@aptre/v86 0.5.0 → 0.6.0

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