@aptre/v86 0.5.0 → 0.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (21) hide show
  1. package/dist/v86.browser.js +1113 -93
  2. package/dist/v86.browser.js.map +4 -4
  3. package/dist/v86.js +1112 -93
  4. package/dist/v86.js.map +4 -4
  5. package/lib/9p.ts +4 -4
  6. package/lib/filesystem.ts +1 -1
  7. package/package.json +7 -7
  8. package/src/browser/starter.ts +53 -23
  9. package/src/const.ts +2 -0
  10. package/src/cpu.ts +128 -98
  11. package/src/pci.ts +8 -3
  12. package/src/ps2.ts +2 -2
  13. package/src/virtio.ts +10 -18
  14. package/src/virtio_mem.ts +349 -0
  15. package/src/virtio_v86fs.ts +873 -0
  16. package/src/rust/gen/analyzer.rs +0 -3807
  17. package/src/rust/gen/analyzer0f.rs +0 -3992
  18. package/src/rust/gen/interpreter.rs +0 -4447
  19. package/src/rust/gen/interpreter0f.rs +0 -5404
  20. package/src/rust/gen/jit.rs +0 -5080
  21. package/src/rust/gen/jit0f.rs +0 -5547
package/src/rust/gen/analyzer.rs DELETED
@@ -1,3807 +0,0 @@
1
- #[cfg_attr(rustfmt, rustfmt_skip)]
2
- use crate::analysis;
3
- use crate::prefix;
4
- use crate::cpu_context;
5
- pub fn analyzer(opcode: u32, cpu: &mut cpu_context::CpuContext, analysis: &mut analysis::Analysis) {
6
- match opcode {
7
- 0x00 | 0x100 => {
8
- let modrm_byte = cpu.read_imm8();
9
- if modrm_byte < 0xC0 {
10
- analysis::modrm_analyze(cpu, modrm_byte);
11
- }
12
- else {
13
- }
14
- },
15
- 0x01 => {
16
- let modrm_byte = cpu.read_imm8();
17
- if modrm_byte < 0xC0 {
18
- analysis::modrm_analyze(cpu, modrm_byte);
19
- }
20
- else {
21
- }
22
- },
23
- 0x101 => {
24
- let modrm_byte = cpu.read_imm8();
25
- if modrm_byte < 0xC0 {
26
- analysis::modrm_analyze(cpu, modrm_byte);
27
- }
28
- else {
29
- }
30
- },
31
- 0x02 | 0x102 => {
32
- let modrm_byte = cpu.read_imm8();
33
- if modrm_byte < 0xC0 {
34
- analysis::modrm_analyze(cpu, modrm_byte);
35
- }
36
- else {
37
- }
38
- },
39
- 0x03 => {
40
- let modrm_byte = cpu.read_imm8();
41
- if modrm_byte < 0xC0 {
42
- analysis::modrm_analyze(cpu, modrm_byte);
43
- }
44
- else {
45
- }
46
- },
47
- 0x103 => {
48
- let modrm_byte = cpu.read_imm8();
49
- if modrm_byte < 0xC0 {
50
- analysis::modrm_analyze(cpu, modrm_byte);
51
- }
52
- else {
53
- }
54
- },
55
- 0x04 | 0x104 => {
56
- cpu.read_imm8();
57
- },
58
- 0x05 => {
59
- cpu.read_imm16();
60
- },
61
- 0x105 => {
62
- cpu.read_imm32();
63
- },
64
- 0x06 => {
65
- },
66
- 0x106 => {
67
- },
68
- 0x07 => {
69
- analysis.ty = analysis::AnalysisType::BlockBoundary;
70
- },
71
- 0x107 => {
72
- analysis.ty = analysis::AnalysisType::BlockBoundary;
73
- },
74
- 0x08 | 0x108 => {
75
- let modrm_byte = cpu.read_imm8();
76
- if modrm_byte < 0xC0 {
77
- analysis::modrm_analyze(cpu, modrm_byte);
78
- }
79
- else {
80
- }
81
- },
82
- 0x09 => {
83
- let modrm_byte = cpu.read_imm8();
84
- if modrm_byte < 0xC0 {
85
- analysis::modrm_analyze(cpu, modrm_byte);
86
- }
87
- else {
88
- }
89
- },
90
- 0x109 => {
91
- let modrm_byte = cpu.read_imm8();
92
- if modrm_byte < 0xC0 {
93
- analysis::modrm_analyze(cpu, modrm_byte);
94
- }
95
- else {
96
- }
97
- },
98
- 0x0A | 0x10A => {
99
- let modrm_byte = cpu.read_imm8();
100
- if modrm_byte < 0xC0 {
101
- analysis::modrm_analyze(cpu, modrm_byte);
102
- }
103
- else {
104
- }
105
- },
106
- 0x0B => {
107
- let modrm_byte = cpu.read_imm8();
108
- if modrm_byte < 0xC0 {
109
- analysis::modrm_analyze(cpu, modrm_byte);
110
- }
111
- else {
112
- }
113
- },
114
- 0x10B => {
115
- let modrm_byte = cpu.read_imm8();
116
- if modrm_byte < 0xC0 {
117
- analysis::modrm_analyze(cpu, modrm_byte);
118
- }
119
- else {
120
- }
121
- },
122
- 0x0C | 0x10C => {
123
- cpu.read_imm8();
124
- },
125
- 0x0D => {
126
- cpu.read_imm16();
127
- },
128
- 0x10D => {
129
- cpu.read_imm32();
130
- },
131
- 0x0E => {
132
- },
133
- 0x10E => {
134
- },
135
- 0x0F => {
136
- analysis::instr16_0F_analyze(cpu, analysis);
137
- },
138
- 0x10F => {
139
- analysis::instr32_0F_analyze(cpu, analysis);
140
- },
141
- 0x10 | 0x110 => {
142
- let modrm_byte = cpu.read_imm8();
143
- if modrm_byte < 0xC0 {
144
- analysis::modrm_analyze(cpu, modrm_byte);
145
- }
146
- else {
147
- }
148
- },
149
- 0x11 => {
150
- let modrm_byte = cpu.read_imm8();
151
- if modrm_byte < 0xC0 {
152
- analysis::modrm_analyze(cpu, modrm_byte);
153
- }
154
- else {
155
- }
156
- },
157
- 0x111 => {
158
- let modrm_byte = cpu.read_imm8();
159
- if modrm_byte < 0xC0 {
160
- analysis::modrm_analyze(cpu, modrm_byte);
161
- }
162
- else {
163
- }
164
- },
165
- 0x12 | 0x112 => {
166
- let modrm_byte = cpu.read_imm8();
167
- if modrm_byte < 0xC0 {
168
- analysis::modrm_analyze(cpu, modrm_byte);
169
- }
170
- else {
171
- }
172
- },
173
- 0x13 => {
174
- let modrm_byte = cpu.read_imm8();
175
- if modrm_byte < 0xC0 {
176
- analysis::modrm_analyze(cpu, modrm_byte);
177
- }
178
- else {
179
- }
180
- },
181
- 0x113 => {
182
- let modrm_byte = cpu.read_imm8();
183
- if modrm_byte < 0xC0 {
184
- analysis::modrm_analyze(cpu, modrm_byte);
185
- }
186
- else {
187
- }
188
- },
189
- 0x14 | 0x114 => {
190
- cpu.read_imm8();
191
- },
192
- 0x15 => {
193
- cpu.read_imm16();
194
- },
195
- 0x115 => {
196
- cpu.read_imm32();
197
- },
198
- 0x16 => {
199
- },
200
- 0x116 => {
201
- },
202
- 0x17 => {
203
- analysis.ty = analysis::AnalysisType::BlockBoundary;
204
- },
205
- 0x117 => {
206
- analysis.ty = analysis::AnalysisType::BlockBoundary;
207
- },
208
- 0x18 | 0x118 => {
209
- let modrm_byte = cpu.read_imm8();
210
- if modrm_byte < 0xC0 {
211
- analysis::modrm_analyze(cpu, modrm_byte);
212
- }
213
- else {
214
- }
215
- },
216
- 0x19 => {
217
- let modrm_byte = cpu.read_imm8();
218
- if modrm_byte < 0xC0 {
219
- analysis::modrm_analyze(cpu, modrm_byte);
220
- }
221
- else {
222
- }
223
- },
224
- 0x119 => {
225
- let modrm_byte = cpu.read_imm8();
226
- if modrm_byte < 0xC0 {
227
- analysis::modrm_analyze(cpu, modrm_byte);
228
- }
229
- else {
230
- }
231
- },
232
- 0x1A | 0x11A => {
233
- let modrm_byte = cpu.read_imm8();
234
- if modrm_byte < 0xC0 {
235
- analysis::modrm_analyze(cpu, modrm_byte);
236
- }
237
- else {
238
- }
239
- },
240
- 0x1B => {
241
- let modrm_byte = cpu.read_imm8();
242
- if modrm_byte < 0xC0 {
243
- analysis::modrm_analyze(cpu, modrm_byte);
244
- }
245
- else {
246
- }
247
- },
248
- 0x11B => {
249
- let modrm_byte = cpu.read_imm8();
250
- if modrm_byte < 0xC0 {
251
- analysis::modrm_analyze(cpu, modrm_byte);
252
- }
253
- else {
254
- }
255
- },
256
- 0x1C | 0x11C => {
257
- cpu.read_imm8();
258
- },
259
- 0x1D => {
260
- cpu.read_imm16();
261
- },
262
- 0x11D => {
263
- cpu.read_imm32();
264
- },
265
- 0x1E => {
266
- },
267
- 0x11E => {
268
- },
269
- 0x1F => {
270
- analysis.ty = analysis::AnalysisType::BlockBoundary;
271
- },
272
- 0x11F => {
273
- analysis.ty = analysis::AnalysisType::BlockBoundary;
274
- },
275
- 0x20 | 0x120 => {
276
- let modrm_byte = cpu.read_imm8();
277
- if modrm_byte < 0xC0 {
278
- analysis::modrm_analyze(cpu, modrm_byte);
279
- }
280
- else {
281
- }
282
- },
283
- 0x21 => {
284
- let modrm_byte = cpu.read_imm8();
285
- if modrm_byte < 0xC0 {
286
- analysis::modrm_analyze(cpu, modrm_byte);
287
- }
288
- else {
289
- }
290
- },
291
- 0x121 => {
292
- let modrm_byte = cpu.read_imm8();
293
- if modrm_byte < 0xC0 {
294
- analysis::modrm_analyze(cpu, modrm_byte);
295
- }
296
- else {
297
- }
298
- },
299
- 0x22 | 0x122 => {
300
- let modrm_byte = cpu.read_imm8();
301
- if modrm_byte < 0xC0 {
302
- analysis::modrm_analyze(cpu, modrm_byte);
303
- }
304
- else {
305
- }
306
- },
307
- 0x23 => {
308
- let modrm_byte = cpu.read_imm8();
309
- if modrm_byte < 0xC0 {
310
- analysis::modrm_analyze(cpu, modrm_byte);
311
- }
312
- else {
313
- }
314
- },
315
- 0x123 => {
316
- let modrm_byte = cpu.read_imm8();
317
- if modrm_byte < 0xC0 {
318
- analysis::modrm_analyze(cpu, modrm_byte);
319
- }
320
- else {
321
- }
322
- },
323
- 0x24 | 0x124 => {
324
- cpu.read_imm8();
325
- },
326
- 0x25 => {
327
- cpu.read_imm16();
328
- },
329
- 0x125 => {
330
- cpu.read_imm32();
331
- },
332
- 0x26 | 0x126 => {
333
- analysis::instr_26_analyze(cpu, analysis);
334
- },
335
- 0x27 | 0x127 => {
336
- },
337
- 0x28 | 0x128 => {
338
- let modrm_byte = cpu.read_imm8();
339
- if modrm_byte < 0xC0 {
340
- analysis::modrm_analyze(cpu, modrm_byte);
341
- }
342
- else {
343
- }
344
- },
345
- 0x29 => {
346
- let modrm_byte = cpu.read_imm8();
347
- if modrm_byte < 0xC0 {
348
- analysis::modrm_analyze(cpu, modrm_byte);
349
- }
350
- else {
351
- }
352
- },
353
- 0x129 => {
354
- let modrm_byte = cpu.read_imm8();
355
- if modrm_byte < 0xC0 {
356
- analysis::modrm_analyze(cpu, modrm_byte);
357
- }
358
- else {
359
- }
360
- },
361
- 0x2A | 0x12A => {
362
- let modrm_byte = cpu.read_imm8();
363
- if modrm_byte < 0xC0 {
364
- analysis::modrm_analyze(cpu, modrm_byte);
365
- }
366
- else {
367
- }
368
- },
369
- 0x2B => {
370
- let modrm_byte = cpu.read_imm8();
371
- if modrm_byte < 0xC0 {
372
- analysis::modrm_analyze(cpu, modrm_byte);
373
- }
374
- else {
375
- }
376
- },
377
- 0x12B => {
378
- let modrm_byte = cpu.read_imm8();
379
- if modrm_byte < 0xC0 {
380
- analysis::modrm_analyze(cpu, modrm_byte);
381
- }
382
- else {
383
- }
384
- },
385
- 0x2C | 0x12C => {
386
- cpu.read_imm8();
387
- },
388
- 0x2D => {
389
- cpu.read_imm16();
390
- },
391
- 0x12D => {
392
- cpu.read_imm32();
393
- },
394
- 0x2E | 0x12E => {
395
- analysis::instr_2E_analyze(cpu, analysis);
396
- },
397
- 0x2F | 0x12F => {
398
- },
399
- 0x30 | 0x130 => {
400
- let modrm_byte = cpu.read_imm8();
401
- if modrm_byte < 0xC0 {
402
- analysis::modrm_analyze(cpu, modrm_byte);
403
- }
404
- else {
405
- }
406
- },
407
- 0x31 => {
408
- let modrm_byte = cpu.read_imm8();
409
- if modrm_byte < 0xC0 {
410
- analysis::modrm_analyze(cpu, modrm_byte);
411
- }
412
- else {
413
- }
414
- },
415
- 0x131 => {
416
- let modrm_byte = cpu.read_imm8();
417
- if modrm_byte < 0xC0 {
418
- analysis::modrm_analyze(cpu, modrm_byte);
419
- }
420
- else {
421
- }
422
- },
423
- 0x32 | 0x132 => {
424
- let modrm_byte = cpu.read_imm8();
425
- if modrm_byte < 0xC0 {
426
- analysis::modrm_analyze(cpu, modrm_byte);
427
- }
428
- else {
429
- }
430
- },
431
- 0x33 => {
432
- let modrm_byte = cpu.read_imm8();
433
- if modrm_byte < 0xC0 {
434
- analysis::modrm_analyze(cpu, modrm_byte);
435
- }
436
- else {
437
- }
438
- },
439
- 0x133 => {
440
- let modrm_byte = cpu.read_imm8();
441
- if modrm_byte < 0xC0 {
442
- analysis::modrm_analyze(cpu, modrm_byte);
443
- }
444
- else {
445
- }
446
- },
447
- 0x34 | 0x134 => {
448
- cpu.read_imm8();
449
- },
450
- 0x35 => {
451
- cpu.read_imm16();
452
- },
453
- 0x135 => {
454
- cpu.read_imm32();
455
- },
456
- 0x36 | 0x136 => {
457
- analysis::instr_36_analyze(cpu, analysis);
458
- },
459
- 0x37 | 0x137 => {
460
- },
461
- 0x38 | 0x138 => {
462
- let modrm_byte = cpu.read_imm8();
463
- if modrm_byte < 0xC0 {
464
- analysis::modrm_analyze(cpu, modrm_byte);
465
- }
466
- else {
467
- }
468
- },
469
- 0x39 => {
470
- let modrm_byte = cpu.read_imm8();
471
- if modrm_byte < 0xC0 {
472
- analysis::modrm_analyze(cpu, modrm_byte);
473
- }
474
- else {
475
- }
476
- },
477
- 0x139 => {
478
- let modrm_byte = cpu.read_imm8();
479
- if modrm_byte < 0xC0 {
480
- analysis::modrm_analyze(cpu, modrm_byte);
481
- }
482
- else {
483
- }
484
- },
485
- 0x3A | 0x13A => {
486
- let modrm_byte = cpu.read_imm8();
487
- if modrm_byte < 0xC0 {
488
- analysis::modrm_analyze(cpu, modrm_byte);
489
- }
490
- else {
491
- }
492
- },
493
- 0x3B => {
494
- let modrm_byte = cpu.read_imm8();
495
- if modrm_byte < 0xC0 {
496
- analysis::modrm_analyze(cpu, modrm_byte);
497
- }
498
- else {
499
- }
500
- },
501
- 0x13B => {
502
- let modrm_byte = cpu.read_imm8();
503
- if modrm_byte < 0xC0 {
504
- analysis::modrm_analyze(cpu, modrm_byte);
505
- }
506
- else {
507
- }
508
- },
509
- 0x3C | 0x13C => {
510
- cpu.read_imm8();
511
- },
512
- 0x3D => {
513
- cpu.read_imm16();
514
- },
515
- 0x13D => {
516
- cpu.read_imm32();
517
- },
518
- 0x3E | 0x13E => {
519
- analysis::instr_3E_analyze(cpu, analysis);
520
- },
521
- 0x3F | 0x13F => {
522
- },
523
- 0x40 => {
524
- },
525
- 0x140 => {
526
- },
527
- 0x41 => {
528
- },
529
- 0x141 => {
530
- },
531
- 0x42 => {
532
- },
533
- 0x142 => {
534
- },
535
- 0x43 => {
536
- },
537
- 0x143 => {
538
- },
539
- 0x44 => {
540
- },
541
- 0x144 => {
542
- },
543
- 0x45 => {
544
- },
545
- 0x145 => {
546
- },
547
- 0x46 => {
548
- },
549
- 0x146 => {
550
- },
551
- 0x47 => {
552
- },
553
- 0x147 => {
554
- },
555
- 0x48 => {
556
- },
557
- 0x148 => {
558
- },
559
- 0x49 => {
560
- },
561
- 0x149 => {
562
- },
563
- 0x4A => {
564
- },
565
- 0x14A => {
566
- },
567
- 0x4B => {
568
- },
569
- 0x14B => {
570
- },
571
- 0x4C => {
572
- },
573
- 0x14C => {
574
- },
575
- 0x4D => {
576
- },
577
- 0x14D => {
578
- },
579
- 0x4E => {
580
- },
581
- 0x14E => {
582
- },
583
- 0x4F => {
584
- },
585
- 0x14F => {
586
- },
587
- 0x50 => {
588
- },
589
- 0x150 => {
590
- },
591
- 0x51 => {
592
- },
593
- 0x151 => {
594
- },
595
- 0x52 => {
596
- },
597
- 0x152 => {
598
- },
599
- 0x53 => {
600
- },
601
- 0x153 => {
602
- },
603
- 0x54 => {
604
- },
605
- 0x154 => {
606
- },
607
- 0x55 => {
608
- },
609
- 0x155 => {
610
- },
611
- 0x56 => {
612
- },
613
- 0x156 => {
614
- },
615
- 0x57 => {
616
- },
617
- 0x157 => {
618
- },
619
- 0x58 => {
620
- },
621
- 0x158 => {
622
- },
623
- 0x59 => {
624
- },
625
- 0x159 => {
626
- },
627
- 0x5A => {
628
- },
629
- 0x15A => {
630
- },
631
- 0x5B => {
632
- },
633
- 0x15B => {
634
- },
635
- 0x5C => {
636
- },
637
- 0x15C => {
638
- },
639
- 0x5D => {
640
- },
641
- 0x15D => {
642
- },
643
- 0x5E => {
644
- },
645
- 0x15E => {
646
- },
647
- 0x5F => {
648
- },
649
- 0x15F => {
650
- },
651
- 0x60 => {
652
- analysis.ty = analysis::AnalysisType::BlockBoundary;
653
- },
654
- 0x160 => {
655
- analysis.ty = analysis::AnalysisType::BlockBoundary;
656
- },
657
- 0x61 => {
658
- analysis.ty = analysis::AnalysisType::BlockBoundary;
659
- },
660
- 0x161 => {
661
- analysis.ty = analysis::AnalysisType::BlockBoundary;
662
- },
663
- 0x62 | 0x162 => {
664
- let modrm_byte = cpu.read_imm8();
665
- if modrm_byte < 0xC0 {
666
- analysis::modrm_analyze(cpu, modrm_byte);
667
- }
668
- else {
669
- }
670
- analysis.ty = analysis::AnalysisType::BlockBoundary;
671
- },
672
- 0x63 | 0x163 => {
673
- let modrm_byte = cpu.read_imm8();
674
- if modrm_byte < 0xC0 {
675
- analysis::modrm_analyze(cpu, modrm_byte);
676
- }
677
- else {
678
- }
679
- analysis.ty = analysis::AnalysisType::BlockBoundary;
680
- },
681
- 0x64 | 0x164 => {
682
- analysis::instr_64_analyze(cpu, analysis);
683
- },
684
- 0x65 | 0x165 => {
685
- analysis::instr_65_analyze(cpu, analysis);
686
- },
687
- 0x66 | 0x166 => {
688
- analysis::instr_66_analyze(cpu, analysis);
689
- },
690
- 0x67 | 0x167 => {
691
- analysis::instr_67_analyze(cpu, analysis);
692
- },
693
- 0x68 => {
694
- cpu.read_imm16();
695
- },
696
- 0x168 => {
697
- cpu.read_imm32();
698
- },
699
- 0x69 => {
700
- let modrm_byte = cpu.read_imm8();
701
- if modrm_byte < 0xC0 {
702
- analysis::modrm_analyze(cpu, modrm_byte);
703
- }
704
- else {
705
- }
706
- cpu.read_imm16();
707
- },
708
- 0x169 => {
709
- let modrm_byte = cpu.read_imm8();
710
- if modrm_byte < 0xC0 {
711
- analysis::modrm_analyze(cpu, modrm_byte);
712
- }
713
- else {
714
- }
715
- cpu.read_imm32();
716
- },
717
- 0x6A => {
718
- cpu.read_imm8s();
719
- },
720
- 0x16A => {
721
- cpu.read_imm8s();
722
- },
723
- 0x6B => {
724
- let modrm_byte = cpu.read_imm8();
725
- if modrm_byte < 0xC0 {
726
- analysis::modrm_analyze(cpu, modrm_byte);
727
- }
728
- else {
729
- }
730
- cpu.read_imm8s();
731
- },
732
- 0x16B => {
733
- let modrm_byte = cpu.read_imm8();
734
- if modrm_byte < 0xC0 {
735
- analysis::modrm_analyze(cpu, modrm_byte);
736
- }
737
- else {
738
- }
739
- cpu.read_imm8s();
740
- },
741
- 0x6C | 0x16C => {
742
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
743
- analysis.ty = analysis::AnalysisType::BlockBoundary;
744
- }
745
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
746
- analysis.ty = analysis::AnalysisType::BlockBoundary;
747
- }
748
- else {
749
- analysis.ty = analysis::AnalysisType::BlockBoundary;
750
- }
751
- },
752
- 0x6D => {
753
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
754
- analysis.ty = analysis::AnalysisType::BlockBoundary;
755
- }
756
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
757
- analysis.ty = analysis::AnalysisType::BlockBoundary;
758
- }
759
- else {
760
- analysis.ty = analysis::AnalysisType::BlockBoundary;
761
- }
762
- },
763
- 0x16D => {
764
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
765
- analysis.ty = analysis::AnalysisType::BlockBoundary;
766
- }
767
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
768
- analysis.ty = analysis::AnalysisType::BlockBoundary;
769
- }
770
- else {
771
- analysis.ty = analysis::AnalysisType::BlockBoundary;
772
- }
773
- },
774
- 0x6E | 0x16E => {
775
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
776
- analysis.ty = analysis::AnalysisType::BlockBoundary;
777
- }
778
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
779
- analysis.ty = analysis::AnalysisType::BlockBoundary;
780
- }
781
- else {
782
- analysis.ty = analysis::AnalysisType::BlockBoundary;
783
- }
784
- },
785
- 0x6F => {
786
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
787
- analysis.ty = analysis::AnalysisType::BlockBoundary;
788
- }
789
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
790
- analysis.ty = analysis::AnalysisType::BlockBoundary;
791
- }
792
- else {
793
- analysis.ty = analysis::AnalysisType::BlockBoundary;
794
- }
795
- },
796
- 0x16F => {
797
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
798
- analysis.ty = analysis::AnalysisType::BlockBoundary;
799
- }
800
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
801
- analysis.ty = analysis::AnalysisType::BlockBoundary;
802
- }
803
- else {
804
- analysis.ty = analysis::AnalysisType::BlockBoundary;
805
- }
806
- },
807
- 0x70 => {
808
- let jump_offset = cpu.read_imm8s();
809
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x70), is_32: cpu.osize_32() };
810
- },
811
- 0x170 => {
812
- let jump_offset = cpu.read_imm8s();
813
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x70), is_32: cpu.osize_32() };
814
- },
815
- 0x71 => {
816
- let jump_offset = cpu.read_imm8s();
817
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x71), is_32: cpu.osize_32() };
818
- },
819
- 0x171 => {
820
- let jump_offset = cpu.read_imm8s();
821
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x71), is_32: cpu.osize_32() };
822
- },
823
- 0x72 => {
824
- let jump_offset = cpu.read_imm8s();
825
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x72), is_32: cpu.osize_32() };
826
- },
827
- 0x172 => {
828
- let jump_offset = cpu.read_imm8s();
829
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x72), is_32: cpu.osize_32() };
830
- },
831
- 0x73 => {
832
- let jump_offset = cpu.read_imm8s();
833
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x73), is_32: cpu.osize_32() };
834
- },
835
- 0x173 => {
836
- let jump_offset = cpu.read_imm8s();
837
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x73), is_32: cpu.osize_32() };
838
- },
839
- 0x74 => {
840
- let jump_offset = cpu.read_imm8s();
841
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x74), is_32: cpu.osize_32() };
842
- },
843
- 0x174 => {
844
- let jump_offset = cpu.read_imm8s();
845
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x74), is_32: cpu.osize_32() };
846
- },
847
- 0x75 => {
848
- let jump_offset = cpu.read_imm8s();
849
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x75), is_32: cpu.osize_32() };
850
- },
851
- 0x175 => {
852
- let jump_offset = cpu.read_imm8s();
853
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x75), is_32: cpu.osize_32() };
854
- },
855
- 0x76 => {
856
- let jump_offset = cpu.read_imm8s();
857
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x76), is_32: cpu.osize_32() };
858
- },
859
- 0x176 => {
860
- let jump_offset = cpu.read_imm8s();
861
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x76), is_32: cpu.osize_32() };
862
- },
863
- 0x77 => {
864
- let jump_offset = cpu.read_imm8s();
865
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x77), is_32: cpu.osize_32() };
866
- },
867
- 0x177 => {
868
- let jump_offset = cpu.read_imm8s();
869
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x77), is_32: cpu.osize_32() };
870
- },
871
- 0x78 => {
872
- let jump_offset = cpu.read_imm8s();
873
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x78), is_32: cpu.osize_32() };
874
- },
875
- 0x178 => {
876
- let jump_offset = cpu.read_imm8s();
877
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x78), is_32: cpu.osize_32() };
878
- },
879
- 0x79 => {
880
- let jump_offset = cpu.read_imm8s();
881
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x79), is_32: cpu.osize_32() };
882
- },
883
- 0x179 => {
884
- let jump_offset = cpu.read_imm8s();
885
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x79), is_32: cpu.osize_32() };
886
- },
887
- 0x7A => {
888
- let jump_offset = cpu.read_imm8s();
889
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7A), is_32: cpu.osize_32() };
890
- },
891
- 0x17A => {
892
- let jump_offset = cpu.read_imm8s();
893
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7A), is_32: cpu.osize_32() };
894
- },
895
- 0x7B => {
896
- let jump_offset = cpu.read_imm8s();
897
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7B), is_32: cpu.osize_32() };
898
- },
899
- 0x17B => {
900
- let jump_offset = cpu.read_imm8s();
901
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7B), is_32: cpu.osize_32() };
902
- },
903
- 0x7C => {
904
- let jump_offset = cpu.read_imm8s();
905
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7C), is_32: cpu.osize_32() };
906
- },
907
- 0x17C => {
908
- let jump_offset = cpu.read_imm8s();
909
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7C), is_32: cpu.osize_32() };
910
- },
911
- 0x7D => {
912
- let jump_offset = cpu.read_imm8s();
913
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7D), is_32: cpu.osize_32() };
914
- },
915
- 0x17D => {
916
- let jump_offset = cpu.read_imm8s();
917
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7D), is_32: cpu.osize_32() };
918
- },
919
- 0x7E => {
920
- let jump_offset = cpu.read_imm8s();
921
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7E), is_32: cpu.osize_32() };
922
- },
923
- 0x17E => {
924
- let jump_offset = cpu.read_imm8s();
925
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7E), is_32: cpu.osize_32() };
926
- },
927
- 0x7F => {
928
- let jump_offset = cpu.read_imm8s();
929
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7F), is_32: cpu.osize_32() };
930
- },
931
- 0x17F => {
932
- let jump_offset = cpu.read_imm8s();
933
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0x7F), is_32: cpu.osize_32() };
934
- },
935
- 0x80 | 0x180 => {
936
- let modrm_byte = cpu.read_imm8();
937
- match modrm_byte >> 3 & 7 {
938
- 0 => {
939
- if modrm_byte < 0xC0 {
940
- analysis::modrm_analyze(cpu, modrm_byte);
941
- }
942
- else {
943
- }
944
- cpu.read_imm8();
945
- },
946
- 1 => {
947
- if modrm_byte < 0xC0 {
948
- analysis::modrm_analyze(cpu, modrm_byte);
949
- }
950
- else {
951
- }
952
- cpu.read_imm8();
953
- },
954
- 2 => {
955
- if modrm_byte < 0xC0 {
956
- analysis::modrm_analyze(cpu, modrm_byte);
957
- }
958
- else {
959
- }
960
- cpu.read_imm8();
961
- },
962
- 3 => {
963
- if modrm_byte < 0xC0 {
964
- analysis::modrm_analyze(cpu, modrm_byte);
965
- }
966
- else {
967
- }
968
- cpu.read_imm8();
969
- },
970
- 4 => {
971
- if modrm_byte < 0xC0 {
972
- analysis::modrm_analyze(cpu, modrm_byte);
973
- }
974
- else {
975
- }
976
- cpu.read_imm8();
977
- },
978
- 5 => {
979
- if modrm_byte < 0xC0 {
980
- analysis::modrm_analyze(cpu, modrm_byte);
981
- }
982
- else {
983
- }
984
- cpu.read_imm8();
985
- },
986
- 6 => {
987
- if modrm_byte < 0xC0 {
988
- analysis::modrm_analyze(cpu, modrm_byte);
989
- }
990
- else {
991
- }
992
- cpu.read_imm8();
993
- },
994
- 7 => {
995
- if modrm_byte < 0xC0 {
996
- analysis::modrm_analyze(cpu, modrm_byte);
997
- }
998
- else {
999
- }
1000
- cpu.read_imm8();
1001
- },
1002
- _ => {
1003
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1004
- analysis.no_next_instruction = true;
1005
- }
1006
- }
1007
- },
1008
- 0x81 => {
1009
- let modrm_byte = cpu.read_imm8();
1010
- match modrm_byte >> 3 & 7 {
1011
- 0 => {
1012
- if modrm_byte < 0xC0 {
1013
- analysis::modrm_analyze(cpu, modrm_byte);
1014
- }
1015
- else {
1016
- }
1017
- cpu.read_imm16();
1018
- },
1019
- 1 => {
1020
- if modrm_byte < 0xC0 {
1021
- analysis::modrm_analyze(cpu, modrm_byte);
1022
- }
1023
- else {
1024
- }
1025
- cpu.read_imm16();
1026
- },
1027
- 2 => {
1028
- if modrm_byte < 0xC0 {
1029
- analysis::modrm_analyze(cpu, modrm_byte);
1030
- }
1031
- else {
1032
- }
1033
- cpu.read_imm16();
1034
- },
1035
- 3 => {
1036
- if modrm_byte < 0xC0 {
1037
- analysis::modrm_analyze(cpu, modrm_byte);
1038
- }
1039
- else {
1040
- }
1041
- cpu.read_imm16();
1042
- },
1043
- 4 => {
1044
- if modrm_byte < 0xC0 {
1045
- analysis::modrm_analyze(cpu, modrm_byte);
1046
- }
1047
- else {
1048
- }
1049
- cpu.read_imm16();
1050
- },
1051
- 5 => {
1052
- if modrm_byte < 0xC0 {
1053
- analysis::modrm_analyze(cpu, modrm_byte);
1054
- }
1055
- else {
1056
- }
1057
- cpu.read_imm16();
1058
- },
1059
- 6 => {
1060
- if modrm_byte < 0xC0 {
1061
- analysis::modrm_analyze(cpu, modrm_byte);
1062
- }
1063
- else {
1064
- }
1065
- cpu.read_imm16();
1066
- },
1067
- 7 => {
1068
- if modrm_byte < 0xC0 {
1069
- analysis::modrm_analyze(cpu, modrm_byte);
1070
- }
1071
- else {
1072
- }
1073
- cpu.read_imm16();
1074
- },
1075
- _ => {
1076
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1077
- analysis.no_next_instruction = true;
1078
- }
1079
- }
1080
- },
1081
- 0x181 => {
1082
- let modrm_byte = cpu.read_imm8();
1083
- match modrm_byte >> 3 & 7 {
1084
- 0 => {
1085
- if modrm_byte < 0xC0 {
1086
- analysis::modrm_analyze(cpu, modrm_byte);
1087
- }
1088
- else {
1089
- }
1090
- cpu.read_imm32();
1091
- },
1092
- 1 => {
1093
- if modrm_byte < 0xC0 {
1094
- analysis::modrm_analyze(cpu, modrm_byte);
1095
- }
1096
- else {
1097
- }
1098
- cpu.read_imm32();
1099
- },
1100
- 2 => {
1101
- if modrm_byte < 0xC0 {
1102
- analysis::modrm_analyze(cpu, modrm_byte);
1103
- }
1104
- else {
1105
- }
1106
- cpu.read_imm32();
1107
- },
1108
- 3 => {
1109
- if modrm_byte < 0xC0 {
1110
- analysis::modrm_analyze(cpu, modrm_byte);
1111
- }
1112
- else {
1113
- }
1114
- cpu.read_imm32();
1115
- },
1116
- 4 => {
1117
- if modrm_byte < 0xC0 {
1118
- analysis::modrm_analyze(cpu, modrm_byte);
1119
- }
1120
- else {
1121
- }
1122
- cpu.read_imm32();
1123
- },
1124
- 5 => {
1125
- if modrm_byte < 0xC0 {
1126
- analysis::modrm_analyze(cpu, modrm_byte);
1127
- }
1128
- else {
1129
- }
1130
- cpu.read_imm32();
1131
- },
1132
- 6 => {
1133
- if modrm_byte < 0xC0 {
1134
- analysis::modrm_analyze(cpu, modrm_byte);
1135
- }
1136
- else {
1137
- }
1138
- cpu.read_imm32();
1139
- },
1140
- 7 => {
1141
- if modrm_byte < 0xC0 {
1142
- analysis::modrm_analyze(cpu, modrm_byte);
1143
- }
1144
- else {
1145
- }
1146
- cpu.read_imm32();
1147
- },
1148
- _ => {
1149
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1150
- analysis.no_next_instruction = true;
1151
- }
1152
- }
1153
- },
1154
- 0x82 | 0x182 => {
1155
- let modrm_byte = cpu.read_imm8();
1156
- match modrm_byte >> 3 & 7 {
1157
- 0 => {
1158
- if modrm_byte < 0xC0 {
1159
- analysis::modrm_analyze(cpu, modrm_byte);
1160
- }
1161
- else {
1162
- }
1163
- cpu.read_imm8();
1164
- },
1165
- 1 => {
1166
- if modrm_byte < 0xC0 {
1167
- analysis::modrm_analyze(cpu, modrm_byte);
1168
- }
1169
- else {
1170
- }
1171
- cpu.read_imm8();
1172
- },
1173
- 2 => {
1174
- if modrm_byte < 0xC0 {
1175
- analysis::modrm_analyze(cpu, modrm_byte);
1176
- }
1177
- else {
1178
- }
1179
- cpu.read_imm8();
1180
- },
1181
- 3 => {
1182
- if modrm_byte < 0xC0 {
1183
- analysis::modrm_analyze(cpu, modrm_byte);
1184
- }
1185
- else {
1186
- }
1187
- cpu.read_imm8();
1188
- },
1189
- 4 => {
1190
- if modrm_byte < 0xC0 {
1191
- analysis::modrm_analyze(cpu, modrm_byte);
1192
- }
1193
- else {
1194
- }
1195
- cpu.read_imm8();
1196
- },
1197
- 5 => {
1198
- if modrm_byte < 0xC0 {
1199
- analysis::modrm_analyze(cpu, modrm_byte);
1200
- }
1201
- else {
1202
- }
1203
- cpu.read_imm8();
1204
- },
1205
- 6 => {
1206
- if modrm_byte < 0xC0 {
1207
- analysis::modrm_analyze(cpu, modrm_byte);
1208
- }
1209
- else {
1210
- }
1211
- cpu.read_imm8();
1212
- },
1213
- 7 => {
1214
- if modrm_byte < 0xC0 {
1215
- analysis::modrm_analyze(cpu, modrm_byte);
1216
- }
1217
- else {
1218
- }
1219
- cpu.read_imm8();
1220
- },
1221
- _ => {
1222
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1223
- analysis.no_next_instruction = true;
1224
- }
1225
- }
1226
- },
1227
- 0x83 => {
1228
- let modrm_byte = cpu.read_imm8();
1229
- match modrm_byte >> 3 & 7 {
1230
- 0 => {
1231
- if modrm_byte < 0xC0 {
1232
- analysis::modrm_analyze(cpu, modrm_byte);
1233
- }
1234
- else {
1235
- }
1236
- cpu.read_imm8s();
1237
- },
1238
- 1 => {
1239
- if modrm_byte < 0xC0 {
1240
- analysis::modrm_analyze(cpu, modrm_byte);
1241
- }
1242
- else {
1243
- }
1244
- cpu.read_imm8s();
1245
- },
1246
- 2 => {
1247
- if modrm_byte < 0xC0 {
1248
- analysis::modrm_analyze(cpu, modrm_byte);
1249
- }
1250
- else {
1251
- }
1252
- cpu.read_imm8s();
1253
- },
1254
- 3 => {
1255
- if modrm_byte < 0xC0 {
1256
- analysis::modrm_analyze(cpu, modrm_byte);
1257
- }
1258
- else {
1259
- }
1260
- cpu.read_imm8s();
1261
- },
1262
- 4 => {
1263
- if modrm_byte < 0xC0 {
1264
- analysis::modrm_analyze(cpu, modrm_byte);
1265
- }
1266
- else {
1267
- }
1268
- cpu.read_imm8s();
1269
- },
1270
- 5 => {
1271
- if modrm_byte < 0xC0 {
1272
- analysis::modrm_analyze(cpu, modrm_byte);
1273
- }
1274
- else {
1275
- }
1276
- cpu.read_imm8s();
1277
- },
1278
- 6 => {
1279
- if modrm_byte < 0xC0 {
1280
- analysis::modrm_analyze(cpu, modrm_byte);
1281
- }
1282
- else {
1283
- }
1284
- cpu.read_imm8s();
1285
- },
1286
- 7 => {
1287
- if modrm_byte < 0xC0 {
1288
- analysis::modrm_analyze(cpu, modrm_byte);
1289
- }
1290
- else {
1291
- }
1292
- cpu.read_imm8s();
1293
- },
1294
- _ => {
1295
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1296
- analysis.no_next_instruction = true;
1297
- }
1298
- }
1299
- },
1300
- 0x183 => {
1301
- let modrm_byte = cpu.read_imm8();
1302
- match modrm_byte >> 3 & 7 {
1303
- 0 => {
1304
- if modrm_byte < 0xC0 {
1305
- analysis::modrm_analyze(cpu, modrm_byte);
1306
- }
1307
- else {
1308
- }
1309
- cpu.read_imm8s();
1310
- },
1311
- 1 => {
1312
- if modrm_byte < 0xC0 {
1313
- analysis::modrm_analyze(cpu, modrm_byte);
1314
- }
1315
- else {
1316
- }
1317
- cpu.read_imm8s();
1318
- },
1319
- 2 => {
1320
- if modrm_byte < 0xC0 {
1321
- analysis::modrm_analyze(cpu, modrm_byte);
1322
- }
1323
- else {
1324
- }
1325
- cpu.read_imm8s();
1326
- },
1327
- 3 => {
1328
- if modrm_byte < 0xC0 {
1329
- analysis::modrm_analyze(cpu, modrm_byte);
1330
- }
1331
- else {
1332
- }
1333
- cpu.read_imm8s();
1334
- },
1335
- 4 => {
1336
- if modrm_byte < 0xC0 {
1337
- analysis::modrm_analyze(cpu, modrm_byte);
1338
- }
1339
- else {
1340
- }
1341
- cpu.read_imm8s();
1342
- },
1343
- 5 => {
1344
- if modrm_byte < 0xC0 {
1345
- analysis::modrm_analyze(cpu, modrm_byte);
1346
- }
1347
- else {
1348
- }
1349
- cpu.read_imm8s();
1350
- },
1351
- 6 => {
1352
- if modrm_byte < 0xC0 {
1353
- analysis::modrm_analyze(cpu, modrm_byte);
1354
- }
1355
- else {
1356
- }
1357
- cpu.read_imm8s();
1358
- },
1359
- 7 => {
1360
- if modrm_byte < 0xC0 {
1361
- analysis::modrm_analyze(cpu, modrm_byte);
1362
- }
1363
- else {
1364
- }
1365
- cpu.read_imm8s();
1366
- },
1367
- _ => {
1368
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1369
- analysis.no_next_instruction = true;
1370
- }
1371
- }
1372
- },
1373
- 0x84 | 0x184 => {
1374
- let modrm_byte = cpu.read_imm8();
1375
- if modrm_byte < 0xC0 {
1376
- analysis::modrm_analyze(cpu, modrm_byte);
1377
- }
1378
- else {
1379
- }
1380
- },
1381
- 0x85 => {
1382
- let modrm_byte = cpu.read_imm8();
1383
- if modrm_byte < 0xC0 {
1384
- analysis::modrm_analyze(cpu, modrm_byte);
1385
- }
1386
- else {
1387
- }
1388
- },
1389
- 0x185 => {
1390
- let modrm_byte = cpu.read_imm8();
1391
- if modrm_byte < 0xC0 {
1392
- analysis::modrm_analyze(cpu, modrm_byte);
1393
- }
1394
- else {
1395
- }
1396
- },
1397
- 0x86 | 0x186 => {
1398
- let modrm_byte = cpu.read_imm8();
1399
- if modrm_byte < 0xC0 {
1400
- analysis::modrm_analyze(cpu, modrm_byte);
1401
- }
1402
- else {
1403
- }
1404
- },
1405
- 0x87 => {
1406
- let modrm_byte = cpu.read_imm8();
1407
- if modrm_byte < 0xC0 {
1408
- analysis::modrm_analyze(cpu, modrm_byte);
1409
- }
1410
- else {
1411
- }
1412
- },
1413
- 0x187 => {
1414
- let modrm_byte = cpu.read_imm8();
1415
- if modrm_byte < 0xC0 {
1416
- analysis::modrm_analyze(cpu, modrm_byte);
1417
- }
1418
- else {
1419
- }
1420
- },
1421
- 0x88 | 0x188 => {
1422
- let modrm_byte = cpu.read_imm8();
1423
- if modrm_byte < 0xC0 {
1424
- analysis::modrm_analyze(cpu, modrm_byte);
1425
- }
1426
- else {
1427
- }
1428
- },
1429
- 0x89 => {
1430
- let modrm_byte = cpu.read_imm8();
1431
- if modrm_byte < 0xC0 {
1432
- analysis::modrm_analyze(cpu, modrm_byte);
1433
- }
1434
- else {
1435
- }
1436
- },
1437
- 0x189 => {
1438
- let modrm_byte = cpu.read_imm8();
1439
- if modrm_byte < 0xC0 {
1440
- analysis::modrm_analyze(cpu, modrm_byte);
1441
- }
1442
- else {
1443
- }
1444
- },
1445
- 0x8A | 0x18A => {
1446
- let modrm_byte = cpu.read_imm8();
1447
- if modrm_byte < 0xC0 {
1448
- analysis::modrm_analyze(cpu, modrm_byte);
1449
- }
1450
- else {
1451
- }
1452
- },
1453
- 0x8B => {
1454
- let modrm_byte = cpu.read_imm8();
1455
- if modrm_byte < 0xC0 {
1456
- analysis::modrm_analyze(cpu, modrm_byte);
1457
- }
1458
- else {
1459
- }
1460
- },
1461
- 0x18B => {
1462
- let modrm_byte = cpu.read_imm8();
1463
- if modrm_byte < 0xC0 {
1464
- analysis::modrm_analyze(cpu, modrm_byte);
1465
- }
1466
- else {
1467
- }
1468
- },
1469
- 0x8C => {
1470
- let modrm_byte = cpu.read_imm8();
1471
- if modrm_byte < 0xC0 {
1472
- analysis::modrm_analyze(cpu, modrm_byte);
1473
- }
1474
- else {
1475
- }
1476
- },
1477
- 0x18C => {
1478
- let modrm_byte = cpu.read_imm8();
1479
- if modrm_byte < 0xC0 {
1480
- analysis::modrm_analyze(cpu, modrm_byte);
1481
- }
1482
- else {
1483
- }
1484
- },
1485
- 0x8D => {
1486
- let modrm_byte = cpu.read_imm8();
1487
- if modrm_byte < 0xC0 {
1488
- analysis::modrm_analyze(cpu, modrm_byte);
1489
- }
1490
- else {
1491
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1492
- }
1493
- },
1494
- 0x18D => {
1495
- let modrm_byte = cpu.read_imm8();
1496
- if modrm_byte < 0xC0 {
1497
- analysis::modrm_analyze(cpu, modrm_byte);
1498
- }
1499
- else {
1500
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1501
- }
1502
- },
1503
- 0x8E | 0x18E => {
1504
- let modrm_byte = cpu.read_imm8();
1505
- if modrm_byte < 0xC0 {
1506
- analysis::modrm_analyze(cpu, modrm_byte);
1507
- }
1508
- else {
1509
- }
1510
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1511
- },
1512
- 0x8F => {
1513
- let modrm_byte = cpu.read_imm8();
1514
- match modrm_byte >> 3 & 7 {
1515
- 0 => {
1516
- if modrm_byte < 0xC0 {
1517
- analysis::modrm_analyze(cpu, modrm_byte);
1518
- }
1519
- else {
1520
- }
1521
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1522
- },
1523
- _ => {
1524
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1525
- analysis.no_next_instruction = true;
1526
- }
1527
- }
1528
- },
1529
- 0x18F => {
1530
- let modrm_byte = cpu.read_imm8();
1531
- match modrm_byte >> 3 & 7 {
1532
- 0 => {
1533
- if modrm_byte < 0xC0 {
1534
- analysis::modrm_analyze(cpu, modrm_byte);
1535
- }
1536
- else {
1537
- }
1538
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1539
- },
1540
- _ => {
1541
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1542
- analysis.no_next_instruction = true;
1543
- }
1544
- }
1545
- },
1546
- 0x90 | 0x190 => {
1547
- },
1548
- 0x91 => {
1549
- },
1550
- 0x191 => {
1551
- },
1552
- 0x92 => {
1553
- },
1554
- 0x192 => {
1555
- },
1556
- 0x93 => {
1557
- },
1558
- 0x193 => {
1559
- },
1560
- 0x94 => {
1561
- },
1562
- 0x194 => {
1563
- },
1564
- 0x95 => {
1565
- },
1566
- 0x195 => {
1567
- },
1568
- 0x96 => {
1569
- },
1570
- 0x196 => {
1571
- },
1572
- 0x97 => {
1573
- },
1574
- 0x197 => {
1575
- },
1576
- 0x98 => {
1577
- },
1578
- 0x198 => {
1579
- },
1580
- 0x99 => {
1581
- },
1582
- 0x199 => {
1583
- },
1584
- 0x9A => {
1585
- cpu.read_imm16();
1586
- cpu.read_imm16();
1587
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1588
- },
1589
- 0x19A => {
1590
- cpu.read_imm32();
1591
- cpu.read_imm16();
1592
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1593
- },
1594
- 0x9B | 0x19B => {
1595
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1596
- },
1597
- 0x9C => {
1598
- },
1599
- 0x19C => {
1600
- },
1601
- 0x9D => {
1602
- },
1603
- 0x19D => {
1604
- },
1605
- 0x9E | 0x19E => {
1606
- },
1607
- 0x9F | 0x19F => {
1608
- },
1609
- 0xA0 | 0x1A0 => {
1610
- cpu.read_moffs();
1611
- },
1612
- 0xA1 => {
1613
- cpu.read_moffs();
1614
- },
1615
- 0x1A1 => {
1616
- cpu.read_moffs();
1617
- },
1618
- 0xA2 | 0x1A2 => {
1619
- cpu.read_moffs();
1620
- },
1621
- 0xA3 => {
1622
- cpu.read_moffs();
1623
- },
1624
- 0x1A3 => {
1625
- cpu.read_moffs();
1626
- },
1627
- 0xA4 | 0x1A4 => {
1628
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1629
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1630
- }
1631
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1632
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1633
- }
1634
- else {
1635
- }
1636
- },
1637
- 0xA5 => {
1638
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1639
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1640
- }
1641
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1642
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1643
- }
1644
- else {
1645
- }
1646
- },
1647
- 0x1A5 => {
1648
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1649
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1650
- }
1651
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1652
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1653
- }
1654
- else {
1655
- }
1656
- },
1657
- 0xA6 | 0x1A6 => {
1658
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1659
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1660
- }
1661
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1662
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1663
- }
1664
- else {
1665
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1666
- }
1667
- },
1668
- 0xA7 => {
1669
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1670
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1671
- }
1672
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1673
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1674
- }
1675
- else {
1676
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1677
- }
1678
- },
1679
- 0x1A7 => {
1680
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1681
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1682
- }
1683
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1684
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1685
- }
1686
- else {
1687
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1688
- }
1689
- },
1690
- 0xA8 | 0x1A8 => {
1691
- cpu.read_imm8();
1692
- },
1693
- 0xA9 => {
1694
- cpu.read_imm16();
1695
- },
1696
- 0x1A9 => {
1697
- cpu.read_imm32();
1698
- },
1699
- 0xAA | 0x1AA => {
1700
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1701
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1702
- }
1703
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1704
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1705
- }
1706
- else {
1707
- }
1708
- },
1709
- 0xAB => {
1710
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1711
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1712
- }
1713
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1714
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1715
- }
1716
- else {
1717
- }
1718
- },
1719
- 0x1AB => {
1720
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1721
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1722
- }
1723
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1724
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1725
- }
1726
- else {
1727
- }
1728
- },
1729
- 0xAC | 0x1AC => {
1730
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1731
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1732
- }
1733
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1734
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1735
- }
1736
- else {
1737
- }
1738
- },
1739
- 0xAD => {
1740
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1741
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1742
- }
1743
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1744
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1745
- }
1746
- else {
1747
- }
1748
- },
1749
- 0x1AD => {
1750
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1751
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1752
- }
1753
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1754
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1755
- }
1756
- else {
1757
- }
1758
- },
1759
- 0xAE | 0x1AE => {
1760
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1761
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1762
- }
1763
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1764
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1765
- }
1766
- else {
1767
- }
1768
- },
1769
- 0xAF => {
1770
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1771
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1772
- }
1773
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1774
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1775
- }
1776
- else {
1777
- }
1778
- },
1779
- 0x1AF => {
1780
- if cpu.prefixes & prefix::PREFIX_F2 != 0 {
1781
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1782
- }
1783
- else if cpu.prefixes & prefix::PREFIX_F3 != 0 {
1784
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1785
- }
1786
- else {
1787
- }
1788
- },
1789
- 0xB0 | 0x1B0 => {
1790
- cpu.read_imm8();
1791
- },
1792
- 0xB1 | 0x1B1 => {
1793
- cpu.read_imm8();
1794
- },
1795
- 0xB2 | 0x1B2 => {
1796
- cpu.read_imm8();
1797
- },
1798
- 0xB3 | 0x1B3 => {
1799
- cpu.read_imm8();
1800
- },
1801
- 0xB4 | 0x1B4 => {
1802
- cpu.read_imm8();
1803
- },
1804
- 0xB5 | 0x1B5 => {
1805
- cpu.read_imm8();
1806
- },
1807
- 0xB6 | 0x1B6 => {
1808
- cpu.read_imm8();
1809
- },
1810
- 0xB7 | 0x1B7 => {
1811
- cpu.read_imm8();
1812
- },
1813
- 0xB8 => {
1814
- cpu.read_imm16();
1815
- },
1816
- 0x1B8 => {
1817
- cpu.read_imm32();
1818
- },
1819
- 0xB9 => {
1820
- cpu.read_imm16();
1821
- },
1822
- 0x1B9 => {
1823
- cpu.read_imm32();
1824
- },
1825
- 0xBA => {
1826
- cpu.read_imm16();
1827
- },
1828
- 0x1BA => {
1829
- cpu.read_imm32();
1830
- },
1831
- 0xBB => {
1832
- cpu.read_imm16();
1833
- },
1834
- 0x1BB => {
1835
- cpu.read_imm32();
1836
- },
1837
- 0xBC => {
1838
- cpu.read_imm16();
1839
- },
1840
- 0x1BC => {
1841
- cpu.read_imm32();
1842
- },
1843
- 0xBD => {
1844
- cpu.read_imm16();
1845
- },
1846
- 0x1BD => {
1847
- cpu.read_imm32();
1848
- },
1849
- 0xBE => {
1850
- cpu.read_imm16();
1851
- },
1852
- 0x1BE => {
1853
- cpu.read_imm32();
1854
- },
1855
- 0xBF => {
1856
- cpu.read_imm16();
1857
- },
1858
- 0x1BF => {
1859
- cpu.read_imm32();
1860
- },
1861
- 0xC0 | 0x1C0 => {
1862
- let modrm_byte = cpu.read_imm8();
1863
- match modrm_byte >> 3 & 7 {
1864
- 0 => {
1865
- if modrm_byte < 0xC0 {
1866
- analysis::modrm_analyze(cpu, modrm_byte);
1867
- }
1868
- else {
1869
- }
1870
- cpu.read_imm8();
1871
- },
1872
- 1 => {
1873
- if modrm_byte < 0xC0 {
1874
- analysis::modrm_analyze(cpu, modrm_byte);
1875
- }
1876
- else {
1877
- }
1878
- cpu.read_imm8();
1879
- },
1880
- 2 => {
1881
- if modrm_byte < 0xC0 {
1882
- analysis::modrm_analyze(cpu, modrm_byte);
1883
- }
1884
- else {
1885
- }
1886
- cpu.read_imm8();
1887
- },
1888
- 3 => {
1889
- if modrm_byte < 0xC0 {
1890
- analysis::modrm_analyze(cpu, modrm_byte);
1891
- }
1892
- else {
1893
- }
1894
- cpu.read_imm8();
1895
- },
1896
- 4 => {
1897
- if modrm_byte < 0xC0 {
1898
- analysis::modrm_analyze(cpu, modrm_byte);
1899
- }
1900
- else {
1901
- }
1902
- cpu.read_imm8();
1903
- },
1904
- 5 => {
1905
- if modrm_byte < 0xC0 {
1906
- analysis::modrm_analyze(cpu, modrm_byte);
1907
- }
1908
- else {
1909
- }
1910
- cpu.read_imm8();
1911
- },
1912
- 6 => {
1913
- if modrm_byte < 0xC0 {
1914
- analysis::modrm_analyze(cpu, modrm_byte);
1915
- }
1916
- else {
1917
- }
1918
- cpu.read_imm8();
1919
- },
1920
- 7 => {
1921
- if modrm_byte < 0xC0 {
1922
- analysis::modrm_analyze(cpu, modrm_byte);
1923
- }
1924
- else {
1925
- }
1926
- cpu.read_imm8();
1927
- },
1928
- _ => {
1929
- analysis.ty = analysis::AnalysisType::BlockBoundary;
1930
- analysis.no_next_instruction = true;
1931
- }
1932
- }
1933
- },
1934
- 0xC1 => {
1935
- let modrm_byte = cpu.read_imm8();
1936
- match modrm_byte >> 3 & 7 {
1937
- 0 => {
1938
- if modrm_byte < 0xC0 {
1939
- analysis::modrm_analyze(cpu, modrm_byte);
1940
- }
1941
- else {
1942
- }
1943
- cpu.read_imm8();
1944
- },
1945
- 1 => {
1946
- if modrm_byte < 0xC0 {
1947
- analysis::modrm_analyze(cpu, modrm_byte);
1948
- }
1949
- else {
1950
- }
1951
- cpu.read_imm8();
1952
- },
1953
- 2 => {
1954
- if modrm_byte < 0xC0 {
1955
- analysis::modrm_analyze(cpu, modrm_byte);
1956
- }
1957
- else {
1958
- }
1959
- cpu.read_imm8();
1960
- },
1961
- 3 => {
1962
- if modrm_byte < 0xC0 {
1963
- analysis::modrm_analyze(cpu, modrm_byte);
1964
- }
1965
- else {
1966
- }
1967
- cpu.read_imm8();
1968
- },
1969
- 4 => {
1970
- if modrm_byte < 0xC0 {
1971
- analysis::modrm_analyze(cpu, modrm_byte);
1972
- }
1973
- else {
1974
- }
1975
- cpu.read_imm8();
1976
- },
1977
- 5 => {
1978
- if modrm_byte < 0xC0 {
1979
- analysis::modrm_analyze(cpu, modrm_byte);
1980
- }
1981
- else {
1982
- }
1983
- cpu.read_imm8();
1984
- },
1985
- 6 => {
1986
- if modrm_byte < 0xC0 {
1987
- analysis::modrm_analyze(cpu, modrm_byte);
1988
- }
1989
- else {
1990
- }
1991
- cpu.read_imm8();
1992
- },
1993
- 7 => {
1994
- if modrm_byte < 0xC0 {
1995
- analysis::modrm_analyze(cpu, modrm_byte);
1996
- }
1997
- else {
1998
- }
1999
- cpu.read_imm8();
2000
- },
2001
- _ => {
2002
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2003
- analysis.no_next_instruction = true;
2004
- }
2005
- }
2006
- },
2007
- 0x1C1 => {
2008
- let modrm_byte = cpu.read_imm8();
2009
- match modrm_byte >> 3 & 7 {
2010
- 0 => {
2011
- if modrm_byte < 0xC0 {
2012
- analysis::modrm_analyze(cpu, modrm_byte);
2013
- }
2014
- else {
2015
- }
2016
- cpu.read_imm8();
2017
- },
2018
- 1 => {
2019
- if modrm_byte < 0xC0 {
2020
- analysis::modrm_analyze(cpu, modrm_byte);
2021
- }
2022
- else {
2023
- }
2024
- cpu.read_imm8();
2025
- },
2026
- 2 => {
2027
- if modrm_byte < 0xC0 {
2028
- analysis::modrm_analyze(cpu, modrm_byte);
2029
- }
2030
- else {
2031
- }
2032
- cpu.read_imm8();
2033
- },
2034
- 3 => {
2035
- if modrm_byte < 0xC0 {
2036
- analysis::modrm_analyze(cpu, modrm_byte);
2037
- }
2038
- else {
2039
- }
2040
- cpu.read_imm8();
2041
- },
2042
- 4 => {
2043
- if modrm_byte < 0xC0 {
2044
- analysis::modrm_analyze(cpu, modrm_byte);
2045
- }
2046
- else {
2047
- }
2048
- cpu.read_imm8();
2049
- },
2050
- 5 => {
2051
- if modrm_byte < 0xC0 {
2052
- analysis::modrm_analyze(cpu, modrm_byte);
2053
- }
2054
- else {
2055
- }
2056
- cpu.read_imm8();
2057
- },
2058
- 6 => {
2059
- if modrm_byte < 0xC0 {
2060
- analysis::modrm_analyze(cpu, modrm_byte);
2061
- }
2062
- else {
2063
- }
2064
- cpu.read_imm8();
2065
- },
2066
- 7 => {
2067
- if modrm_byte < 0xC0 {
2068
- analysis::modrm_analyze(cpu, modrm_byte);
2069
- }
2070
- else {
2071
- }
2072
- cpu.read_imm8();
2073
- },
2074
- _ => {
2075
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2076
- analysis.no_next_instruction = true;
2077
- }
2078
- }
2079
- },
2080
- 0xC2 => {
2081
- cpu.read_imm16();
2082
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2083
- analysis.no_next_instruction = true;
2084
- analysis.absolute_jump = true;
2085
- },
2086
- 0x1C2 => {
2087
- cpu.read_imm16();
2088
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2089
- analysis.no_next_instruction = true;
2090
- analysis.absolute_jump = true;
2091
- },
2092
- 0xC3 => {
2093
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2094
- analysis.no_next_instruction = true;
2095
- analysis.absolute_jump = true;
2096
- },
2097
- 0x1C3 => {
2098
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2099
- analysis.no_next_instruction = true;
2100
- analysis.absolute_jump = true;
2101
- },
2102
- 0xC4 => {
2103
- let modrm_byte = cpu.read_imm8();
2104
- if modrm_byte < 0xC0 {
2105
- analysis::modrm_analyze(cpu, modrm_byte);
2106
- }
2107
- else {
2108
- }
2109
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2110
- },
2111
- 0x1C4 => {
2112
- let modrm_byte = cpu.read_imm8();
2113
- if modrm_byte < 0xC0 {
2114
- analysis::modrm_analyze(cpu, modrm_byte);
2115
- }
2116
- else {
2117
- }
2118
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2119
- },
2120
- 0xC5 => {
2121
- let modrm_byte = cpu.read_imm8();
2122
- if modrm_byte < 0xC0 {
2123
- analysis::modrm_analyze(cpu, modrm_byte);
2124
- }
2125
- else {
2126
- }
2127
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2128
- },
2129
- 0x1C5 => {
2130
- let modrm_byte = cpu.read_imm8();
2131
- if modrm_byte < 0xC0 {
2132
- analysis::modrm_analyze(cpu, modrm_byte);
2133
- }
2134
- else {
2135
- }
2136
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2137
- },
2138
- 0xC6 | 0x1C6 => {
2139
- let modrm_byte = cpu.read_imm8();
2140
- match modrm_byte >> 3 & 7 {
2141
- 0 => {
2142
- if modrm_byte < 0xC0 {
2143
- analysis::modrm_analyze(cpu, modrm_byte);
2144
- }
2145
- else {
2146
- }
2147
- cpu.read_imm8();
2148
- },
2149
- _ => {
2150
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2151
- analysis.no_next_instruction = true;
2152
- }
2153
- }
2154
- },
2155
- 0xC7 => {
2156
- let modrm_byte = cpu.read_imm8();
2157
- match modrm_byte >> 3 & 7 {
2158
- 0 => {
2159
- if modrm_byte < 0xC0 {
2160
- analysis::modrm_analyze(cpu, modrm_byte);
2161
- }
2162
- else {
2163
- }
2164
- cpu.read_imm16();
2165
- },
2166
- _ => {
2167
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2168
- analysis.no_next_instruction = true;
2169
- }
2170
- }
2171
- },
2172
- 0x1C7 => {
2173
- let modrm_byte = cpu.read_imm8();
2174
- match modrm_byte >> 3 & 7 {
2175
- 0 => {
2176
- if modrm_byte < 0xC0 {
2177
- analysis::modrm_analyze(cpu, modrm_byte);
2178
- }
2179
- else {
2180
- }
2181
- cpu.read_imm32();
2182
- },
2183
- _ => {
2184
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2185
- analysis.no_next_instruction = true;
2186
- }
2187
- }
2188
- },
2189
- 0xC8 => {
2190
- cpu.read_imm16();
2191
- cpu.read_imm8();
2192
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2193
- },
2194
- 0x1C8 => {
2195
- cpu.read_imm16();
2196
- cpu.read_imm8();
2197
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2198
- },
2199
- 0xC9 => {
2200
- },
2201
- 0x1C9 => {
2202
- },
2203
- 0xCA => {
2204
- cpu.read_imm16();
2205
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2206
- analysis.no_next_instruction = true;
2207
- },
2208
- 0x1CA => {
2209
- cpu.read_imm16();
2210
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2211
- analysis.no_next_instruction = true;
2212
- },
2213
- 0xCB => {
2214
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2215
- analysis.no_next_instruction = true;
2216
- },
2217
- 0x1CB => {
2218
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2219
- analysis.no_next_instruction = true;
2220
- },
2221
- 0xCC | 0x1CC => {
2222
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2223
- },
2224
- 0xCD | 0x1CD => {
2225
- cpu.read_imm8();
2226
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2227
- },
2228
- 0xCE | 0x1CE => {
2229
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2230
- },
2231
- 0xCF => {
2232
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2233
- analysis.no_next_instruction = true;
2234
- },
2235
- 0x1CF => {
2236
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2237
- analysis.no_next_instruction = true;
2238
- },
2239
- 0xD0 | 0x1D0 => {
2240
- let modrm_byte = cpu.read_imm8();
2241
- match modrm_byte >> 3 & 7 {
2242
- 0 => {
2243
- if modrm_byte < 0xC0 {
2244
- analysis::modrm_analyze(cpu, modrm_byte);
2245
- }
2246
- else {
2247
- }
2248
- },
2249
- 1 => {
2250
- if modrm_byte < 0xC0 {
2251
- analysis::modrm_analyze(cpu, modrm_byte);
2252
- }
2253
- else {
2254
- }
2255
- },
2256
- 2 => {
2257
- if modrm_byte < 0xC0 {
2258
- analysis::modrm_analyze(cpu, modrm_byte);
2259
- }
2260
- else {
2261
- }
2262
- },
2263
- 3 => {
2264
- if modrm_byte < 0xC0 {
2265
- analysis::modrm_analyze(cpu, modrm_byte);
2266
- }
2267
- else {
2268
- }
2269
- },
2270
- 4 => {
2271
- if modrm_byte < 0xC0 {
2272
- analysis::modrm_analyze(cpu, modrm_byte);
2273
- }
2274
- else {
2275
- }
2276
- },
2277
- 5 => {
2278
- if modrm_byte < 0xC0 {
2279
- analysis::modrm_analyze(cpu, modrm_byte);
2280
- }
2281
- else {
2282
- }
2283
- },
2284
- 6 => {
2285
- if modrm_byte < 0xC0 {
2286
- analysis::modrm_analyze(cpu, modrm_byte);
2287
- }
2288
- else {
2289
- }
2290
- },
2291
- 7 => {
2292
- if modrm_byte < 0xC0 {
2293
- analysis::modrm_analyze(cpu, modrm_byte);
2294
- }
2295
- else {
2296
- }
2297
- },
2298
- _ => {
2299
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2300
- analysis.no_next_instruction = true;
2301
- }
2302
- }
2303
- },
2304
- 0xD1 => {
2305
- let modrm_byte = cpu.read_imm8();
2306
- match modrm_byte >> 3 & 7 {
2307
- 0 => {
2308
- if modrm_byte < 0xC0 {
2309
- analysis::modrm_analyze(cpu, modrm_byte);
2310
- }
2311
- else {
2312
- }
2313
- },
2314
- 1 => {
2315
- if modrm_byte < 0xC0 {
2316
- analysis::modrm_analyze(cpu, modrm_byte);
2317
- }
2318
- else {
2319
- }
2320
- },
2321
- 2 => {
2322
- if modrm_byte < 0xC0 {
2323
- analysis::modrm_analyze(cpu, modrm_byte);
2324
- }
2325
- else {
2326
- }
2327
- },
2328
- 3 => {
2329
- if modrm_byte < 0xC0 {
2330
- analysis::modrm_analyze(cpu, modrm_byte);
2331
- }
2332
- else {
2333
- }
2334
- },
2335
- 4 => {
2336
- if modrm_byte < 0xC0 {
2337
- analysis::modrm_analyze(cpu, modrm_byte);
2338
- }
2339
- else {
2340
- }
2341
- },
2342
- 5 => {
2343
- if modrm_byte < 0xC0 {
2344
- analysis::modrm_analyze(cpu, modrm_byte);
2345
- }
2346
- else {
2347
- }
2348
- },
2349
- 6 => {
2350
- if modrm_byte < 0xC0 {
2351
- analysis::modrm_analyze(cpu, modrm_byte);
2352
- }
2353
- else {
2354
- }
2355
- },
2356
- 7 => {
2357
- if modrm_byte < 0xC0 {
2358
- analysis::modrm_analyze(cpu, modrm_byte);
2359
- }
2360
- else {
2361
- }
2362
- },
2363
- _ => {
2364
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2365
- analysis.no_next_instruction = true;
2366
- }
2367
- }
2368
- },
2369
- 0x1D1 => {
2370
- let modrm_byte = cpu.read_imm8();
2371
- match modrm_byte >> 3 & 7 {
2372
- 0 => {
2373
- if modrm_byte < 0xC0 {
2374
- analysis::modrm_analyze(cpu, modrm_byte);
2375
- }
2376
- else {
2377
- }
2378
- },
2379
- 1 => {
2380
- if modrm_byte < 0xC0 {
2381
- analysis::modrm_analyze(cpu, modrm_byte);
2382
- }
2383
- else {
2384
- }
2385
- },
2386
- 2 => {
2387
- if modrm_byte < 0xC0 {
2388
- analysis::modrm_analyze(cpu, modrm_byte);
2389
- }
2390
- else {
2391
- }
2392
- },
2393
- 3 => {
2394
- if modrm_byte < 0xC0 {
2395
- analysis::modrm_analyze(cpu, modrm_byte);
2396
- }
2397
- else {
2398
- }
2399
- },
2400
- 4 => {
2401
- if modrm_byte < 0xC0 {
2402
- analysis::modrm_analyze(cpu, modrm_byte);
2403
- }
2404
- else {
2405
- }
2406
- },
2407
- 5 => {
2408
- if modrm_byte < 0xC0 {
2409
- analysis::modrm_analyze(cpu, modrm_byte);
2410
- }
2411
- else {
2412
- }
2413
- },
2414
- 6 => {
2415
- if modrm_byte < 0xC0 {
2416
- analysis::modrm_analyze(cpu, modrm_byte);
2417
- }
2418
- else {
2419
- }
2420
- },
2421
- 7 => {
2422
- if modrm_byte < 0xC0 {
2423
- analysis::modrm_analyze(cpu, modrm_byte);
2424
- }
2425
- else {
2426
- }
2427
- },
2428
- _ => {
2429
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2430
- analysis.no_next_instruction = true;
2431
- }
2432
- }
2433
- },
2434
- 0xD2 | 0x1D2 => {
2435
- let modrm_byte = cpu.read_imm8();
2436
- match modrm_byte >> 3 & 7 {
2437
- 0 => {
2438
- if modrm_byte < 0xC0 {
2439
- analysis::modrm_analyze(cpu, modrm_byte);
2440
- }
2441
- else {
2442
- }
2443
- },
2444
- 1 => {
2445
- if modrm_byte < 0xC0 {
2446
- analysis::modrm_analyze(cpu, modrm_byte);
2447
- }
2448
- else {
2449
- }
2450
- },
2451
- 2 => {
2452
- if modrm_byte < 0xC0 {
2453
- analysis::modrm_analyze(cpu, modrm_byte);
2454
- }
2455
- else {
2456
- }
2457
- },
2458
- 3 => {
2459
- if modrm_byte < 0xC0 {
2460
- analysis::modrm_analyze(cpu, modrm_byte);
2461
- }
2462
- else {
2463
- }
2464
- },
2465
- 4 => {
2466
- if modrm_byte < 0xC0 {
2467
- analysis::modrm_analyze(cpu, modrm_byte);
2468
- }
2469
- else {
2470
- }
2471
- },
2472
- 5 => {
2473
- if modrm_byte < 0xC0 {
2474
- analysis::modrm_analyze(cpu, modrm_byte);
2475
- }
2476
- else {
2477
- }
2478
- },
2479
- 6 => {
2480
- if modrm_byte < 0xC0 {
2481
- analysis::modrm_analyze(cpu, modrm_byte);
2482
- }
2483
- else {
2484
- }
2485
- },
2486
- 7 => {
2487
- if modrm_byte < 0xC0 {
2488
- analysis::modrm_analyze(cpu, modrm_byte);
2489
- }
2490
- else {
2491
- }
2492
- },
2493
- _ => {
2494
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2495
- analysis.no_next_instruction = true;
2496
- }
2497
- }
2498
- },
2499
- 0xD3 => {
2500
- let modrm_byte = cpu.read_imm8();
2501
- match modrm_byte >> 3 & 7 {
2502
- 0 => {
2503
- if modrm_byte < 0xC0 {
2504
- analysis::modrm_analyze(cpu, modrm_byte);
2505
- }
2506
- else {
2507
- }
2508
- },
2509
- 1 => {
2510
- if modrm_byte < 0xC0 {
2511
- analysis::modrm_analyze(cpu, modrm_byte);
2512
- }
2513
- else {
2514
- }
2515
- },
2516
- 2 => {
2517
- if modrm_byte < 0xC0 {
2518
- analysis::modrm_analyze(cpu, modrm_byte);
2519
- }
2520
- else {
2521
- }
2522
- },
2523
- 3 => {
2524
- if modrm_byte < 0xC0 {
2525
- analysis::modrm_analyze(cpu, modrm_byte);
2526
- }
2527
- else {
2528
- }
2529
- },
2530
- 4 => {
2531
- if modrm_byte < 0xC0 {
2532
- analysis::modrm_analyze(cpu, modrm_byte);
2533
- }
2534
- else {
2535
- }
2536
- },
2537
- 5 => {
2538
- if modrm_byte < 0xC0 {
2539
- analysis::modrm_analyze(cpu, modrm_byte);
2540
- }
2541
- else {
2542
- }
2543
- },
2544
- 6 => {
2545
- if modrm_byte < 0xC0 {
2546
- analysis::modrm_analyze(cpu, modrm_byte);
2547
- }
2548
- else {
2549
- }
2550
- },
2551
- 7 => {
2552
- if modrm_byte < 0xC0 {
2553
- analysis::modrm_analyze(cpu, modrm_byte);
2554
- }
2555
- else {
2556
- }
2557
- },
2558
- _ => {
2559
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2560
- analysis.no_next_instruction = true;
2561
- }
2562
- }
2563
- },
2564
- 0x1D3 => {
2565
- let modrm_byte = cpu.read_imm8();
2566
- match modrm_byte >> 3 & 7 {
2567
- 0 => {
2568
- if modrm_byte < 0xC0 {
2569
- analysis::modrm_analyze(cpu, modrm_byte);
2570
- }
2571
- else {
2572
- }
2573
- },
2574
- 1 => {
2575
- if modrm_byte < 0xC0 {
2576
- analysis::modrm_analyze(cpu, modrm_byte);
2577
- }
2578
- else {
2579
- }
2580
- },
2581
- 2 => {
2582
- if modrm_byte < 0xC0 {
2583
- analysis::modrm_analyze(cpu, modrm_byte);
2584
- }
2585
- else {
2586
- }
2587
- },
2588
- 3 => {
2589
- if modrm_byte < 0xC0 {
2590
- analysis::modrm_analyze(cpu, modrm_byte);
2591
- }
2592
- else {
2593
- }
2594
- },
2595
- 4 => {
2596
- if modrm_byte < 0xC0 {
2597
- analysis::modrm_analyze(cpu, modrm_byte);
2598
- }
2599
- else {
2600
- }
2601
- },
2602
- 5 => {
2603
- if modrm_byte < 0xC0 {
2604
- analysis::modrm_analyze(cpu, modrm_byte);
2605
- }
2606
- else {
2607
- }
2608
- },
2609
- 6 => {
2610
- if modrm_byte < 0xC0 {
2611
- analysis::modrm_analyze(cpu, modrm_byte);
2612
- }
2613
- else {
2614
- }
2615
- },
2616
- 7 => {
2617
- if modrm_byte < 0xC0 {
2618
- analysis::modrm_analyze(cpu, modrm_byte);
2619
- }
2620
- else {
2621
- }
2622
- },
2623
- _ => {
2624
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2625
- analysis.no_next_instruction = true;
2626
- }
2627
- }
2628
- },
2629
- 0xD4 | 0x1D4 => {
2630
- cpu.read_imm8();
2631
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2632
- },
2633
- 0xD5 | 0x1D5 => {
2634
- cpu.read_imm8();
2635
- },
2636
- 0xD6 | 0x1D6 => {
2637
- },
2638
- 0xD7 | 0x1D7 => {
2639
- },
2640
- 0xD8 | 0x1D8 => {
2641
- let modrm_byte = cpu.read_imm8();
2642
- match modrm_byte >> 3 & 7 {
2643
- 0 => {
2644
- if modrm_byte < 0xC0 {
2645
- analysis::modrm_analyze(cpu, modrm_byte);
2646
- }
2647
- else {
2648
- }
2649
- },
2650
- 1 => {
2651
- if modrm_byte < 0xC0 {
2652
- analysis::modrm_analyze(cpu, modrm_byte);
2653
- }
2654
- else {
2655
- }
2656
- },
2657
- 2 => {
2658
- if modrm_byte < 0xC0 {
2659
- analysis::modrm_analyze(cpu, modrm_byte);
2660
- }
2661
- else {
2662
- }
2663
- },
2664
- 3 => {
2665
- if modrm_byte < 0xC0 {
2666
- analysis::modrm_analyze(cpu, modrm_byte);
2667
- }
2668
- else {
2669
- }
2670
- },
2671
- 4 => {
2672
- if modrm_byte < 0xC0 {
2673
- analysis::modrm_analyze(cpu, modrm_byte);
2674
- }
2675
- else {
2676
- }
2677
- },
2678
- 5 => {
2679
- if modrm_byte < 0xC0 {
2680
- analysis::modrm_analyze(cpu, modrm_byte);
2681
- }
2682
- else {
2683
- }
2684
- },
2685
- 6 => {
2686
- if modrm_byte < 0xC0 {
2687
- analysis::modrm_analyze(cpu, modrm_byte);
2688
- }
2689
- else {
2690
- }
2691
- },
2692
- 7 => {
2693
- if modrm_byte < 0xC0 {
2694
- analysis::modrm_analyze(cpu, modrm_byte);
2695
- }
2696
- else {
2697
- }
2698
- },
2699
- _ => {
2700
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2701
- analysis.no_next_instruction = true;
2702
- }
2703
- }
2704
- },
2705
- 0xD9 => {
2706
- let modrm_byte = cpu.read_imm8();
2707
- match modrm_byte >> 3 & 7 {
2708
- 0 => {
2709
- if modrm_byte < 0xC0 {
2710
- analysis::modrm_analyze(cpu, modrm_byte);
2711
- }
2712
- else {
2713
- }
2714
- },
2715
- 1 => {
2716
- if modrm_byte < 0xC0 {
2717
- analysis::modrm_analyze(cpu, modrm_byte);
2718
- }
2719
- else {
2720
- }
2721
- },
2722
- 2 => {
2723
- if modrm_byte < 0xC0 {
2724
- analysis::modrm_analyze(cpu, modrm_byte);
2725
- }
2726
- else {
2727
- }
2728
- },
2729
- 3 => {
2730
- if modrm_byte < 0xC0 {
2731
- analysis::modrm_analyze(cpu, modrm_byte);
2732
- }
2733
- else {
2734
- }
2735
- },
2736
- 4 => {
2737
- if modrm_byte < 0xC0 {
2738
- analysis::modrm_analyze(cpu, modrm_byte);
2739
- }
2740
- else {
2741
- }
2742
- },
2743
- 5 => {
2744
- if modrm_byte < 0xC0 {
2745
- analysis::modrm_analyze(cpu, modrm_byte);
2746
- }
2747
- else {
2748
- }
2749
- },
2750
- 6 => {
2751
- if modrm_byte < 0xC0 {
2752
- analysis::modrm_analyze(cpu, modrm_byte);
2753
- }
2754
- else {
2755
- }
2756
- },
2757
- 7 => {
2758
- if modrm_byte < 0xC0 {
2759
- analysis::modrm_analyze(cpu, modrm_byte);
2760
- }
2761
- else {
2762
- }
2763
- },
2764
- _ => {
2765
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2766
- analysis.no_next_instruction = true;
2767
- }
2768
- }
2769
- },
2770
- 0x1D9 => {
2771
- let modrm_byte = cpu.read_imm8();
2772
- match modrm_byte >> 3 & 7 {
2773
- 0 => {
2774
- if modrm_byte < 0xC0 {
2775
- analysis::modrm_analyze(cpu, modrm_byte);
2776
- }
2777
- else {
2778
- }
2779
- },
2780
- 1 => {
2781
- if modrm_byte < 0xC0 {
2782
- analysis::modrm_analyze(cpu, modrm_byte);
2783
- }
2784
- else {
2785
- }
2786
- },
2787
- 2 => {
2788
- if modrm_byte < 0xC0 {
2789
- analysis::modrm_analyze(cpu, modrm_byte);
2790
- }
2791
- else {
2792
- }
2793
- },
2794
- 3 => {
2795
- if modrm_byte < 0xC0 {
2796
- analysis::modrm_analyze(cpu, modrm_byte);
2797
- }
2798
- else {
2799
- }
2800
- },
2801
- 4 => {
2802
- if modrm_byte < 0xC0 {
2803
- analysis::modrm_analyze(cpu, modrm_byte);
2804
- }
2805
- else {
2806
- }
2807
- },
2808
- 5 => {
2809
- if modrm_byte < 0xC0 {
2810
- analysis::modrm_analyze(cpu, modrm_byte);
2811
- }
2812
- else {
2813
- }
2814
- },
2815
- 6 => {
2816
- if modrm_byte < 0xC0 {
2817
- analysis::modrm_analyze(cpu, modrm_byte);
2818
- }
2819
- else {
2820
- }
2821
- },
2822
- 7 => {
2823
- if modrm_byte < 0xC0 {
2824
- analysis::modrm_analyze(cpu, modrm_byte);
2825
- }
2826
- else {
2827
- }
2828
- },
2829
- _ => {
2830
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2831
- analysis.no_next_instruction = true;
2832
- }
2833
- }
2834
- },
2835
- 0xDA | 0x1DA => {
2836
- let modrm_byte = cpu.read_imm8();
2837
- match modrm_byte >> 3 & 7 {
2838
- 0 => {
2839
- if modrm_byte < 0xC0 {
2840
- analysis::modrm_analyze(cpu, modrm_byte);
2841
- }
2842
- else {
2843
- }
2844
- },
2845
- 1 => {
2846
- if modrm_byte < 0xC0 {
2847
- analysis::modrm_analyze(cpu, modrm_byte);
2848
- }
2849
- else {
2850
- }
2851
- },
2852
- 2 => {
2853
- if modrm_byte < 0xC0 {
2854
- analysis::modrm_analyze(cpu, modrm_byte);
2855
- }
2856
- else {
2857
- }
2858
- },
2859
- 3 => {
2860
- if modrm_byte < 0xC0 {
2861
- analysis::modrm_analyze(cpu, modrm_byte);
2862
- }
2863
- else {
2864
- }
2865
- },
2866
- 4 => {
2867
- if modrm_byte < 0xC0 {
2868
- analysis::modrm_analyze(cpu, modrm_byte);
2869
- }
2870
- else {
2871
- }
2872
- },
2873
- 5 => {
2874
- if modrm_byte < 0xC0 {
2875
- analysis::modrm_analyze(cpu, modrm_byte);
2876
- }
2877
- else {
2878
- }
2879
- },
2880
- 6 => {
2881
- if modrm_byte < 0xC0 {
2882
- analysis::modrm_analyze(cpu, modrm_byte);
2883
- }
2884
- else {
2885
- }
2886
- },
2887
- 7 => {
2888
- if modrm_byte < 0xC0 {
2889
- analysis::modrm_analyze(cpu, modrm_byte);
2890
- }
2891
- else {
2892
- }
2893
- },
2894
- _ => {
2895
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2896
- analysis.no_next_instruction = true;
2897
- }
2898
- }
2899
- },
2900
- 0xDB | 0x1DB => {
2901
- let modrm_byte = cpu.read_imm8();
2902
- match modrm_byte >> 3 & 7 {
2903
- 0 => {
2904
- if modrm_byte < 0xC0 {
2905
- analysis::modrm_analyze(cpu, modrm_byte);
2906
- }
2907
- else {
2908
- }
2909
- },
2910
- 1 => {
2911
- if modrm_byte < 0xC0 {
2912
- analysis::modrm_analyze(cpu, modrm_byte);
2913
- }
2914
- else {
2915
- }
2916
- },
2917
- 2 => {
2918
- if modrm_byte < 0xC0 {
2919
- analysis::modrm_analyze(cpu, modrm_byte);
2920
- }
2921
- else {
2922
- }
2923
- },
2924
- 3 => {
2925
- if modrm_byte < 0xC0 {
2926
- analysis::modrm_analyze(cpu, modrm_byte);
2927
- }
2928
- else {
2929
- }
2930
- },
2931
- 4 => {
2932
- if modrm_byte < 0xC0 {
2933
- analysis::modrm_analyze(cpu, modrm_byte);
2934
- }
2935
- else {
2936
- }
2937
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2938
- },
2939
- 5 => {
2940
- if modrm_byte < 0xC0 {
2941
- analysis::modrm_analyze(cpu, modrm_byte);
2942
- }
2943
- else {
2944
- }
2945
- },
2946
- 6 => {
2947
- if modrm_byte < 0xC0 {
2948
- analysis::modrm_analyze(cpu, modrm_byte);
2949
- }
2950
- else {
2951
- }
2952
- },
2953
- 7 => {
2954
- if modrm_byte < 0xC0 {
2955
- analysis::modrm_analyze(cpu, modrm_byte);
2956
- }
2957
- else {
2958
- }
2959
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2960
- },
2961
- _ => {
2962
- analysis.ty = analysis::AnalysisType::BlockBoundary;
2963
- analysis.no_next_instruction = true;
2964
- }
2965
- }
2966
- },
2967
- 0xDC | 0x1DC => {
2968
- let modrm_byte = cpu.read_imm8();
2969
- match modrm_byte >> 3 & 7 {
2970
- 0 => {
2971
- if modrm_byte < 0xC0 {
2972
- analysis::modrm_analyze(cpu, modrm_byte);
2973
- }
2974
- else {
2975
- }
2976
- },
2977
- 1 => {
2978
- if modrm_byte < 0xC0 {
2979
- analysis::modrm_analyze(cpu, modrm_byte);
2980
- }
2981
- else {
2982
- }
2983
- },
2984
- 2 => {
2985
- if modrm_byte < 0xC0 {
2986
- analysis::modrm_analyze(cpu, modrm_byte);
2987
- }
2988
- else {
2989
- }
2990
- },
2991
- 3 => {
2992
- if modrm_byte < 0xC0 {
2993
- analysis::modrm_analyze(cpu, modrm_byte);
2994
- }
2995
- else {
2996
- }
2997
- },
2998
- 4 => {
2999
- if modrm_byte < 0xC0 {
3000
- analysis::modrm_analyze(cpu, modrm_byte);
3001
- }
3002
- else {
3003
- }
3004
- },
3005
- 5 => {
3006
- if modrm_byte < 0xC0 {
3007
- analysis::modrm_analyze(cpu, modrm_byte);
3008
- }
3009
- else {
3010
- }
3011
- },
3012
- 6 => {
3013
- if modrm_byte < 0xC0 {
3014
- analysis::modrm_analyze(cpu, modrm_byte);
3015
- }
3016
- else {
3017
- }
3018
- },
3019
- 7 => {
3020
- if modrm_byte < 0xC0 {
3021
- analysis::modrm_analyze(cpu, modrm_byte);
3022
- }
3023
- else {
3024
- }
3025
- },
3026
- _ => {
3027
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3028
- analysis.no_next_instruction = true;
3029
- }
3030
- }
3031
- },
3032
- 0xDD => {
3033
- let modrm_byte = cpu.read_imm8();
3034
- match modrm_byte >> 3 & 7 {
3035
- 0 => {
3036
- if modrm_byte < 0xC0 {
3037
- analysis::modrm_analyze(cpu, modrm_byte);
3038
- }
3039
- else {
3040
- }
3041
- },
3042
- 1 => {
3043
- if modrm_byte < 0xC0 {
3044
- analysis::modrm_analyze(cpu, modrm_byte);
3045
- }
3046
- else {
3047
- }
3048
- },
3049
- 2 => {
3050
- if modrm_byte < 0xC0 {
3051
- analysis::modrm_analyze(cpu, modrm_byte);
3052
- }
3053
- else {
3054
- }
3055
- },
3056
- 3 => {
3057
- if modrm_byte < 0xC0 {
3058
- analysis::modrm_analyze(cpu, modrm_byte);
3059
- }
3060
- else {
3061
- }
3062
- },
3063
- 4 => {
3064
- if modrm_byte < 0xC0 {
3065
- analysis::modrm_analyze(cpu, modrm_byte);
3066
- }
3067
- else {
3068
- }
3069
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3070
- },
3071
- 5 => {
3072
- if modrm_byte < 0xC0 {
3073
- analysis::modrm_analyze(cpu, modrm_byte);
3074
- }
3075
- else {
3076
- }
3077
- },
3078
- 6 => {
3079
- if modrm_byte < 0xC0 {
3080
- analysis::modrm_analyze(cpu, modrm_byte);
3081
- }
3082
- else {
3083
- }
3084
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3085
- },
3086
- 7 => {
3087
- if modrm_byte < 0xC0 {
3088
- analysis::modrm_analyze(cpu, modrm_byte);
3089
- }
3090
- else {
3091
- }
3092
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3093
- },
3094
- _ => {
3095
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3096
- analysis.no_next_instruction = true;
3097
- }
3098
- }
3099
- },
3100
- 0x1DD => {
3101
- let modrm_byte = cpu.read_imm8();
3102
- match modrm_byte >> 3 & 7 {
3103
- 0 => {
3104
- if modrm_byte < 0xC0 {
3105
- analysis::modrm_analyze(cpu, modrm_byte);
3106
- }
3107
- else {
3108
- }
3109
- },
3110
- 1 => {
3111
- if modrm_byte < 0xC0 {
3112
- analysis::modrm_analyze(cpu, modrm_byte);
3113
- }
3114
- else {
3115
- }
3116
- },
3117
- 2 => {
3118
- if modrm_byte < 0xC0 {
3119
- analysis::modrm_analyze(cpu, modrm_byte);
3120
- }
3121
- else {
3122
- }
3123
- },
3124
- 3 => {
3125
- if modrm_byte < 0xC0 {
3126
- analysis::modrm_analyze(cpu, modrm_byte);
3127
- }
3128
- else {
3129
- }
3130
- },
3131
- 4 => {
3132
- if modrm_byte < 0xC0 {
3133
- analysis::modrm_analyze(cpu, modrm_byte);
3134
- }
3135
- else {
3136
- }
3137
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3138
- },
3139
- 5 => {
3140
- if modrm_byte < 0xC0 {
3141
- analysis::modrm_analyze(cpu, modrm_byte);
3142
- }
3143
- else {
3144
- }
3145
- },
3146
- 6 => {
3147
- if modrm_byte < 0xC0 {
3148
- analysis::modrm_analyze(cpu, modrm_byte);
3149
- }
3150
- else {
3151
- }
3152
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3153
- },
3154
- 7 => {
3155
- if modrm_byte < 0xC0 {
3156
- analysis::modrm_analyze(cpu, modrm_byte);
3157
- }
3158
- else {
3159
- }
3160
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3161
- },
3162
- _ => {
3163
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3164
- analysis.no_next_instruction = true;
3165
- }
3166
- }
3167
- },
3168
- 0xDE | 0x1DE => {
3169
- let modrm_byte = cpu.read_imm8();
3170
- match modrm_byte >> 3 & 7 {
3171
- 0 => {
3172
- if modrm_byte < 0xC0 {
3173
- analysis::modrm_analyze(cpu, modrm_byte);
3174
- }
3175
- else {
3176
- }
3177
- },
3178
- 1 => {
3179
- if modrm_byte < 0xC0 {
3180
- analysis::modrm_analyze(cpu, modrm_byte);
3181
- }
3182
- else {
3183
- }
3184
- },
3185
- 2 => {
3186
- if modrm_byte < 0xC0 {
3187
- analysis::modrm_analyze(cpu, modrm_byte);
3188
- }
3189
- else {
3190
- }
3191
- },
3192
- 3 => {
3193
- if modrm_byte < 0xC0 {
3194
- analysis::modrm_analyze(cpu, modrm_byte);
3195
- }
3196
- else {
3197
- }
3198
- },
3199
- 4 => {
3200
- if modrm_byte < 0xC0 {
3201
- analysis::modrm_analyze(cpu, modrm_byte);
3202
- }
3203
- else {
3204
- }
3205
- },
3206
- 5 => {
3207
- if modrm_byte < 0xC0 {
3208
- analysis::modrm_analyze(cpu, modrm_byte);
3209
- }
3210
- else {
3211
- }
3212
- },
3213
- 6 => {
3214
- if modrm_byte < 0xC0 {
3215
- analysis::modrm_analyze(cpu, modrm_byte);
3216
- }
3217
- else {
3218
- }
3219
- },
3220
- 7 => {
3221
- if modrm_byte < 0xC0 {
3222
- analysis::modrm_analyze(cpu, modrm_byte);
3223
- }
3224
- else {
3225
- }
3226
- },
3227
- _ => {
3228
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3229
- analysis.no_next_instruction = true;
3230
- }
3231
- }
3232
- },
3233
- 0xDF | 0x1DF => {
3234
- let modrm_byte = cpu.read_imm8();
3235
- match modrm_byte >> 3 & 7 {
3236
- 0 => {
3237
- if modrm_byte < 0xC0 {
3238
- analysis::modrm_analyze(cpu, modrm_byte);
3239
- }
3240
- else {
3241
- }
3242
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3243
- },
3244
- 1 => {
3245
- if modrm_byte < 0xC0 {
3246
- analysis::modrm_analyze(cpu, modrm_byte);
3247
- }
3248
- else {
3249
- }
3250
- },
3251
- 2 => {
3252
- if modrm_byte < 0xC0 {
3253
- analysis::modrm_analyze(cpu, modrm_byte);
3254
- }
3255
- else {
3256
- }
3257
- },
3258
- 3 => {
3259
- if modrm_byte < 0xC0 {
3260
- analysis::modrm_analyze(cpu, modrm_byte);
3261
- }
3262
- else {
3263
- }
3264
- },
3265
- 4 => {
3266
- if modrm_byte < 0xC0 {
3267
- analysis::modrm_analyze(cpu, modrm_byte);
3268
- }
3269
- else {
3270
- }
3271
- },
3272
- 5 => {
3273
- if modrm_byte < 0xC0 {
3274
- analysis::modrm_analyze(cpu, modrm_byte);
3275
- }
3276
- else {
3277
- }
3278
- },
3279
- 6 => {
3280
- if modrm_byte < 0xC0 {
3281
- analysis::modrm_analyze(cpu, modrm_byte);
3282
- }
3283
- else {
3284
- }
3285
- },
3286
- 7 => {
3287
- if modrm_byte < 0xC0 {
3288
- analysis::modrm_analyze(cpu, modrm_byte);
3289
- }
3290
- else {
3291
- }
3292
- },
3293
- _ => {
3294
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3295
- analysis.no_next_instruction = true;
3296
- }
3297
- }
3298
- },
3299
- 0xE0 => {
3300
- let jump_offset = cpu.read_imm8s();
3301
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0xE0), is_32: cpu.osize_32() };
3302
- },
3303
- 0x1E0 => {
3304
- let jump_offset = cpu.read_imm8s();
3305
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0xE0), is_32: cpu.osize_32() };
3306
- },
3307
- 0xE1 => {
3308
- let jump_offset = cpu.read_imm8s();
3309
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0xE1), is_32: cpu.osize_32() };
3310
- },
3311
- 0x1E1 => {
3312
- let jump_offset = cpu.read_imm8s();
3313
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0xE1), is_32: cpu.osize_32() };
3314
- },
3315
- 0xE2 => {
3316
- let jump_offset = cpu.read_imm8s();
3317
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0xE2), is_32: cpu.osize_32() };
3318
- },
3319
- 0x1E2 => {
3320
- let jump_offset = cpu.read_imm8s();
3321
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0xE2), is_32: cpu.osize_32() };
3322
- },
3323
- 0xE3 => {
3324
- let jump_offset = cpu.read_imm8s();
3325
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0xE3), is_32: cpu.osize_32() };
3326
- },
3327
- 0x1E3 => {
3328
- let jump_offset = cpu.read_imm8s();
3329
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: Some(0xE3), is_32: cpu.osize_32() };
3330
- },
3331
- 0xE4 | 0x1E4 => {
3332
- cpu.read_imm8();
3333
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3334
- },
3335
- 0xE5 => {
3336
- cpu.read_imm8();
3337
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3338
- },
3339
- 0x1E5 => {
3340
- cpu.read_imm8();
3341
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3342
- },
3343
- 0xE6 | 0x1E6 => {
3344
- cpu.read_imm8();
3345
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3346
- },
3347
- 0xE7 => {
3348
- cpu.read_imm8();
3349
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3350
- },
3351
- 0x1E7 => {
3352
- cpu.read_imm8();
3353
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3354
- },
3355
- 0xE8 => {
3356
- let jump_offset = cpu.read_imm16();
3357
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: None, is_32: cpu.osize_32() };
3358
- },
3359
- 0x1E8 => {
3360
- let jump_offset = cpu.read_imm32();
3361
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: None, is_32: cpu.osize_32() };
3362
- },
3363
- 0xE9 => {
3364
- let jump_offset = cpu.read_imm16();
3365
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: None, is_32: cpu.osize_32() };
3366
- analysis.no_next_instruction = true;
3367
- },
3368
- 0x1E9 => {
3369
- let jump_offset = cpu.read_imm32();
3370
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: None, is_32: cpu.osize_32() };
3371
- analysis.no_next_instruction = true;
3372
- },
3373
- 0xEA => {
3374
- cpu.read_imm16();
3375
- cpu.read_imm16();
3376
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3377
- analysis.no_next_instruction = true;
3378
- },
3379
- 0x1EA => {
3380
- cpu.read_imm32();
3381
- cpu.read_imm16();
3382
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3383
- analysis.no_next_instruction = true;
3384
- },
3385
- 0xEB => {
3386
- let jump_offset = cpu.read_imm8s();
3387
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: None, is_32: cpu.osize_32() };
3388
- analysis.no_next_instruction = true;
3389
- },
3390
- 0x1EB => {
3391
- let jump_offset = cpu.read_imm8s();
3392
- analysis.ty = analysis::AnalysisType::Jump { offset: jump_offset as i32, condition: None, is_32: cpu.osize_32() };
3393
- analysis.no_next_instruction = true;
3394
- },
3395
- 0xEC | 0x1EC => {
3396
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3397
- },
3398
- 0xED => {
3399
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3400
- },
3401
- 0x1ED => {
3402
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3403
- },
3404
- 0xEE | 0x1EE => {
3405
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3406
- },
3407
- 0xEF => {
3408
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3409
- },
3410
- 0x1EF => {
3411
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3412
- },
3413
- 0xF0 | 0x1F0 => {
3414
- analysis::instr_F0_analyze(cpu, analysis);
3415
- },
3416
- 0xF1 | 0x1F1 => {
3417
- },
3418
- 0xF2 | 0x1F2 => {
3419
- analysis::instr_F2_analyze(cpu, analysis);
3420
- },
3421
- 0xF3 | 0x1F3 => {
3422
- analysis::instr_F3_analyze(cpu, analysis);
3423
- },
3424
- 0xF4 | 0x1F4 => {
3425
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3426
- analysis.no_next_instruction = true;
3427
- },
3428
- 0xF5 | 0x1F5 => {
3429
- },
3430
- 0xF6 | 0x1F6 => {
3431
- let modrm_byte = cpu.read_imm8();
3432
- match modrm_byte >> 3 & 7 {
3433
- 0 => {
3434
- if modrm_byte < 0xC0 {
3435
- analysis::modrm_analyze(cpu, modrm_byte);
3436
- }
3437
- else {
3438
- }
3439
- cpu.read_imm8();
3440
- },
3441
- 1 => {
3442
- if modrm_byte < 0xC0 {
3443
- analysis::modrm_analyze(cpu, modrm_byte);
3444
- }
3445
- else {
3446
- }
3447
- cpu.read_imm8();
3448
- },
3449
- 2 => {
3450
- if modrm_byte < 0xC0 {
3451
- analysis::modrm_analyze(cpu, modrm_byte);
3452
- }
3453
- else {
3454
- }
3455
- },
3456
- 3 => {
3457
- if modrm_byte < 0xC0 {
3458
- analysis::modrm_analyze(cpu, modrm_byte);
3459
- }
3460
- else {
3461
- }
3462
- },
3463
- 4 => {
3464
- if modrm_byte < 0xC0 {
3465
- analysis::modrm_analyze(cpu, modrm_byte);
3466
- }
3467
- else {
3468
- }
3469
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3470
- },
3471
- 5 => {
3472
- if modrm_byte < 0xC0 {
3473
- analysis::modrm_analyze(cpu, modrm_byte);
3474
- }
3475
- else {
3476
- }
3477
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3478
- },
3479
- 6 => {
3480
- if modrm_byte < 0xC0 {
3481
- analysis::modrm_analyze(cpu, modrm_byte);
3482
- }
3483
- else {
3484
- }
3485
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3486
- },
3487
- 7 => {
3488
- if modrm_byte < 0xC0 {
3489
- analysis::modrm_analyze(cpu, modrm_byte);
3490
- }
3491
- else {
3492
- }
3493
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3494
- },
3495
- _ => {
3496
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3497
- analysis.no_next_instruction = true;
3498
- }
3499
- }
3500
- },
3501
- 0xF7 => {
3502
- let modrm_byte = cpu.read_imm8();
3503
- match modrm_byte >> 3 & 7 {
3504
- 0 => {
3505
- if modrm_byte < 0xC0 {
3506
- analysis::modrm_analyze(cpu, modrm_byte);
3507
- }
3508
- else {
3509
- }
3510
- cpu.read_imm16();
3511
- },
3512
- 1 => {
3513
- if modrm_byte < 0xC0 {
3514
- analysis::modrm_analyze(cpu, modrm_byte);
3515
- }
3516
- else {
3517
- }
3518
- cpu.read_imm16();
3519
- },
3520
- 2 => {
3521
- if modrm_byte < 0xC0 {
3522
- analysis::modrm_analyze(cpu, modrm_byte);
3523
- }
3524
- else {
3525
- }
3526
- },
3527
- 3 => {
3528
- if modrm_byte < 0xC0 {
3529
- analysis::modrm_analyze(cpu, modrm_byte);
3530
- }
3531
- else {
3532
- }
3533
- },
3534
- 4 => {
3535
- if modrm_byte < 0xC0 {
3536
- analysis::modrm_analyze(cpu, modrm_byte);
3537
- }
3538
- else {
3539
- }
3540
- },
3541
- 5 => {
3542
- if modrm_byte < 0xC0 {
3543
- analysis::modrm_analyze(cpu, modrm_byte);
3544
- }
3545
- else {
3546
- }
3547
- },
3548
- 6 => {
3549
- if modrm_byte < 0xC0 {
3550
- analysis::modrm_analyze(cpu, modrm_byte);
3551
- }
3552
- else {
3553
- }
3554
- },
3555
- 7 => {
3556
- if modrm_byte < 0xC0 {
3557
- analysis::modrm_analyze(cpu, modrm_byte);
3558
- }
3559
- else {
3560
- }
3561
- },
3562
- _ => {
3563
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3564
- analysis.no_next_instruction = true;
3565
- }
3566
- }
3567
- },
3568
- 0x1F7 => {
3569
- let modrm_byte = cpu.read_imm8();
3570
- match modrm_byte >> 3 & 7 {
3571
- 0 => {
3572
- if modrm_byte < 0xC0 {
3573
- analysis::modrm_analyze(cpu, modrm_byte);
3574
- }
3575
- else {
3576
- }
3577
- cpu.read_imm32();
3578
- },
3579
- 1 => {
3580
- if modrm_byte < 0xC0 {
3581
- analysis::modrm_analyze(cpu, modrm_byte);
3582
- }
3583
- else {
3584
- }
3585
- cpu.read_imm32();
3586
- },
3587
- 2 => {
3588
- if modrm_byte < 0xC0 {
3589
- analysis::modrm_analyze(cpu, modrm_byte);
3590
- }
3591
- else {
3592
- }
3593
- },
3594
- 3 => {
3595
- if modrm_byte < 0xC0 {
3596
- analysis::modrm_analyze(cpu, modrm_byte);
3597
- }
3598
- else {
3599
- }
3600
- },
3601
- 4 => {
3602
- if modrm_byte < 0xC0 {
3603
- analysis::modrm_analyze(cpu, modrm_byte);
3604
- }
3605
- else {
3606
- }
3607
- },
3608
- 5 => {
3609
- if modrm_byte < 0xC0 {
3610
- analysis::modrm_analyze(cpu, modrm_byte);
3611
- }
3612
- else {
3613
- }
3614
- },
3615
- 6 => {
3616
- if modrm_byte < 0xC0 {
3617
- analysis::modrm_analyze(cpu, modrm_byte);
3618
- }
3619
- else {
3620
- }
3621
- },
3622
- 7 => {
3623
- if modrm_byte < 0xC0 {
3624
- analysis::modrm_analyze(cpu, modrm_byte);
3625
- }
3626
- else {
3627
- }
3628
- },
3629
- _ => {
3630
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3631
- analysis.no_next_instruction = true;
3632
- }
3633
- }
3634
- },
3635
- 0xF8 | 0x1F8 => {
3636
- },
3637
- 0xF9 | 0x1F9 => {
3638
- },
3639
- 0xFA | 0x1FA => {
3640
- },
3641
- 0xFB | 0x1FB => {
3642
- analysis.ty = analysis::AnalysisType::STI;
3643
- },
3644
- 0xFC | 0x1FC => {
3645
- },
3646
- 0xFD | 0x1FD => {
3647
- },
3648
- 0xFE | 0x1FE => {
3649
- let modrm_byte = cpu.read_imm8();
3650
- match modrm_byte >> 3 & 7 {
3651
- 0 => {
3652
- if modrm_byte < 0xC0 {
3653
- analysis::modrm_analyze(cpu, modrm_byte);
3654
- }
3655
- else {
3656
- }
3657
- },
3658
- 1 => {
3659
- if modrm_byte < 0xC0 {
3660
- analysis::modrm_analyze(cpu, modrm_byte);
3661
- }
3662
- else {
3663
- }
3664
- },
3665
- _ => {
3666
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3667
- analysis.no_next_instruction = true;
3668
- }
3669
- }
3670
- },
3671
- 0xFF => {
3672
- let modrm_byte = cpu.read_imm8();
3673
- match modrm_byte >> 3 & 7 {
3674
- 0 => {
3675
- if modrm_byte < 0xC0 {
3676
- analysis::modrm_analyze(cpu, modrm_byte);
3677
- }
3678
- else {
3679
- }
3680
- },
3681
- 1 => {
3682
- if modrm_byte < 0xC0 {
3683
- analysis::modrm_analyze(cpu, modrm_byte);
3684
- }
3685
- else {
3686
- }
3687
- },
3688
- 2 => {
3689
- if modrm_byte < 0xC0 {
3690
- analysis::modrm_analyze(cpu, modrm_byte);
3691
- }
3692
- else {
3693
- }
3694
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3695
- analysis.absolute_jump = true;
3696
- },
3697
- 3 => {
3698
- if modrm_byte < 0xC0 {
3699
- analysis::modrm_analyze(cpu, modrm_byte);
3700
- }
3701
- else {
3702
- }
3703
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3704
- },
3705
- 4 => {
3706
- if modrm_byte < 0xC0 {
3707
- analysis::modrm_analyze(cpu, modrm_byte);
3708
- }
3709
- else {
3710
- }
3711
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3712
- analysis.no_next_instruction = true;
3713
- analysis.absolute_jump = true;
3714
- },
3715
- 5 => {
3716
- if modrm_byte < 0xC0 {
3717
- analysis::modrm_analyze(cpu, modrm_byte);
3718
- }
3719
- else {
3720
- }
3721
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3722
- analysis.no_next_instruction = true;
3723
- },
3724
- 6 => {
3725
- if modrm_byte < 0xC0 {
3726
- analysis::modrm_analyze(cpu, modrm_byte);
3727
- }
3728
- else {
3729
- }
3730
- },
3731
- _ => {
3732
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3733
- analysis.no_next_instruction = true;
3734
- }
3735
- }
3736
- },
3737
- 0x1FF => {
3738
- let modrm_byte = cpu.read_imm8();
3739
- match modrm_byte >> 3 & 7 {
3740
- 0 => {
3741
- if modrm_byte < 0xC0 {
3742
- analysis::modrm_analyze(cpu, modrm_byte);
3743
- }
3744
- else {
3745
- }
3746
- },
3747
- 1 => {
3748
- if modrm_byte < 0xC0 {
3749
- analysis::modrm_analyze(cpu, modrm_byte);
3750
- }
3751
- else {
3752
- }
3753
- },
3754
- 2 => {
3755
- if modrm_byte < 0xC0 {
3756
- analysis::modrm_analyze(cpu, modrm_byte);
3757
- }
3758
- else {
3759
- }
3760
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3761
- analysis.absolute_jump = true;
3762
- },
3763
- 3 => {
3764
- if modrm_byte < 0xC0 {
3765
- analysis::modrm_analyze(cpu, modrm_byte);
3766
- }
3767
- else {
3768
- }
3769
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3770
- },
3771
- 4 => {
3772
- if modrm_byte < 0xC0 {
3773
- analysis::modrm_analyze(cpu, modrm_byte);
3774
- }
3775
- else {
3776
- }
3777
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3778
- analysis.no_next_instruction = true;
3779
- analysis.absolute_jump = true;
3780
- },
3781
- 5 => {
3782
- if modrm_byte < 0xC0 {
3783
- analysis::modrm_analyze(cpu, modrm_byte);
3784
- }
3785
- else {
3786
- }
3787
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3788
- analysis.no_next_instruction = true;
3789
- },
3790
- 6 => {
3791
- if modrm_byte < 0xC0 {
3792
- analysis::modrm_analyze(cpu, modrm_byte);
3793
- }
3794
- else {
3795
- }
3796
- },
3797
- _ => {
3798
- analysis.ty = analysis::AnalysisType::BlockBoundary;
3799
- analysis.no_next_instruction = true;
3800
- }
3801
- }
3802
- },
3803
- _ => {
3804
- dbg_assert!(false);
3805
- }
3806
- }
3807
- }