From 1bf1084f2b10c3b47fd1a588d85d21ed0eb41d0c Mon Sep 17 00:00:00 2001 From: Lorry Tar Creator Date: Tue, 27 Jun 2017 06:07:23 +0000 Subject: webkitgtk-2.16.5 --- .../disassembler/udis86/differences.txt | 9 + .../JavaScriptCore/disassembler/udis86/optable.xml | 10099 +++++++++++++++++++ .../JavaScriptCore/disassembler/udis86/ud_itab.py | 379 + .../disassembler/udis86/ud_opcode.py | 622 ++ Source/JavaScriptCore/disassembler/udis86/udis86.c | 462 + Source/JavaScriptCore/disassembler/udis86/udis86.h | 33 + .../disassembler/udis86/udis86_decode.c | 1273 +++ .../disassembler/udis86/udis86_decode.h | 197 + .../disassembler/udis86/udis86_extern.h | 113 + .../disassembler/udis86/udis86_itab_holder.c | 33 + .../disassembler/udis86/udis86_syn-att.c | 235 + .../disassembler/udis86/udis86_syn-intel.c | 231 + .../disassembler/udis86/udis86_syn.c | 219 + .../disassembler/udis86/udis86_syn.h | 53 + .../disassembler/udis86/udis86_types.h | 260 + .../disassembler/udis86/udis86_udint.h | 98 + 16 files changed, 14316 insertions(+) create mode 100644 Source/JavaScriptCore/disassembler/udis86/differences.txt create mode 100644 Source/JavaScriptCore/disassembler/udis86/optable.xml create mode 100644 Source/JavaScriptCore/disassembler/udis86/ud_itab.py create mode 100644 Source/JavaScriptCore/disassembler/udis86/ud_opcode.py create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86.c create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86.h create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_decode.c create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_decode.h create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_extern.h create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_itab_holder.c create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_syn-att.c create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_syn-intel.c create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_syn.c create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_syn.h create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_types.h create mode 100644 Source/JavaScriptCore/disassembler/udis86/udis86_udint.h (limited to 'Source/JavaScriptCore/disassembler/udis86') diff --git a/Source/JavaScriptCore/disassembler/udis86/differences.txt b/Source/JavaScriptCore/disassembler/udis86/differences.txt new file mode 100644 index 000000000..c3dabf6f0 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/differences.txt @@ -0,0 +1,9 @@ +This documents the differences between the stock version of udis86 and the one found +here: + +- All files not named "udis86" were prefixed with "udis86". + +- assert() has been changed to ASSERT() + +- Fixed udis86_syn-att.c's jump destination printing to work correctly in 64-bit mode. + diff --git a/Source/JavaScriptCore/disassembler/udis86/optable.xml b/Source/JavaScriptCore/disassembler/udis86/optable.xml new file mode 100644 index 000000000..3bda8587e --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/optable.xml @@ -0,0 +1,10099 @@ + + + + + + + + aaa + + 37 /m=!64 + + + + + aad + + d5 /m=!64 + Ib + + + + + aam + + d4 /m=!64 + Ib + + + + + aas + + 3f /m=!64 + + + + + adc + + aso rexr rexx rexb + 10 + Eb Gb + + + aso oso rexw rexr rexx rexb + 11 + Ev Gv + + + aso rexr rexx rexb + 12 + Gb Eb + + + aso oso rexw rexr rexx rexb + 13 + Gv Ev + + + 14 + AL Ib + + + oso rexw + 15 + rAX sIz + + + aso rexr rexx rexb + 80 /reg=2 + Eb Ib + + + aso rexr rexx rexb + 82 /reg=2 /m=!64 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 81 /reg=2 + Ev sIz + + + aso oso rexw rexr rexx rexb + 83 /reg=2 + Ev sIb + + + + + add + + aso rexr rexx rexb + 00 + Eb Gb + + + aso oso rexw rexr rexx rexb + 01 + Ev Gv + + + aso rexr rexx rexb + 02 + Gb Eb + + + aso oso rexw rexr rexx rexb + 03 + Gv Ev + + + 04 + AL Ib + + + oso rexw + 05 + rAX sIz + + + aso rexr rexx rexb + 80 /reg=0 + Eb Ib + + + aso rexr rexx rexb + 82 /reg=0 /m=!64 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 81 /reg=0 + Ev sIz + + + aso oso rexw rexr rexx rexb + 83 /reg=0 + Ev sIb + + + + + addpd + + aso rexr rexx rexb vexl + /sse=66 0f 58 + V H W + sse2 avx + + + + + addps + + aso rexr rexx rexb vexl + 0f 58 + V H W + sse avx + + + + + addsd + + aso rexr rexx rexb + /sse=f2 0f 58 + V H W + sse2 avx + + + + + addss + + aso rexr rexx rexb + /sse=f3 0f 58 + V H W + sse avx + + + + + addsubpd + + aso rexr rexx rexb + /sse=66 0f d0 + V H W + sse3 avx + + + + + addsubps + + aso rexr rexx rexb + /sse=f2 0f d0 + V H W + sse3 avx + + + + + aesdec + + aso rexr rexx rexb + /sse=66 0f 38 de + V H W + aesni avx + + + + + aesdeclast + + aso rexr rexx rexb + /sse=66 0f 38 df + V W + aesni avx + + + + + aesenc + aesni + + aso rexr rexx rexb + /sse=66 0f 38 dc + V W + aesni avx + + + + + aesenclast + aesni avx + + aso rexr rexx rexb + /sse=66 0f 38 dd + V H W + + + + + aesimc + + aso rexr rexx rexb + /sse=66 0f 38 db + V W + aesni avx + + + + + aeskeygenassist + + aso rexr rexx rexb + /sse=66 0f 3a df + V W Ib + aesni avx + + + + + and + + aso rexr rexx rexb + 20 + Eb Gb + + + aso oso rexw rexr rexx rexb + 21 + Ev Gv + + + aso rexr rexx rexb + 22 + Gb Eb + + + aso oso rexw rexr rexx rexb + 23 + Gv Ev + + + 24 + AL Ib + + + oso rexw + 25 + rAX sIz + + + aso rexw rexr rexx rexb + 80 /reg=4 + Eb Ib + + + aso rexr rexx rexb + 82 /reg=4 /m=!64 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 81 /reg=4 + Ev sIz + + + aso oso rexw rexr rexx rexb + 83 /reg=4 + Ev sIb + + + + + andpd + + aso rexr rexx rexb vexl + /sse=66 0f 54 + V H W + sse2 avx + + + + + andps + + aso rexr rexx rexb + 0f 54 + V H W + sse avx + + + + + andnpd + + aso rexr rexx rexb + /sse=66 0f 55 + V H W + sse2 avx + + + + + andnps + + aso rexr rexx rexb + 0f 55 + V H W + sse2 avx + + + + + arpl + + aso + 63 /m=!64 + Ew Gw + + + + + movsxd + + aso oso rexw rexx rexr rexb + 63 /m=64 + Gq Ed + + + + + call + + aso oso rexw rexr rexx rexb + ff /reg=2 /m=!64 + Ev + + + aso oso rexw rexr rexx rexb + ff /reg=2 /m=64 + Eq + def64 + + + aso oso rexw rexr rexx rexb + ff /reg=3 + Fv + + + oso + e8 + Jz + def64 + + + oso + 9a /m=!64 + Av + + + + + cbw + + oso rexw + 98 /o=16 + + + + + cwde + + oso rexw + 98 /o=32 + + + + + cdqe + + oso rexw + 98 /o=64 + + + + + clc + + f8 + + + + + cld + + fc + + + + + clflush + + aso rexw rexr rexx rexb + 0f ae /reg=7 /mod=!11 + M + + + + + clgi + amd + + 0f 01 /reg=3 /mod=11 /rm=5 + + + + + cli + + fa + + + + + clts + + 0f 06 + + + + + cmc + + f5 + + + + + cmovo + + aso oso rexw rexr rexx rexb + 0f 40 + Gv Ev + + + + + cmovno + + aso oso rexw rexr rexx rexb + 0f 41 + Gv Ev + + + + + cmovb + + aso oso rexw rexr rexx rexb + 0f 42 + Gv Ev + + + + + cmovae + + aso oso rexw rexr rexx rexb + 0f 43 + Gv Ev + + + + + cmovz + + aso oso rexw rexr rexx rexb + 0f 44 + Gv Ev + + + + + cmovnz + + aso oso rexw rexr rexx rexb + 0f 45 + Gv Ev + + + + + cmovbe + + aso oso rexw rexr rexx rexb + 0f 46 + Gv Ev + + + + + cmova + + aso oso rexw rexr rexx rexb + 0f 47 + Gv Ev + + + + + cmovs + + aso oso rexw rexr rexx rexb + 0f 48 + Gv Ev + + + + + cmovns + + aso oso rexw rexr rexx rexb + 0f 49 + Gv Ev + + + + + cmovp + + aso oso rexw rexr rexx rexb + 0f 4a + Gv Ev + + + + + cmovnp + + aso oso rexw rexr rexx rexb + 0f 4b + Gv Ev + + + + + cmovl + + aso oso rexw rexr rexx rexb + 0f 4c + Gv Ev + + + + + cmovge + + aso oso rexw rexr rexx rexb + 0f 4d + Gv Ev + + + + + cmovle + + aso oso rexw rexr rexx rexb + 0f 4e + Gv Ev + + + + + cmovg + + aso oso rexw rexr rexx rexb + 0f 4f + Gv Ev + + + + + cmp + + aso rexr rexx rexb + 38 + Eb Gb + + + aso oso rexw rexr rexx rexb + 39 + Ev Gv + + + aso rexr rexx rexb + 3a + Gb Eb + + + aso oso rexw rexr rexx rexb + 3b + Gv Ev + + + 3c + AL Ib + + + oso rexw + 3d + rAX sIz + + + aso rexr rexx rexb + 80 /reg=7 + Eb Ib + + + aso rexr rexx rexb + 82 /reg=7 /m=!64 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 81 /reg=7 + Ev sIz + + + aso oso rexw rexr rexx rexb + 83 /reg=7 + Ev sIb + + + + + cmppd + + aso rexr rexx rexb vexl + /sse=66 0f c2 + V H W Ib + sse2 avx + + + + + cmpps + + aso rexr rexx rexb vexl + 0f c2 + V H W Ib + sse2 avx + + + + + cmpsb + + repz seg + a6 + + + + + cmpsw + + repz oso rexw seg + a7 /o=16 + + + + + cmpsd + + repz oso rexw seg + a7 /o=32 + + + aso rexr rexx rexb + /sse=f2 0f c2 + V H W Ib + sse2 avx + + + + + cmpsq + + repz oso rexw seg + a7 /o=64 + + + + + cmpss + + aso rexr rexx rexb + /sse=f3 0f c2 + V H W Ib + sse2 avx + + + + + cmpxchg + + aso rexr rexx rexb + 0f b0 + Eb Gb + + + aso oso rexw rexr rexx rexb + 0f b1 + Ev Gv + + + + + cmpxchg8b + + aso rexr rexx rexb + 0f c7 /mod=!11 /reg=1 /o=16 + M + + + aso rexr rexx rexb + 0f c7 /mod=!11 /reg=1 /o=32 + M + + + + + cmpxchg16b + + aso rexr rexx rexb + 0f c7 /mod=!11 /reg=1 /o=64 + M + + + + + comisd + + aso rexr rexx rexb + /sse=66 0f 2f + Vsd Wsd + sse2 avx + + + + + comiss + + aso rexr rexx rexb + 0f 2f + V W + sse2 avx + + + + + cpuid + + 0f a2 + + + + + cvtdq2pd + + aso rexr rexx rexb vexl + /sse=f3 0f e6 + V Wdq + sse2 avx + + + + + cvtdq2ps + + aso rexr rexx rexb + 0f 5b + V W + sse2 avx + + + + + cvtpd2dq + + aso rexr rexx rexb vexl + /sse=f2 0f e6 + Vdq W + sse2 avx + + + + + cvtpd2pi + + aso rexr rexx rexb + /sse=66 0f 2d + P W + + + + + cvtpd2ps + + aso rexr rexx rexb vexl + /sse=66 0f 5a + Vdq W + sse2 avx + + + + + cvtpi2ps + + aso rexr rexx rexb + 0f 2a + V Q + + + + + cvtpi2pd + + aso rexr rexx rexb + /sse=66 0f 2a + V Q + + + + + cvtps2dq + + aso rexr rexx rexb vexl + /sse=66 0f 5b + V W + sse2 avx + + + + + cvtps2pd + + aso rexr rexx rexb vexl + 0f 5a + V Wdq + sse2 avx + + + + + cvtps2pi + + aso rexr rexx rexb + 0f 2d + P MqU + + + + + cvtsd2si + + aso rexw rexr rexx rexb + /sse=f2 0f 2d + Gy MqU + sse2 avx + + + + + cvtsd2ss + + aso rexr rexx rexb + /sse=f2 0f 5a + V H W + sse2 avx + + + + + cvtsi2sd + + aso rexw rexr rexx rexb + /sse=f2 0f 2a + V H Ey + sse2 avx + + + + + cvtsi2ss + + aso rexw rexr rexx rexb + /sse=f3 0f 2a + V H Ey + sse avx + + + + + cvtss2sd + + aso rexr rexx rexb + /sse=f3 0f 5a + V H W + sse2 avx + + + + + cvtss2si + + aso rexw rexr rexx rexb + /sse=f3 0f 2d + Gy MdU + sse avx + + + + + cvttpd2dq + + aso rexr rexx rexb vexl + /sse=66 0f e6 + Vdq W + sse2 avx + + + + + cvttpd2pi + + aso rexr rexx rexb + /sse=66 0f 2c + P W + + + + + cvttps2dq + + aso rexr rexx rexb vexl + /sse=f3 0f 5b + V W + sse2 avx + + + + + cvttps2pi + + aso rexr rexx rexb + 0f 2c + P W + + + + + cvttsd2si + + aso rexw rexr rexx rexb + /sse=f2 0f 2c + Gy MqU + sse2 avx + + + + + cvttss2si + + aso rexw rexr rexx rexb + /sse=f3 0f 2c + Gy MdU + sse2 avx + + + + + cwd + + oso rexw + 99 /o=16 + + + + + cdq + + oso rexw + 99 /o=32 + + + + + cqo + + oso rexw + 99 /o=64 + + + + + daa + + 27 /m=!64 + inv64 + + + + + das + + 2f /m=!64 + inv64 + + + + + dec + + oso + 48 + R0z + + + oso + 49 + R1z + + + oso + 4a + R2z + + + oso + 4b + R3z + + + oso + 4c + R4z + + + oso + 4d + R5z + + + oso + 4e + R6z + + + oso + 4f + R7z + + + aso rexw rexr rexx rexb + fe /reg=1 + Eb + + + aso oso rexw rexr rexx rexb + ff /reg=1 + Ev + + + + + div + + aso oso rexw rexr rexx rexb + f7 /reg=6 + Ev + + + aso rexw rexr rexx rexb + f6 /reg=6 + Eb + + + + + divpd + + aso rexr rexx rexb vexl + /sse=66 0f 5e + V H W + sse2 avx + + + + + divps + + aso rexr rexx rexb + 0f 5e + V H W + sse avx + + + + + divsd + + aso rexr rexx rexb + /sse=f2 0f 5e + V H MqU + sse2 avx + + + + + divss + + aso rexr rexx rexb + /sse=f3 0f 5e + V H MdU + sse avx + + + + + dppd + + aso rexr rexx rexb + /sse=66 0f 3a 41 + V H W Ib + sse4.1 avx + + + + + dpps + + aso rexr rexx rexb vexl + /sse=66 0f 3a 40 + V H W Ib + sse4.1 avx + + + + + emms + + 0f 77 + + + + + enter + + c8 + Iw Ib + def64 + + + + + extractps + + aso rexr rexw rexx rexb + /sse=66 0f 3a 17 + MdRy V Ib + sse4.1 avx + + + + + f2xm1 + X87 + + d9 /mod=11 /x87=30 + + + + + fabs + X87 + + d9 /mod=11 /x87=21 + + + + + fadd + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=0 + Mq + + + aso rexr rexx rexb + d8 /mod=!11 /reg=0 + Md + + + dc /mod=11 /x87=00 + ST0 ST0 + + + dc /mod=11 /x87=01 + ST1 ST0 + + + dc /mod=11 /x87=02 + ST2 ST0 + + + dc /mod=11 /x87=03 + ST3 ST0 + + + dc /mod=11 /x87=04 + ST4 ST0 + + + dc /mod=11 /x87=05 + ST5 ST0 + + + dc /mod=11 /x87=06 + ST6 ST0 + + + dc /mod=11 /x87=07 + ST7 ST0 + + + d8 /mod=11 /x87=00 + ST0 ST0 + + + d8 /mod=11 /x87=01 + ST0 ST1 + + + d8 /mod=11 /x87=02 + ST0 ST2 + + + d8 /mod=11 /x87=03 + ST0 ST3 + + + d8 /mod=11 /x87=04 + ST0 ST4 + + + d8 /mod=11 /x87=05 + ST0 ST5 + + + d8 /mod=11 /x87=06 + ST0 ST6 + + + d8 /mod=11 /x87=07 + ST0 ST7 + + + + + faddp + X87 + + de /mod=11 /x87=00 + ST0 ST0 + + + de /mod=11 /x87=01 + ST1 ST0 + + + de /mod=11 /x87=02 + ST2 ST0 + + + de /mod=11 /x87=03 + ST3 ST0 + + + de /mod=11 /x87=04 + ST4 ST0 + + + de /mod=11 /x87=05 + ST5 ST0 + + + de /mod=11 /x87=06 + ST6 ST0 + + + de /mod=11 /x87=07 + ST7 ST0 + + + + + fbld + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=4 + Mt + + + + + fbstp + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=6 + Mt + + + + + fchs + X87 + + d9 /mod=11 /x87=20 + + + + + fclex + X87 + + db /mod=11 /x87=22 + + + + + fcmovb + X87 + + da /mod=11 /x87=00 + ST0 ST0 + + + da /mod=11 /x87=01 + ST0 ST1 + + + da /mod=11 /x87=02 + ST0 ST2 + + + da /mod=11 /x87=03 + ST0 ST3 + + + da /mod=11 /x87=04 + ST0 ST4 + + + da /mod=11 /x87=05 + ST0 ST5 + + + da /mod=11 /x87=06 + ST0 ST6 + + + da /mod=11 /x87=07 + ST0 ST7 + + + + + fcmove + X87 + + da /mod=11 /x87=08 + ST0 ST0 + + + da /mod=11 /x87=09 + ST0 ST1 + + + da /mod=11 /x87=0a + ST0 ST2 + + + da /mod=11 /x87=0b + ST0 ST3 + + + da /mod=11 /x87=0c + ST0 ST4 + + + da /mod=11 /x87=0d + ST0 ST5 + + + da /mod=11 /x87=0e + ST0 ST6 + + + da /mod=11 /x87=0f + ST0 ST7 + + + + + fcmovbe + X87 + + da /mod=11 /x87=10 + ST0 ST0 + + + da /mod=11 /x87=11 + ST0 ST1 + + + da /mod=11 /x87=12 + ST0 ST2 + + + da /mod=11 /x87=13 + ST0 ST3 + + + da /mod=11 /x87=14 + ST0 ST4 + + + da /mod=11 /x87=15 + ST0 ST5 + + + da /mod=11 /x87=16 + ST0 ST6 + + + da /mod=11 /x87=17 + ST0 ST7 + + + + + fcmovu + X87 + + da /mod=11 /x87=18 + ST0 ST0 + + + da /mod=11 /x87=19 + ST0 ST1 + + + da /mod=11 /x87=1a + ST0 ST2 + + + da /mod=11 /x87=1b + ST0 ST3 + + + da /mod=11 /x87=1c + ST0 ST4 + + + da /mod=11 /x87=1d + ST0 ST5 + + + da /mod=11 /x87=1e + ST0 ST6 + + + da /mod=11 /x87=1f + ST0 ST7 + + + + + fcmovnb + X87 + + db /mod=11 /x87=00 + ST0 ST0 + + + db /mod=11 /x87=01 + ST0 ST1 + + + db /mod=11 /x87=02 + ST0 ST2 + + + db /mod=11 /x87=03 + ST0 ST3 + + + db /mod=11 /x87=04 + ST0 ST4 + + + db /mod=11 /x87=05 + ST0 ST5 + + + db /mod=11 /x87=06 + ST0 ST6 + + + db /mod=11 /x87=07 + ST0 ST7 + + + + + fcmovne + X87 + + db /mod=11 /x87=08 + ST0 ST0 + + + db /mod=11 /x87=09 + ST0 ST1 + + + db /mod=11 /x87=0a + ST0 ST2 + + + db /mod=11 /x87=0b + ST0 ST3 + + + db /mod=11 /x87=0c + ST0 ST4 + + + db /mod=11 /x87=0d + ST0 ST5 + + + db /mod=11 /x87=0e + ST0 ST6 + + + db /mod=11 /x87=0f + ST0 ST7 + + + + + fcmovnbe + X87 + + db /mod=11 /x87=10 + ST0 ST0 + + + db /mod=11 /x87=11 + ST0 ST1 + + + db /mod=11 /x87=12 + ST0 ST2 + + + db /mod=11 /x87=13 + ST0 ST3 + + + db /mod=11 /x87=14 + ST0 ST4 + + + db /mod=11 /x87=15 + ST0 ST5 + + + db /mod=11 /x87=16 + ST0 ST6 + + + db /mod=11 /x87=17 + ST0 ST7 + + + + + fcmovnu + X87 + + db /mod=11 /x87=18 + ST0 ST0 + + + db /mod=11 /x87=19 + ST0 ST1 + + + db /mod=11 /x87=1a + ST0 ST2 + + + db /mod=11 /x87=1b + ST0 ST3 + + + db /mod=11 /x87=1c + ST0 ST4 + + + db /mod=11 /x87=1d + ST0 ST5 + + + db /mod=11 /x87=1e + ST0 ST6 + + + db /mod=11 /x87=1f + ST0 ST7 + + + + + fucomi + X87 + + db /mod=11 /x87=28 + ST0 ST0 + + + db /mod=11 /x87=29 + ST0 ST1 + + + db /mod=11 /x87=2a + ST0 ST2 + + + db /mod=11 /x87=2b + ST0 ST3 + + + db /mod=11 /x87=2c + ST0 ST4 + + + db /mod=11 /x87=2d + ST0 ST5 + + + db /mod=11 /x87=2e + ST0 ST6 + + + db /mod=11 /x87=2f + ST0 ST7 + + + + + fcom + X87 + + aso rexr rexx rexb + d8 /mod=!11 /reg=2 + Md + + + aso rexr rexx rexb + dc /mod=!11 /reg=2 + Mq + + + d8 /mod=11 /x87=10 + ST0 ST0 + + + d8 /mod=11 /x87=11 + ST0 ST1 + + + d8 /mod=11 /x87=12 + ST0 ST2 + + + d8 /mod=11 /x87=13 + ST0 ST3 + + + d8 /mod=11 /x87=14 + ST0 ST4 + + + d8 /mod=11 /x87=15 + ST0 ST5 + + + d8 /mod=11 /x87=16 + ST0 ST6 + + + d8 /mod=11 /x87=17 + ST0 ST7 + + + + + fcom2 + X87 UNDOC + + dc /mod=11 /x87=10 + ST0 + + + dc /mod=11 /x87=11 + ST1 + + + dc /mod=11 /x87=12 + ST2 + + + dc /mod=11 /x87=13 + ST3 + + + dc /mod=11 /x87=14 + ST4 + + + dc /mod=11 /x87=15 + ST5 + + + dc /mod=11 /x87=16 + ST6 + + + dc /mod=11 /x87=17 + ST7 + + + + + fcomp3 + X87 UNDOC + + dc /mod=11 /x87=18 + ST0 + + + dc /mod=11 /x87=19 + ST1 + + + dc /mod=11 /x87=1a + ST2 + + + dc /mod=11 /x87=1b + ST3 + + + dc /mod=11 /x87=1c + ST4 + + + dc /mod=11 /x87=1d + ST5 + + + dc /mod=11 /x87=1e + ST6 + + + dc /mod=11 /x87=1f + ST7 + + + + + fcomi + X87 + + db /mod=11 /x87=30 + ST0 ST0 + + + db /mod=11 /x87=31 + ST0 ST1 + + + db /mod=11 /x87=32 + ST0 ST2 + + + db /mod=11 /x87=33 + ST0 ST3 + + + db /mod=11 /x87=34 + ST0 ST4 + + + db /mod=11 /x87=35 + ST0 ST5 + + + db /mod=11 /x87=36 + ST0 ST6 + + + db /mod=11 /x87=37 + ST0 ST7 + + + + + fucomip + X87 + + df /mod=11 /x87=28 + ST0 ST0 + + + df /mod=11 /x87=29 + ST0 ST1 + + + df /mod=11 /x87=2a + ST0 ST2 + + + df /mod=11 /x87=2b + ST0 ST3 + + + df /mod=11 /x87=2c + ST0 ST4 + + + df /mod=11 /x87=2d + ST0 ST5 + + + df /mod=11 /x87=2e + ST0 ST6 + + + df /mod=11 /x87=2f + ST0 ST7 + + + + + fcomip + X87 + + df /mod=11 /x87=30 + ST0 ST0 + + + df /mod=11 /x87=31 + ST0 ST1 + + + df /mod=11 /x87=32 + ST0 ST2 + + + df /mod=11 /x87=33 + ST0 ST3 + + + df /mod=11 /x87=34 + ST0 ST4 + + + df /mod=11 /x87=35 + ST0 ST5 + + + df /mod=11 /x87=36 + ST0 ST6 + + + df /mod=11 /x87=37 + ST0 ST7 + + + + + fcomp + X87 + + aso rexr rexx rexb + d8 /mod=!11 /reg=3 + Md + + + aso rexr rexx rexb + dc /mod=!11 /reg=3 + Mq + + + d8 /mod=11 /x87=18 + ST0 ST0 + + + d8 /mod=11 /x87=19 + ST0 ST1 + + + d8 /mod=11 /x87=1a + ST0 ST2 + + + d8 /mod=11 /x87=1b + ST0 ST3 + + + d8 /mod=11 /x87=1c + ST0 ST4 + + + d8 /mod=11 /x87=1d + ST0 ST5 + + + d8 /mod=11 /x87=1e + ST0 ST6 + + + d8 /mod=11 /x87=1f + ST0 ST7 + + + + + fcomp5 + X87 UNDOC + + de /mod=11 /x87=10 + ST0 + + + de /mod=11 /x87=11 + ST1 + + + de /mod=11 /x87=12 + ST2 + + + de /mod=11 /x87=13 + ST3 + + + de /mod=11 /x87=14 + ST4 + + + de /mod=11 /x87=15 + ST5 + + + de /mod=11 /x87=16 + ST6 + + + de /mod=11 /x87=17 + ST7 + + + + + fcompp + X87 + + de /mod=11 /x87=19 + + + + + fcos + X87 + + d9 /mod=11 /x87=3f + + + + + fdecstp + X87 + + d9 /mod=11 /x87=36 + + + + + fdiv + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=6 + Mq + + + dc /mod=11 /x87=38 + ST0 ST0 + + + dc /mod=11 /x87=39 + ST1 ST0 + + + dc /mod=11 /x87=3a + ST2 ST0 + + + dc /mod=11 /x87=3b + ST3 ST0 + + + dc /mod=11 /x87=3c + ST4 ST0 + + + dc /mod=11 /x87=3d + ST5 ST0 + + + dc /mod=11 /x87=3e + ST6 ST0 + + + dc /mod=11 /x87=3f + ST7 ST0 + + + aso rexr rexx rexb + d8 /mod=!11 /reg=6 + Md + + + d8 /mod=11 /x87=30 + ST0 ST0 + + + d8 /mod=11 /x87=31 + ST0 ST1 + + + d8 /mod=11 /x87=32 + ST0 ST2 + + + d8 /mod=11 /x87=33 + ST0 ST3 + + + d8 /mod=11 /x87=34 + ST0 ST4 + + + d8 /mod=11 /x87=35 + ST0 ST5 + + + d8 /mod=11 /x87=36 + ST0 ST6 + + + d8 /mod=11 /x87=37 + ST0 ST7 + + + + + fdivp + X87 + + de /mod=11 /x87=38 + ST0 ST0 + + + de /mod=11 /x87=39 + ST1 ST0 + + + de /mod=11 /x87=3a + ST2 ST0 + + + de /mod=11 /x87=3b + ST3 ST0 + + + de /mod=11 /x87=3c + ST4 ST0 + + + de /mod=11 /x87=3d + ST5 ST0 + + + de /mod=11 /x87=3e + ST6 ST0 + + + de /mod=11 /x87=3f + ST7 ST0 + + + + + fdivr + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=7 + Mq + + + dc /mod=11 /x87=30 + ST0 ST0 + + + dc /mod=11 /x87=31 + ST1 ST0 + + + dc /mod=11 /x87=32 + ST2 ST0 + + + dc /mod=11 /x87=33 + ST3 ST0 + + + dc /mod=11 /x87=34 + ST4 ST0 + + + dc /mod=11 /x87=35 + ST5 ST0 + + + dc /mod=11 /x87=36 + ST6 ST0 + + + dc /mod=11 /x87=37 + ST7 ST0 + + + aso rexr rexx rexb + d8 /mod=!11 /reg=7 + Md + + + d8 /mod=11 /x87=38 + ST0 ST0 + + + d8 /mod=11 /x87=39 + ST0 ST1 + + + d8 /mod=11 /x87=3a + ST0 ST2 + + + d8 /mod=11 /x87=3b + ST0 ST3 + + + d8 /mod=11 /x87=3c + ST0 ST4 + + + d8 /mod=11 /x87=3d + ST0 ST5 + + + d8 /mod=11 /x87=3e + ST0 ST6 + + + d8 /mod=11 /x87=3f + ST0 ST7 + + + + + fdivrp + X87 + + de /mod=11 /x87=30 + ST0 ST0 + + + de /mod=11 /x87=31 + ST1 ST0 + + + de /mod=11 /x87=32 + ST2 ST0 + + + de /mod=11 /x87=33 + ST3 ST0 + + + de /mod=11 /x87=34 + ST4 ST0 + + + de /mod=11 /x87=35 + ST5 ST0 + + + de /mod=11 /x87=36 + ST6 ST0 + + + de /mod=11 /x87=37 + ST7 ST0 + + + + + femms + + 0f 0e + + + + + ffree + X87 + + dd /mod=11 /x87=00 + ST0 + + + dd /mod=11 /x87=01 + ST1 + + + dd /mod=11 /x87=02 + ST2 + + + dd /mod=11 /x87=03 + ST3 + + + dd /mod=11 /x87=04 + ST4 + + + dd /mod=11 /x87=05 + ST5 + + + dd /mod=11 /x87=06 + ST6 + + + dd /mod=11 /x87=07 + ST7 + + + + + ffreep + X87 + + df /mod=11 /x87=00 + ST0 + + + df /mod=11 /x87=01 + ST1 + + + df /mod=11 /x87=02 + ST2 + + + df /mod=11 /x87=03 + ST3 + + + df /mod=11 /x87=04 + ST4 + + + df /mod=11 /x87=05 + ST5 + + + df /mod=11 /x87=06 + ST6 + + + df /mod=11 /x87=07 + ST7 + + + + + ficom + X87 + + aso rexr rexx rexb + de /mod=!11 /reg=2 + Mw + + + aso rexr rexx rexb + da /mod=!11 /reg=2 + Md + + + + + ficomp + X87 + + aso rexr rexx rexb + de /mod=!11 /reg=3 + Mw + + + aso rexr rexx rexb + da /mod=!11 /reg=3 + Md + + + + + fild + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=0 + Mw + + + aso rexr rexx rexb + df /mod=!11 /reg=5 + Mq + + + aso rexr rexx rexb + db /mod=!11 /reg=0 + Md + + + + + fincstp + X87 + + d9 /mod=11 /x87=37 + + + + + fninit + X87 + + db /mod=11 /x87=23 + + + + + fiadd + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=0 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=0 + Mw + + + + + fidivr + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=7 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=7 + Mw + + + + + fidiv + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=6 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=6 + Mw + + + + + fisub + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=4 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=4 + Mw + + + + + fisubr + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=5 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=5 + Mw + + + + + fist + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=2 + Mw + + + aso rexr rexx rexb + db /mod=!11 /reg=2 + Md + + + + + fistp + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=3 + Mw + + + aso rexr rexx rexb + df /mod=!11 /reg=7 + Mq + + + aso rexr rexx rexb + db /mod=!11 /reg=3 + Md + + + + + fisttp + X87 + + aso rexr rexx rexb + db /mod=!11 /reg=1 + Md + + + aso rexr rexx rexb + dd /mod=!11 /reg=1 + Mq + + + aso rexr rexx rexb + df /mod=!11 /reg=1 + Mw + + + + + fld + X87 + + aso rexr rexx rexb + db /mod=!11 /reg=5 + Mt + + + aso rexr rexx rexb + dd /mod=!11 /reg=0 + Mq + + + aso rexr rexx rexb + d9 /mod=!11 /reg=0 + Md + + + d9 /mod=11 /x87=00 + ST0 + + + d9 /mod=11 /x87=01 + ST1 + + + d9 /mod=11 /x87=02 + ST2 + + + d9 /mod=11 /x87=03 + ST3 + + + d9 /mod=11 /x87=04 + ST4 + + + d9 /mod=11 /x87=05 + ST5 + + + d9 /mod=11 /x87=06 + ST6 + + + d9 /mod=11 /x87=07 + ST7 + + + + + fld1 + X87 + + d9 /mod=11 /x87=28 + + + + + fldl2t + X87 + + d9 /mod=11 /x87=29 + + + + + fldl2e + X87 + + d9 /mod=11 /x87=2a + + + + + fldpi + X87 + + d9 /mod=11 /x87=2b + + + + + fldlg2 + X87 + + d9 /mod=11 /x87=2c + + + + + fldln2 + X87 + + d9 /mod=11 /x87=2d + + + + + fldz + X87 + + d9 /mod=11 /x87=2e + + + + + fldcw + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=5 + Mw + + + + + fldenv + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=4 + M + + + + + fmul + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=1 + Mq + + + dc /mod=11 /x87=08 + ST0 ST0 + + + dc /mod=11 /x87=09 + ST1 ST0 + + + dc /mod=11 /x87=0a + ST2 ST0 + + + dc /mod=11 /x87=0b + ST3 ST0 + + + dc /mod=11 /x87=0c + ST4 ST0 + + + dc /mod=11 /x87=0d + ST5 ST0 + + + dc /mod=11 /x87=0e + ST6 ST0 + + + dc /mod=11 /x87=0f + ST7 ST0 + + + aso rexr rexx rexb + d8 /mod=!11 /reg=1 + Md + + + d8 /mod=11 /x87=08 + ST0 ST0 + + + d8 /mod=11 /x87=09 + ST0 ST1 + + + d8 /mod=11 /x87=0a + ST0 ST2 + + + d8 /mod=11 /x87=0b + ST0 ST3 + + + d8 /mod=11 /x87=0c + ST0 ST4 + + + d8 /mod=11 /x87=0d + ST0 ST5 + + + d8 /mod=11 /x87=0e + ST0 ST6 + + + d8 /mod=11 /x87=0f + ST0 ST7 + + + + + fmulp + X87 + + de /mod=11 /x87=08 + ST0 ST0 + + + de /mod=11 /x87=09 + ST1 ST0 + + + de /mod=11 /x87=0a + ST2 ST0 + + + de /mod=11 /x87=0b + ST3 ST0 + + + de /mod=11 /x87=0c + ST4 ST0 + + + de /mod=11 /x87=0d + ST5 ST0 + + + de /mod=11 /x87=0e + ST6 ST0 + + + de /mod=11 /x87=0f + ST7 ST0 + + + + + fimul + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=1 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=1 + Mw + + + + + fnop + X87 + + d9 /mod=11 /x87=10 + + + + + fndisi + X87 + + db /mod=11 /x87=21 + + + + + fneni + X87 + + db /mod=11 /x87=20 + + + + + fnsetpm + X87 + + db /mod=11 /x87=24 + + + + + fpatan + X87 + + d9 /mod=11 /x87=33 + + + + + fprem + X87 + + d9 /mod=11 /x87=38 + + + + + fprem1 + X87 + + d9 /mod=11 /x87=35 + + + + + fptan + X87 + + d9 /mod=11 /x87=32 + + + + + frndint + X87 + + d9 /mod=11 /x87=3c + + + + + frstor + X87 + + aso rexr rexx rexb + dd /mod=!11 /reg=4 + M + + + + + frstpm + X87 + + db /mod=11 /x87=25 + + + + + fnsave + X87 + + aso rexr rexx rexb + dd /mod=!11 /reg=6 + M + + + + + fscale + X87 + + d9 /mod=11 /x87=3d + + + + + fsin + X87 + + d9 /mod=11 /x87=3e + + + + + fsincos + X87 + + d9 /mod=11 /x87=3b + + + + + fsqrt + X87 + + d9 /mod=11 /x87=3a + + + + + fstp + X87 + + aso rexr rexx rexb + db /mod=!11 /reg=7 + Mt + + + aso rexr rexx rexb + dd /mod=!11 /reg=3 + Mq + + + aso rexr rexx rexb + d9 /mod=!11 /reg=3 + Md + + + dd /mod=11 /x87=18 + ST0 + + + dd /mod=11 /x87=19 + ST1 + + + dd /mod=11 /x87=1a + ST2 + + + dd /mod=11 /x87=1b + ST3 + + + dd /mod=11 /x87=1c + ST4 + + + dd /mod=11 /x87=1d + ST5 + + + dd /mod=11 /x87=1e + ST6 + + + dd /mod=11 /x87=1f + ST7 + + + + + fstp1 + + d9 /mod=11 /x87=18 + ST0 + + + d9 /mod=11 /x87=19 + ST1 + + + d9 /mod=11 /x87=1a + ST2 + + + d9 /mod=11 /x87=1b + ST3 + + + d9 /mod=11 /x87=1c + ST4 + + + d9 /mod=11 /x87=1d + ST5 + + + d9 /mod=11 /x87=1e + ST6 + + + d9 /mod=11 /x87=1f + ST7 + + + + + fstp8 + + df /mod=11 /x87=10 + ST0 + + + df /mod=11 /x87=11 + ST1 + + + df /mod=11 /x87=12 + ST2 + + + df /mod=11 /x87=13 + ST3 + + + df /mod=11 /x87=14 + ST4 + + + df /mod=11 /x87=15 + ST5 + + + df /mod=11 /x87=16 + ST6 + + + df /mod=11 /x87=17 + ST7 + + + + + fstp9 + + df /mod=11 /x87=18 + ST0 + + + df /mod=11 /x87=19 + ST1 + + + df /mod=11 /x87=1a + ST2 + + + df /mod=11 /x87=1b + ST3 + + + df /mod=11 /x87=1c + ST4 + + + df /mod=11 /x87=1d + ST5 + + + df /mod=11 /x87=1e + ST6 + + + df /mod=11 /x87=1f + ST7 + + + + + fst + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=2 + Md + + + aso rexr rexx rexb + dd /mod=!11 /reg=2 + Mq + + + dd /mod=11 /x87=10 + ST0 + + + dd /mod=11 /x87=11 + ST1 + + + dd /mod=11 /x87=12 + ST2 + + + dd /mod=11 /x87=13 + ST3 + + + dd /mod=11 /x87=14 + ST4 + + + dd /mod=11 /x87=15 + ST5 + + + dd /mod=11 /x87=16 + ST6 + + + dd /mod=11 /x87=17 + ST7 + + + + + fnstcw + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=7 + Mw + + + + + fnstenv + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=6 + M + + + + + fnstsw + X87 + + aso rexr rexx rexb + dd /mod=!11 /reg=7 + Mw + + + df /mod=11 /x87=20 + AX + + + + + fsub + X87 + + aso rexr rexx rexb + d8 /mod=!11 /reg=4 + Md + + + aso rexr rexx rexb + dc /mod=!11 /reg=4 + Mq + + + d8 /mod=11 /x87=20 + ST0 ST0 + + + d8 /mod=11 /x87=21 + ST0 ST1 + + + d8 /mod=11 /x87=22 + ST0 ST2 + + + d8 /mod=11 /x87=23 + ST0 ST3 + + + d8 /mod=11 /x87=24 + ST0 ST4 + + + d8 /mod=11 /x87=25 + ST0 ST5 + + + d8 /mod=11 /x87=26 + ST0 ST6 + + + d8 /mod=11 /x87=27 + ST0 ST7 + + + dc /mod=11 /x87=28 + ST0 ST0 + + + dc /mod=11 /x87=29 + ST1 ST0 + + + dc /mod=11 /x87=2a + ST2 ST0 + + + dc /mod=11 /x87=2b + ST3 ST0 + + + dc /mod=11 /x87=2c + ST4 ST0 + + + dc /mod=11 /x87=2d + ST5 ST0 + + + dc /mod=11 /x87=2e + ST6 ST0 + + + dc /mod=11 /x87=2f + ST7 ST0 + + + + + fsubp + X87 + + de /mod=11 /x87=28 + ST0 ST0 + + + de /mod=11 /x87=29 + ST1 ST0 + + + de /mod=11 /x87=2a + ST2 ST0 + + + de /mod=11 /x87=2b + ST3 ST0 + + + de /mod=11 /x87=2c + ST4 ST0 + + + de /mod=11 /x87=2d + ST5 ST0 + + + de /mod=11 /x87=2e + ST6 ST0 + + + de /mod=11 /x87=2f + ST7 ST0 + + + + + fsubr + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=5 + Mq + + + d8 /mod=11 /x87=28 + ST0 ST0 + + + d8 /mod=11 /x87=29 + ST0 ST1 + + + d8 /mod=11 /x87=2a + ST0 ST2 + + + d8 /mod=11 /x87=2b + ST0 ST3 + + + d8 /mod=11 /x87=2c + ST0 ST4 + + + d8 /mod=11 /x87=2d + ST0 ST5 + + + d8 /mod=11 /x87=2e + ST0 ST6 + + + d8 /mod=11 /x87=2f + ST0 ST7 + + + dc /mod=11 /x87=20 + ST0 ST0 + + + dc /mod=11 /x87=21 + ST1 ST0 + + + dc /mod=11 /x87=22 + ST2 ST0 + + + dc /mod=11 /x87=23 + ST3 ST0 + + + dc /mod=11 /x87=24 + ST4 ST0 + + + dc /mod=11 /x87=25 + ST5 ST0 + + + dc /mod=11 /x87=26 + ST6 ST0 + + + dc /mod=11 /x87=27 + ST7 ST0 + + + aso rexr rexx rexb + d8 /mod=!11 /reg=5 + Md + + + + + fsubrp + X87 + + de /mod=11 /x87=20 + ST0 ST0 + + + de /mod=11 /x87=21 + ST1 ST0 + + + de /mod=11 /x87=22 + ST2 ST0 + + + de /mod=11 /x87=23 + ST3 ST0 + + + de /mod=11 /x87=24 + ST4 ST0 + + + de /mod=11 /x87=25 + ST5 ST0 + + + de /mod=11 /x87=26 + ST6 ST0 + + + de /mod=11 /x87=27 + ST7 ST0 + + + + + ftst + X87 + + d9 /mod=11 /x87=24 + + + + + fucom + X87 + + dd /mod=11 /x87=20 + ST0 + + + dd /mod=11 /x87=21 + ST1 + + + dd /mod=11 /x87=22 + ST2 + + + dd /mod=11 /x87=23 + ST3 + + + dd /mod=11 /x87=24 + ST4 + + + dd /mod=11 /x87=25 + ST5 + + + dd /mod=11 /x87=26 + ST6 + + + dd /mod=11 /x87=27 + ST7 + + + + + fucomp + X87 + + dd /mod=11 /x87=28 + ST0 + + + dd /mod=11 /x87=29 + ST1 + + + dd /mod=11 /x87=2a + ST2 + + + dd /mod=11 /x87=2b + ST3 + + + dd /mod=11 /x87=2c + ST4 + + + dd /mod=11 /x87=2d + ST5 + + + dd /mod=11 /x87=2e + ST6 + + + dd /mod=11 /x87=2f + ST7 + + + + + fucompp + X87 + + da /mod=11 /x87=29 + + + + + fxam + X87 + + d9 /mod=11 /x87=25 + + + + + fxch + X87 + + d9 /mod=11 /x87=08 + ST0 ST0 + + + d9 /mod=11 /x87=09 + ST0 ST1 + + + d9 /mod=11 /x87=0a + ST0 ST2 + + + d9 /mod=11 /x87=0b + ST0 ST3 + + + d9 /mod=11 /x87=0c + ST0 ST4 + + + d9 /mod=11 /x87=0d + ST0 ST5 + + + d9 /mod=11 /x87=0e + ST0 ST6 + + + d9 /mod=11 /x87=0f + ST0 ST7 + + + + + fxch4 + X87 + + dd /mod=11 /x87=08 + ST0 + + + dd /mod=11 /x87=09 + ST1 + + + dd /mod=11 /x87=0a + ST2 + + + dd /mod=11 /x87=0b + ST3 + + + dd /mod=11 /x87=0c + ST4 + + + dd /mod=11 /x87=0d + ST5 + + + dd /mod=11 /x87=0e + ST6 + + + dd /mod=11 /x87=0f + ST7 + + + + + fxch7 + X87 + + df /mod=11 /x87=08 + ST0 + + + df /mod=11 /x87=09 + ST1 + + + df /mod=11 /x87=0a + ST2 + + + df /mod=11 /x87=0b + ST3 + + + df /mod=11 /x87=0c + ST4 + + + df /mod=11 /x87=0d + ST5 + + + df /mod=11 /x87=0e + ST6 + + + df /mod=11 /x87=0f + ST7 + + + + + fxrstor + + aso rexw rexr rexx rexb + 0f ae /mod=!11 /reg=1 + M + + + + + fxsave + + aso rexw rexr rexx rexb + 0f ae /mod=!11 /reg=0 + M + + + + + fxtract + X87 + + d9 /mod=11 /x87=34 + + + + + fyl2x + X87 + + d9 /mod=11 /x87=31 + + + + + fyl2xp1 + X87 + + d9 /mod=11 /x87=39 + + + + + hlt + + f4 + + + + + idiv + + aso oso rexw rexr rexx rexb + f7 /reg=7 + Ev + + + aso rexw rexr rexx rexb + f6 /reg=7 + Eb + + + + + in + + e4 + AL Ib + + + oso + e5 + eAX Ib + + + ec + AL DX + + + oso + ed + eAX DX + + + + + imul + + aso oso rexw rexr rexx rexb + 0f af + Gv Ev + + + aso rexw rexr rexx rexb + f6 /reg=5 + Eb + + + aso oso rexw rexr rexx rexb + f7 /reg=5 + Ev + + + aso oso rexw rexr rexx rexb + 69 + Gv Ev Iz + + + aso oso rexw rexr rexx rexb + 6b + Gv Ev sIb + + + + + inc + + oso + 40 + R0z + + + oso + 41 + R1z + + + oso + 42 + R2z + + + oso + 43 + R3z + + + oso + 44 + R4z + + + oso + 45 + R5z + + + oso + 46 + R6z + + + oso + 47 + R7z + + + aso oso rexw rexr rexx rexb + ff /reg=0 + Ev + + + aso rexw rexr rexx rexb + fe /reg=0 + Eb + + + + + insb + + rep seg + 6c + + + + + insw + + rep oso seg + 6d /o=16 + + + + + insd + + rep oso seg + 6d /o=32 + + + + + int1 + + f1 + + + + + int3 + + cc + + + + + int + + cd + Ib + + + + + into + + ce /m=!64 + inv64 + + + + + invd + + 0f 08 + + + + + invept + intel + + /sse=66 0f 38 80 /m=32 + Gd Mo + + + /sse=66 0f 38 80 /m=64 + Gq Mo + + + + + invlpg + + aso rexr rexx rexb + 0f 01 /reg=7 /mod=!11 + M + + + + + invlpga + amd + + 0f 01 /reg=3 /mod=11 /rm=7 + + + + + invvpid + intel + + /sse=66 0f 38 81 /m=32 + Gd Mo + + + /sse=66 0f 38 81 /m=64 + Gq Mo + + + + + iretw + + oso rexw + cf /o=16 + + + + + iretd + + oso rexw + cf /o=32 + + + + + iretq + + oso rexw + cf /o=64 + + + + + jo + + 70 + Jb + + + oso + 0f 80 + Jz + def64 + + + + + jno + + 71 + Jb + + + oso + 0f 81 + Jz + def64 + + + + + jb + + 72 + Jb + + + oso + 0f 82 + Jz + def64 + + + + + jae + + 73 + Jb + + + oso + 0f 83 + Jz + def64 + + + + + jz + + 74 + Jb + + + oso + 0f 84 + Jz + def64 + + + + + jnz + + 75 + Jb + + + oso + 0f 85 + Jz + def64 + + + + + jbe + + 76 + Jb + + + oso + 0f 86 + Jz + def64 + + + + + ja + + 77 + Jb + + + oso + 0f 87 + Jz + def64 + + + + + js + + 78 + Jb + + + oso + 0f 88 + Jz + def64 + + + + + jns + + 79 + Jb + + + oso + 0f 89 + Jz + def64 + + + + + jp + + 7a + Jb + + + oso + 0f 8a + Jz + def64 + + + + + jnp + + 7b + Jb + + + oso + 0f 8b + Jz + def64 + + + + + jl + + 7c + Jb + + + oso + 0f 8c + Jz + def64 + + + + + jge + + 7d + Jb + + + oso + 0f 8d + Jz + def64 + + + + + jle + + 7e + Jb + + + oso + 0f 8e + Jz + def64 + + + + + jg + + 7f + Jb + + + oso + 0f 8f + Jz + def64 + + + + + jcxz + + aso + e3 /a=16 + Jb + + + + + jecxz + + aso + e3 /a=32 + Jb + + + + + jrcxz + + aso + e3 /a=64 + Jb + + + + + jmp + + aso oso rexw rexr rexx rexb + ff /reg=4 + Ev + def64 + + + aso oso rexw rexr rexx rexb + ff /reg=5 + Fv + + + oso + e9 + Jz + def64 + + + oso + ea /m=!64 + Av + + + eb + Jb + def64 + + + + + lahf + + 9f + + + + + lar + + aso oso rexw rexr rexx rexb + 0f 02 + Gv Ew + + + + + ldmxcsr + + aso rexw rexr rexx rexb + 0f ae /reg=2 /mod=!11 + Md + + + + + lds + + aso oso + c5 /vex=none /m=!64 + Gv M + + + + + lea + + aso oso rexw rexr rexx rexb + 8d + Gv M + + + + + les + + aso oso + c4 /m=!64 + Gv M + + + + + lfs + + aso oso rexw rexr rexx rexb + 0f b4 + Gz M + + + + + lgs + + aso oso rexw rexr rexx rexb + 0f b5 + Gz M + + + + + lidt + + aso rexr rexx rexb + 0f 01 /reg=3 /mod=!11 + M + + + + + lss + + aso oso rexw rexr rexx rexb + 0f b2 + Gv M + + + + + leave + + c9 + + + + + lfence + + 0f ae /reg=5 /mod=11 /rm=0 + + + 0f ae /reg=5 /mod=11 /rm=1 + + + 0f ae /reg=5 /mod=11 /rm=2 + + + 0f ae /reg=5 /mod=11 /rm=3 + + + 0f ae /reg=5 /mod=11 /rm=4 + + + 0f ae /reg=5 /mod=11 /rm=5 + + + 0f ae /reg=5 /mod=11 /rm=6 + + + 0f ae /reg=5 /mod=11 /rm=7 + + + + + lgdt + + aso rexr rexx rexb + 0f 01 /reg=2 /mod=!11 + M + + + + + lldt + + aso rexr rexx rexb + 0f 00 /reg=2 + Ew + + + + + lmsw + + aso rexr rexx rexb + 0f 01 /reg=6 /mod=!11 + Ew + + + aso rexr rexx rexb + 0f 01 /reg=6 /mod=11 + Ew + + + + + lock + + f0 + + + + + lodsb + + rep seg + ac + + + + + lodsw + + rep seg oso rexw + ad /o=16 + + + + + lodsd + + rep seg oso rexw + ad /o=32 + + + + + lodsq + + rep seg oso rexw + ad /o=64 + + + + + loopne + + e0 + Jb + + + + + loope + + e1 + Jb + + + + + loop + + e2 + Jb + + + + + lsl + + aso oso rexw rexr rexx rexb + 0f 03 + Gv Ew + + + + + ltr + + aso rexr rexx rexb + 0f 00 /reg=3 + Ew + + + + + maskmovq + + aso rexr rexx rexb + 0f f7 /mod=11 + P N + + + + + maxpd + + aso rexr rexx rexb vexl + /sse=66 0f 5f + V H W + sse2 avx + + + + + maxps + + aso rexr rexx rexb vexl + 0f 5f + V H W + sse avx + + + + + maxsd + + aso rexr rexx rexb + /sse=f2 0f 5f + V H W + sse2 avx + + + + + maxss + + aso rexr rexx rexb + /sse=f3 0f 5f + V H W + sse avx + + + + + mfence + + 0f ae /reg=6 /mod=11 /rm=0 + + + 0f ae /reg=6 /mod=11 /rm=1 + + + 0f ae /reg=6 /mod=11 /rm=2 + + + 0f ae /reg=6 /mod=11 /rm=3 + + + 0f ae /reg=6 /mod=11 /rm=4 + + + 0f ae /reg=6 /mod=11 /rm=5 + + + 0f ae /reg=6 /mod=11 /rm=6 + + + 0f ae /reg=6 /mod=11 /rm=7 + + + + + minpd + + aso rexr rexx rexb vexl + /sse=66 0f 5d + V H W + sse2 avx + + + + + minps + + aso rexr rexx rexb + 0f 5d + V H W + sse2 avx + + + + + minsd + + aso rexr rexx rexb + /sse=f2 0f 5d + V H MqU + sse2 avx + + + + + minss + + aso rexr rexx rexb + /sse=f3 0f 5d + V H MdU + sse avx + + + + + monitor + + 0f 01 /reg=1 /mod=11 /rm=0 + + + + + montmul + + 0f a6 /mod=11 /rm=0 /reg=0 + + + + + mov + + aso rexw rexr rexx rexb + c6 /reg=0 + Eb Ib + + + aso oso rexw rexr rexx rexb + c7 /reg=0 + Ev sIz + + + aso rexr rexx rexb + 88 + Eb Gb + + + aso oso rexw rexr rexx rexb + 89 + Ev Gv + + + aso rexr rexx rexb + 8a + Gb Eb + + + aso oso rexw rexr rexx rexb + 8b + Gv Ev + + + aso oso rexw rexr rexx rexb + 8c + MwRv S + + + aso oso rexw rexr rexx rexb + 8e + S MwRv + + + a0 + AL Ob + + + aso oso rexw + a1 + rAX Ov + + + a2 + Ob AL + + + aso oso rexw + a3 + Ov rAX + + + rexb + b0 + R0b Ib + + + rexb + b1 + R1b Ib + + + rexb + b2 + R2b Ib + + + rexb + b3 + R3b Ib + + + rexb + b4 + R4b Ib + + + rexb + b5 + R5b Ib + + + rexb + b6 + R6b Ib + + + rexb + b7 + R7b Ib + + + oso rexw rexb + b8 + R0v Iv + + + oso rexw rexb + b9 + R1v Iv + + + oso rexw rexb + ba + R2v Iv + + + oso rexw rexb + bb + R3v Iv + + + oso rexw rexb + bc + R4v Iv + + + oso rexw rexb + bd + R5v Iv + + + oso rexw rexb + be + R6v Iv + + + oso rexw rexb + bf + R7v Iv + + + rexr rexw rexb + 0f 20 + R C + + + rexr rexw rexb + 0f 21 + R D + + + rexr rexw rexb + 0f 22 + C R + + + rexr rexw rexb + 0f 23 + D R + + + + + movapd + + aso rexr rexx rexb vexl + /sse=66 0f 28 + V W + sse2 avx + + + aso rexr rexx rexb vexl + /sse=66 0f 29 + W V + sse2 avx + + + + + movaps + + aso rexr rexx rexb vexl + 0f 28 + V W + sse avx + + + aso rexr rexx rexb vexl + 0f 29 + W V + sse avx + + + + + movd + + aso rexw rexr rexx rexb + 0f 6e /o=16 + P Ey + mmx + + + aso rexw rexr rexx rexb + 0f 6e /o=32 + P Ey + mmx + + + + aso rexw rexr rexx rexb + /sse=66 0f 6e /o=16 + V Ey + sse2 avx + + + aso rexw rexr rexx rexb + /sse=66 0f 6e /o=32 + V Ey + sse2 avx + + + aso rexw rexr rexx rexb + 0f 7e /o=16 + Ey P + mmx + + + aso rexw rexr rexx rexb + 0f 7e /o=32 + Ey P + mmx + + + aso rexw rexr rexx rexb + /sse=66 0f 7e /o=16 + Ey V + sse2 avx + + + aso rexw rexr rexx rexb + /sse=66 0f 7e /o=32 + Ey V + sse2 avx + + + + + movhpd + + aso rexr rexx rexb + /sse=66 0f 16 /mod=!11 + V H M + sse2 avx + + + aso rexr rexx rexb + /sse=66 0f 17 + M V + sse2 avx + + + + + movhps + + aso rexr rexx rexb + 0f 16 /mod=!11 + V H M + sse avx + + + aso rexr rexx rexb + 0f 17 + M V + sse avx + + + + + movlhps + + aso rexr rexx rexb + 0f 16 /mod=11 + V H U + sse avx + + + + + movlpd + + aso rexr rexx rexb + /sse=66 0f 12 /mod=!11 + V M + + + aso rexr rexx rexb + /sse=66 0f 13 + M V + + sse2 avx + + + + movlps + + aso rexr rexx rexb + 0f 12 /mod=!11 + V M + + + aso rexr rexx rexb + 0f 13 + M V + + sse avx + + + + movhlps + + aso rexr rexx rexb + 0f 12 /mod=11 + V U + sse avx + + + + + movmskpd + + oso rexr rexb vexl + /sse=66 0f 50 + Gd U + sse2 avx + + + + + movmskps + + oso rexr rexb + 0f 50 + Gd U + sse2 avx + + + + + movntdq + + aso rexr rexx rexb vexl + /sse=66 0f e7 + M V + sse2 avx + + + + + movnti + + aso rexw rexr rexx rexb + 0f c3 + M Gy + + + + + movntpd + + aso rexr rexx rexb vexl + /sse=66 0f 2b + M V + sse2 avx + + + + + movntps + + aso rexr rexx rexb vexl + 0f 2b + M V + sse2 avx + + + + + movntq + + aso rexr rexx rexb + 0f e7 + M P + + + + + movq + + aso rexw rexr rexx rexb + 0f 6e /o=64 + P Eq + mmx + + + aso rexw rexr rexx rexb + /sse=66 0f 6e /o=64 + V Eq + sse2 avx + + + aso rexw rexr rexx rexb + 0f 7e /o=64 + Eq P + mmx + + + aso rexw rexr rexx rexb + /sse=66 0f 7e /o=64 + Eq V + sse2 avx + + + aso rexw rexr rexx rexb + /sse=f3 0f 7e + V W + sse2 avx + + + aso rexw rexr rexx rexb + /sse=66 0f d6 + W V + sse2 avx + + + aso rexw rexr rexx rexb + 0f 6f + P Q + mmx + + + aso rexw rexr rexx rexb + 0f 7f + Q P + mmx + + + + + movsb + + rep seg + a4 + + + + + movsw + + rep seg oso rexw + a5 /o=16 + + + + + movsd + + rep seg oso rexw + a5 /o=32 + + + aso rexr rexx rexb + /sse=f2 0f 10 + V MqU + sse2 + + + aso rexr rexx rexb + /sse=f2 0f 11 + W V + sse2 + + + + + movsq + + rep seg oso rexw + a5 /o=64 + + + + + movss + + aso rexr rexx rexb + /sse=f3 0f 10 + V MdU + sse + + + aso rexr rexx rexb + /sse=f3 0f 11 + W V + sse + + + + + movsx + + aso oso rexw rexr rexx rexb + 0f be + Gv Eb + + + aso oso rexw rexr rexx rexb + 0f bf + Gy Ew + + + + + movupd + + aso rexr rexx rexb vexl + /sse=66 0f 10 + V W + sse2 avx + + + aso rexr rexx rexb vexl + /sse=66 0f 11 + W V + sse2 avx + + + + + movups + + aso rexr rexx rexb vexl + 0f 10 + V W + sse2 avx + + + aso rexr rexx rexb vexl + 0f 11 + W V + sse2 avx + + + + + movzx + + aso oso rexw rexr rexx rexb + 0f b6 + Gv Eb + + + aso oso rexw rexr rexx rexb + 0f b7 + Gy Ew + + + + + mul + + aso rexw rexr rexx rexb + f6 /reg=4 + Eb + + + aso oso rexw rexr rexx rexb + f7 /reg=4 + Ev + + + + + mulpd + + aso rexr rexx rexb vexl + /sse=66 0f 59 + V H W + sse2 avx + + + + + mulps + + aso rexr rexx rexb vexl + 0f 59 + V H W + sse2 avx + + + + + mulsd + + aso rexr rexx rexb + /sse=f2 0f 59 + V H W + sse2 avx + + + + + mulss + + aso rexr rexx rexb + /sse=f3 0f 59 + V H W + sse avx + + + + + mwait + + 0f 01 /reg=1 /mod=11 /rm=1 + + + + + neg + + aso rexw rexr rexx rexb + f6 /reg=3 + Eb + + + aso oso rexw rexr rexx rexb + f7 /reg=3 + Ev + + + + + nop + + aso rexr rexx rexb + 0f 19 + M + + + aso rexr rexx rexb + 0f 1a + M + + + aso rexr rexx rexb + 0f 1b + M + + + aso rexr rexx rexb + 0f 1c + M + + + aso rexr rexx rexb + 0f 1d + M + + + aso rexr rexx rexb + 0f 1e + M + + + aso rexr rexx rexb + 0f 1f + M + + + + + not + + aso rexw rexr rexx rexb + f6 /reg=2 + Eb + + + aso oso rexw rexr rexx rexb + f7 /reg=2 + Ev + + + + + or + + aso rexr rexx rexb + 08 + Eb Gb + + + aso oso rexw rexr rexx rexb + 09 + Ev Gv + + + aso rexr rexx rexb + 0a + Gb Eb + + + aso oso rexw rexr rexx rexb + 0b + Gv Ev + + + 0c + AL Ib + + + oso rexw + 0d + rAX sIz + + + aso rexr rexx rexb + 80 /reg=1 + Eb Ib + + + aso oso rexw rexr rexx rexb + 81 /reg=1 + Ev sIz + + + aso rexr rexx rexb + 82 /reg=1 /m=!64 + Eb Ib + + + aso oso rexw rexr rexx rexb + 83 /reg=1 + Ev sIb + + + + + orpd + + aso rexr rexx rexb vexl + /sse=66 0f 56 + V H W + sse2 avx + + + + + orps + + aso rexr rexx rexb vexl + 0f 56 + V H W + sse avx + + + + + out + + e6 + Ib AL + + + oso + e7 + Ib eAX + + + ee + DX AL + + + oso + ef + DX eAX + + + + + outsb + + rep seg + 6e + + + + + outsw + + rep oso seg + 6f /o=16 + + + + + outsd + + rep oso seg + 6f /o=32 + + + + + packsswb + + aso rexr rexx rexb vexl + /sse=66 0f 63 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 63 + P Q + mmx + + + + + packssdw + + aso rexr rexx rexb vexl + /sse=66 0f 6b + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 6b + P Q + mmx + + + + + packuswb + + aso rexr rexx rexb vexl + /sse=66 0f 67 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 67 + P Q + mmx + + + + + paddb + + aso rexr rexx rexb vexl + /sse=66 0f fc + V H W + sse2 avx + + + aso rexr rexx rexb + 0f fc + P Q + mmx + + + + + paddw + + aso rexr rexx rexb + 0f fd + P Q + mmx + + + aso rexr rexx rexb vexl + /sse=66 0f fd + V H W + sse2 avx + + + + + paddd + + aso rexr rexx rexb + 0f fe + P Q + mmx + + + aso rexr rexx rexb vexl + /sse=66 0f fe + V H W + sse2 avx + + + + + + paddsb + + aso rexr rexx rexb + 0f ec + P Q + + + aso rexr rexx rexb + /sse=66 0f ec + V H W + sse2 avx + + + + + paddsw + + aso rexr rexx rexb + 0f ed + P Q + + + aso rexr rexx rexb + /sse=66 0f ed + V H W + sse2 avx + + + + + paddusb + + aso rexr rexx rexb + 0f dc + P Q + + + aso rexr rexx rexb + /sse=66 0f dc + V H W + sse2 avx + + + + + paddusw + + aso rexr rexx rexb + 0f dd + P Q + + + aso rexr rexx rexb + /sse=66 0f dd + V H W + sse2 avx + + + + + pand + + aso rexr rexx rexb + /sse=66 0f db + V H W + sse2 avx + + + aso rexr rexx rexb + 0f db + P Q + + + + + pandn + + aso rexr rexx rexb + /sse=66 0f df + V H W + sse2 avx + + + aso rexr rexx rexb + 0f df + P Q + + + + + pavgb + + aso rexr rexx rexb + /sse=66 0f e0 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f e0 + P Q + + + + + pavgw + + aso rexr rexx rexb + /sse=66 0f e3 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f e3 + P Q + + + + + pcmpeqb + + aso rexr rexx rexb + 0f 74 + P Q + + + aso rexr rexx rexb + /sse=66 0f 74 + V H W + sse2 avx + + + + + pcmpeqw + + aso rexr rexx rexb + 0f 75 + P Q + + + aso rexr rexx rexb + /sse=66 0f 75 + V H W + sse2 avx + + + + + pcmpeqd + + aso rexr rexx rexb + 0f 76 + P Q + + + aso rexr rexx rexb + /sse=66 0f 76 + V H W + sse2 avx + + + + + pcmpgtb + + aso rexr rexx rexb + /sse=66 0f 64 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 64 + P Q + + + + + pcmpgtw + + aso rexr rexx rexb + /sse=66 0f 65 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 65 + P Q + + + + + pcmpgtd + + aso rexr rexx rexb + /sse=66 0f 66 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 66 + P Q + + + + + pextrb + + aso rexx rexr rexb + /sse=66 0f 3a 14 /vexw=0 + MbRv V Ib + def64 + sse4.1 avx + + + + + pextrd + + aso rexr rexx rexw rexb + /sse=66 0f 3a 16 /o=16 /vexw=0 + Ed V Ib + sse4.1 avx + + + aso rexr rexx rexw rexb + /sse=66 0f 3a 16 /o=32 /vexw=0 + Ed V Ib + sse4.1 avx + + + + + pextrq + + aso rexr rexw rexb + /sse=66 0f 3a 16 /o=64 /vexw=1 + Eq V Ib + def64 + sse4.1 avx + + + + + pextrw + + aso rexw rexr rexb + /sse=66 0f c5 + Gd U Ib + sse avx + + + aso rexw rexr rexx rexb + 0f c5 + Gd N Ib + + + aso rexw rexx rexr rexb + /sse=66 0f 3a 15 + MwRd V Ib + sse4.1 avx + + + + + pinsrb + + aso rexw rexr rexx rexb + /sse=66 0f 3a 20 + V MbRd Ib + sse4.1 + + + + + pinsrw + + aso rexw rexr rexx rexb + 0f c4 + P MwRy Ib + def64 + + + aso rexw rexr rexx rexb + /sse=66 0f c4 + V MwRy Ib + def64 + sse2 avx + + + + + pinsrd + + aso rexw rexr rexx rexb + /sse=66 0f 3a 22 /o=16 + V Ed Ib + sse4.1 + + + + aso rexw rexr rexx rexb + /sse=66 0f 3a 22 /o=32 + V Ed Ib + sse4.1 + + + + + pinsrq + + aso oso rexw rexr rexx rexb + /sse=66 0f 3a 22 /o=64 + V Eq Ib + sse4.1 + + + + + vpinsrb + + aso rexw rexr rexx rexb + /vex=66_0f3a 20 /vexw=0 /vexl=0 + V H MbRd Ib + avx + + + + + vpinsrd + + aso oso rexw rexr rexx rexb + /vex=66_0f3a 22 /m=!64 /vexw=0 /vexl=0 + V H Ed Ib + avx + + + aso oso rexw rexr rexx rexb + /vex=66_0f3a 22 /m=64 /vexw=0 /vexl=0 + V H Ed Ib + avx + + + + + + vpinsrq + + aso oso rexw rexr rexx rexb + /vex=66_0f3a 22 /m=64 /vexw=1 /vexl=0 + V H Eq Ib + avx + + + + + + pmaddwd + + aso rexr rexx rexb + 0f f5 + P Q + + + aso rexr rexx rexb + /sse=66 0f f5 + V H W + sse4.1 avx + + + + + pmaxsw + + aso rexr rexx rexb + /sse=66 0f ee + V H W + sse4.1 avx + + + aso rexr rexx rexb + 0f ee + P Q + + + + + pmaxub + + aso rexr rexx rexb + 0f de + P Q + + + aso rexr rexx rexb + /sse=66 0f de + V H W + sse2 avx + + + + + pminsw + + aso rexr rexx rexb + /sse=66 0f ea + V H W + sse2 avx + + + aso rexr rexx rexb + 0f ea + P Q + + + + + pminub + + aso rexr rexx rexb + /sse=66 0f da + V H W + sse2 avx + + + aso rexr rexx rexb + 0f da + P Q + + + + + pmovmskb + + oso rexr rexw rexb + /sse=66 0f d7 /vexl=0 + Gd U + sse2 avx + + + oso rexr rexw rexb + 0f d7 + Gd N + + + + + pmulhuw + + aso rexr rexx rexb + 0f e4 + P Q + + + aso rexr rexx rexb + /sse=66 0f e4 + V H W + sse2 avx + + + + + pmulhw + + aso rexr rexx rexb + /sse=66 0f e5 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f e5 + P Q + + + + + pmullw + + aso rexr rexx rexb + 0f d5 + P Q + + + aso rexr rexx rexb + /sse=66 0f d5 + V H W + sse2 avx + + + + + pop + + 07 /m=!64 + ES + inv64 + + + 17 /m=!64 + SS + inv64 + + + 1f /m=!64 + DS + inv64 + + + 0f a9 + GS + + + 0f a1 + FS + + + oso rexb + 58 + R0v + def64 + + + oso rexb + 59 + R1v + def64 + + + oso rexb + 5a + R2v + def64 + + + oso rexb + 5b + R3v + def64 + + + oso rexb + 5c + R4v + def64 + + + oso rexb + 5d + R5v + def64 + + + oso rexb + 5e + R6v + def64 + + + oso rexb + 5f + R7v + def64 + + + aso oso rexw rexr rexx rexb + 8f /reg=0 + Ev + def64 + + + + + popa + + oso + 61 /o=16 /m=!64 + inv64 + + + + + popad + + oso + 61 /o=32 /m=!64 + inv64 + + + + + popfw + + oso + 9d /m=!64 /o=16 + + + + + popfd + + oso + 9d /m=!64 /o=32 + + + + + popfq + + oso + 9d /m=64 /o=32 + def64 + + + oso + 9d /m=64 /o=64 + def64 + + + + + por + + aso rexr rexx rexb + /sse=66 0f eb + V H W + sse2 avx + + + aso rexr rexx rexb + 0f eb + P Q + + + + + prefetch + + aso rexw rexr rexx rexb + 0f 0d /reg=0 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=1 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=2 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=3 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=4 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=5 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=6 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=7 + M + + + + + prefetchnta + + aso rexw rexr rexx rexb + 0f 18 /reg=0 + M + + + + + prefetcht0 + + aso rexw rexr rexx rexb + 0f 18 /reg=1 + M + + + + + prefetcht1 + + aso rexw rexr rexx rexb + 0f 18 /reg=2 + M + + + + + prefetcht2 + + aso rexw rexr rexx rexb + 0f 18 /reg=3 + M + + + + + psadbw + + aso rexr rexx rexb + /sse=66 0f f6 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f f6 + P Q + + + + + pshufw + + aso rexr rexx rexb + 0f 70 + P Q Ib + + + + + psllw + + aso rexr rexx rexb + /sse=66 0f f1 + V W + sse2 + + + aso rexr rexx rexb + 0f f1 + P Q + + + rexb + /sse=66 0f 71 /reg=6 + U Ib + sse2 + + + 0f 71 /reg=6 + N Ib + + + + + pslld + + aso rexr rexx rexb + /sse=66 0f f2 + V W + sse2 + + + aso rexr rexx rexb + 0f f2 + P Q + + + rexb + /sse=66 0f 72 /reg=6 + U Ib + sse2 + + + 0f 72 /reg=6 + N Ib + + + + + psllq + + aso rexr rexx rexb + /sse=66 0f f3 + V W + sse2 + + + aso rexr rexx rexb + 0f f3 + P Q + + + rexb + /sse=66 0f 73 /reg=6 + U Ib + sse2 + + + 0f 73 /reg=6 + N Ib + + + + + psraw + + aso rexr rexx rexb + 0f e1 + P Q + + + aso rexr rexx rexb + /sse=66 0f e1 + V H W + sse2 avx + + + rexb + /sse=66 0f 71 /reg=4 + H U Ib + sse2 avx + + + 0f 71 /reg=4 + N Ib + + + + + psrad + + 0f 72 /reg=4 + N Ib + + + aso rexr rexx rexb + /sse=66 0f e2 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f e2 + P Q + + + rexb + /sse=66 0f 72 /reg=4 + H U Ib + sse2 avx + + + + + psrlw + + 0f 71 /reg=2 + N Ib + + + aso rexr rexx rexb + 0f d1 + P Q + + + aso rexr rexx rexb + /sse=66 0f d1 + V H W + sse2 avx + + + rexb + /sse=66 0f 71 /reg=2 + H U Ib + sse2 avx + + + + + psrld + + 0f 72 /reg=2 + N Ib + + + aso rexr rexx rexb + 0f d2 + P Q + + + aso rexr rexx rexb + /sse=66 0f d2 + V H W + sse2 avx + + + rexb + /sse=66 0f 72 /reg=2 + H U Ib + sse2 avx + + + + + psrlq + + 0f 73 /reg=2 + N Ib + + + aso rexr rexx rexb + 0f d3 + P Q + + + aso rexr rexx rexb + /sse=66 0f d3 + V H W + sse2 avx + + + rexb + /sse=66 0f 73 /reg=2 + H U Ib + sse2 avx + + + + + psubb + + aso rexr rexx rexb + /sse=66 0f f8 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f f8 + P Q + + + + + psubw + + aso rexr rexx rexb + /sse=66 0f f9 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f f9 + P Q + + + + + psubd + + aso rexr rexx rexb + 0f fa + P Q + + + aso rexr rexx rexb + /sse=66 0f fa + V H W + sse2 avx + + + + + psubsb + + aso rexr rexx rexb + 0f e8 + P Q + + + aso rexr rexx rexb + /sse=66 0f e8 + V H W + sse2 avx + + + + + psubsw + + aso rexr rexx rexb + 0f e9 + P Q + + + aso rexr rexx rexb + /sse=66 0f e9 + V H W + sse2 avx + + + + + psubusb + + aso rexr rexx rexb + 0f d8 + P Q + + + aso rexr rexx rexb + /sse=66 0f d8 + V H W + sse2 avx + + + + + psubusw + + aso rexr rexx rexb + 0f d9 + P Q + + + aso rexr rexx rexb + /sse=66 0f d9 + V H W + sse2 avx + + + + + punpckhbw + + aso rexr rexx rexb + /sse=66 0f 68 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 68 + P Q + + + + + punpckhwd + + aso rexr rexx rexb + /sse=66 0f 69 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 69 + P Q + + + + + punpckhdq + + aso rexr rexx rexb + /sse=66 0f 6a + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 6a + P Q + + + + + punpcklbw + + aso rexr rexx rexb + /sse=66 0f 60 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 60 + P Q + + + + + punpcklwd + + aso rexr rexx rexb + /sse=66 0f 61 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 61 + P Q + + + + + punpckldq + + aso rexr rexx rexb + /sse=66 0f 62 + V H W + sse2 avx + + + aso rexr rexx rexb + 0f 62 + P Q + + + + + pi2fw + + aso rexr rexx rexb + 0f 0f /3dnow=0c + P Q + + + + + pi2fd + + aso rexr rexx rexb + 0f 0f /3dnow=0d + P Q + + + + + pf2iw + + aso rexr rexx rexb + 0f 0f /3dnow=1c + P Q + + + + + pf2id + + aso rexr rexx rexb + 0f 0f /3dnow=1d + P Q + + + + + pfnacc + + aso rexr rexx rexb + 0f 0f /3dnow=8a + P Q + + + + + pfpnacc + + aso rexr rexx rexb + 0f 0f /3dnow=8e + P Q + + + + + pfcmpge + + aso rexr rexx rexb + 0f 0f /3dnow=90 + P Q + + + + + pfmin + + aso rexr rexx rexb + 0f 0f /3dnow=94 + P Q + + + + + pfrcp + + aso rexr rexx rexb + 0f 0f /3dnow=96 + P Q + + + + + pfrsqrt + + aso rexr rexx rexb + 0f 0f /3dnow=97 + P Q + + + + + pfsub + + aso rexr rexx rexb + 0f 0f /3dnow=9a + P Q + + + + + pfadd + + aso rexr rexx rexb + 0f 0f /3dnow=9e + P Q + + + + + pfcmpgt + + aso rexr rexx rexb + 0f 0f /3dnow=a0 + P Q + + + + + pfmax + + aso rexr rexx rexb + 0f 0f /3dnow=a4 + P Q + + + + + pfrcpit1 + + aso rexr rexx rexb + 0f 0f /3dnow=a6 + P Q + + + + + pfrsqit1 + + aso rexr rexx rexb + 0f 0f /3dnow=a7 + P Q + + + + + pfsubr + + aso rexr rexx rexb + 0f 0f /3dnow=aa + P Q + + + + + pfacc + + aso rexr rexx rexb + 0f 0f /3dnow=ae + P Q + + + + + pfcmpeq + + aso rexr rexx rexb + 0f 0f /3dnow=b0 + P Q + + + + + pfmul + + aso rexr rexx rexb + 0f 0f /3dnow=b4 + P Q + + + + + pfrcpit2 + + aso rexr rexx rexb + 0f 0f /3dnow=b6 + P Q + + + + + pmulhrw + + aso rexr rexx rexb + 0f 0f /3dnow=b7 + P Q + + + + + pswapd + + aso rexr rexx rexb + 0f 0f /3dnow=bb + P Q + + + + + pavgusb + + aso rexr rexx rexb + 0f 0f /3dnow=bf + P Q + + + + + push + + 06 /m=!64 + ES + inv64 + + + 0e /m=!64 + CS + inv64 + + + 16 /m=!64 + SS + inv64 + + + 1e /m=!64 + DS + inv64 + + + 0f a8 + GS + + + 0f a0 + FS + + + oso rexb + 50 + R0v + def64 + + + oso rexb + 51 + R1v + def64 + + + oso rexb + 52 + R2v + def64 + + + oso rexb + 53 + R3v + def64 + + + oso rexb + 54 + R4v + def64 + + + oso rexb + 55 + R5v + def64 + + + oso rexb + 56 + R6v + def64 + + + oso rexb + 57 + R7v + def64 + + + oso + 68 + sIz + def64 + + + aso oso rexw rexr rexx rexb + ff /reg=6 + Ev + def64 + + + oso + 6a + sIb + def64 + + + + + pusha + + oso + 60 /o=16 /m=!64 + inv64 + + + + + pushad + + oso + 60 /o=32 /m=!64 + inv64 + + + + + pushfw + + oso + 9c /m=!64 /o=16 + + + oso rexw + 9c /m=64 /o=16 + def64 + + + + + pushfd + + oso + 9c /m=!64 /o=32 + + + + + pushfq + + oso rexw + 9c /m=64 /o=32 + def64 + + + oso rexw + 9c /m=64 /o=64 + def64 + + + + + pxor + + aso rexr rexx rexb + /sse=66 0f ef + V H W + sse2 avx + + + aso rexr rexx rexb + 0f ef + P Q + + + + + rcl + + aso rexw rexr rexx rexb + c0 /reg=2 + Eb Ib + + + aso oso rexw rexr rexx rexb + c1 /reg=2 + Ev Ib + + + aso rexw rexr rexx rexb + d0 /reg=2 + Eb I1 + + + aso rexw rexr rexx rexb + d2 /reg=2 + Eb CL + + + aso oso rexw rexr rexx rexb + d3 /reg=2 + Ev CL + + + aso oso rexw rexr rexx rexb + d1 /reg=2 + Ev I1 + + + + + rcr + + aso rexw rexr rexx rexb + d0 /reg=3 + Eb I1 + + + aso oso rexw rexr rexx rexb + c1 /reg=3 + Ev Ib + + + aso rexw rexr rexx rexb + c0 /reg=3 + Eb Ib + + + aso oso rexw rexr rexx rexb + d1 /reg=3 + Ev I1 + + + aso rexw rexr rexx rexb + d2 /reg=3 + Eb CL + + + aso oso rexw rexr rexx rexb + d3 /reg=3 + Ev CL + + + + + rol + + aso rexw rexr rexx rexb + c0 /reg=0 + Eb Ib + + + aso rexw rexr rexx rexb + d0 /reg=0 + Eb I1 + + + aso oso rexw rexr rexx rexb + d1 /reg=0 + Ev I1 + + + aso rexw rexr rexx rexb + d2 /reg=0 + Eb CL + + + aso oso rexw rexr rexx rexb + d3 /reg=0 + Ev CL + + + aso oso rexw rexr rexx rexb + c1 /reg=0 + Ev Ib + + + + + ror + + aso rexw rexr rexx rexb + d0 /reg=1 + Eb I1 + + + aso rexw rexr rexx rexb + c0 /reg=1 + Eb Ib + + + aso oso rexw rexr rexx rexb + c1 /reg=1 + Ev Ib + + + aso oso rexw rexr rexx rexb + d1 /reg=1 + Ev I1 + + + aso rexw rexr rexx rexb + d2 /reg=1 + Eb CL + + + aso oso rexw rexr rexx rexb + d3 /reg=1 + Ev CL + + + + + rcpps + + aso rexr rexx rexb vexl + 0f 53 + V W + sse avx + + + + + rcpss + + aso rexr rexx rexb + /sse=f3 0f 53 + V W + sse avx + + + + + rdmsr + + 0f 32 + + + + + rdpmc + + 0f 33 + + + + + rdtsc + + 0f 31 + + + + + rdtscp + amd + + 0f 01 /reg=7 /mod=11 /rm=1 + + + + + repne + + f2 + + + + + rep + + f3 + + + + + ret + + c2 + Iw + + + c3 + + + + + retf + + ca + Iw + + + cb + + + + + rsm + + 0f aa + + + + + rsqrtps + + aso rexr rexx rexb vexl + 0f 52 + V W + sse avx + + + + + rsqrtss + + aso rexr rexx rexb + /sse=f3 0f 52 + V W + sse avx + + + + + sahf + + 9e + + + + + sal + + + + salc + + d6 /m=!64 + inv64 + + + + + sar + + aso oso rexw rexr rexx rexb + d1 /reg=7 + Ev I1 + + + aso rexw rexr rexx rexb + c0 /reg=7 + Eb Ib + + + aso rexw rexr rexx rexb + d0 /reg=7 + Eb I1 + + + aso oso rexw rexr rexx rexb + c1 /reg=7 + Ev Ib + + + aso rexw rexr rexx rexb + d2 /reg=7 + Eb CL + + + aso oso rexw rexr rexx rexb + d3 /reg=7 + Ev CL + + + + + shl + + aso rexw rexr rexx rexb + c0 /reg=6 + Eb Ib + + + aso oso rexw rexr rexx rexb + c1 /reg=6 + Ev Ib + + + aso rexw rexr rexx rexb + d0 /reg=6 + Eb I1 + + + aso rexw rexr rexx rexb + d2 /reg=6 + Eb CL + + + aso oso rexw rexr rexx rexb + d3 /reg=6 + Ev CL + + + aso oso rexw rexr rexx rexb + c1 /reg=4 + Ev Ib + + + aso rexr rexx rexb + d2 /reg=4 + Eb CL + + + aso oso rexw rexr rexx rexb + d1 /reg=4 + Ev I1 + + + aso rexw rexr rexx rexb + d0 /reg=4 + Eb I1 + + + aso rexw rexr rexx rexb + c0 /reg=4 + Eb Ib + + + aso oso rexw rexr rexx rexb + d3 /reg=4 + Ev CL + + + aso oso rexw rexr rexx rexb + d1 /reg=6 + Ev I1 + + + + + shr + + aso oso rexw rexr rexx rexb + c1 /reg=5 + Ev Ib + + + aso rexw rexr rexx rexb + d2 /reg=5 + Eb CL + + + aso oso rexw rexr rexx rexb + d1 /reg=5 + Ev I1 + + + aso rexw rexr rexx rexb + d0 /reg=5 + Eb I1 + + + aso rexw rexr rexx rexb + c0 /reg=5 + Eb Ib + + + aso oso rexw rexr rexx rexb + d3 /reg=5 + Ev CL + + + + + sbb + + aso rexr rexx rexb + 18 + Eb Gb + + + aso oso rexw rexr rexx rexb + 19 + Ev Gv + + + aso rexr rexx rexb + 1a + Gb Eb + + + aso oso rexw rexr rexx rexb + 1b + Gv Ev + + + 1c + AL Ib + + + oso rexw + 1d + rAX sIz + + + aso rexr rexx rexb + 80 /reg=3 + Eb Ib + + + aso oso rexw rexr rexx rexb + 81 /reg=3 + Ev sIz + + + aso rexr rexx rexb + 82 /reg=3 /m=!64 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 83 /reg=3 + Ev sIb + + + + + scasb + + repz + ae + + + + + scasw + + repz oso rexw + af /o=16 + + + + + scasd + + repz oso rexw + af /o=32 + + + + + scasq + + repz oso rexw + af /o=64 + + + + + seto + + aso rexr rexx rexb + 0f 90 + Eb + + + + + setno + + aso rexr rexx rexb + 0f 91 + Eb + + + + + setb + + aso rexr rexx rexb + 0f 92 + Eb + + + + + setae + + aso rexr rexx rexb + 0f 93 + Eb + + + + + setz + + aso rexr rexx rexb + 0f 94 + Eb + + + + + setnz + + aso rexr rexx rexb + 0f 95 + Eb + + + + + setbe + + aso rexr rexx rexb + 0f 96 + Eb + + + + + seta + + aso rexr rexx rexb + 0f 97 + Eb + + + + + sets + + aso rexr rexx rexb + 0f 98 + Eb + + + + + setns + + aso rexr rexx rexb + 0f 99 + Eb + + + + + setp + + aso rexr rexx rexb + 0f 9a + Eb + + + + + setnp + + aso rexr rexx rexb + 0f 9b + Eb + + + + + setl + + aso rexr rexx rexb + 0f 9c + Eb + + + + + setge + + aso rexr rexx rexb + 0f 9d + Eb + + + + + setle + + aso rexr rexx rexb + 0f 9e + Eb + + + + + setg + + aso rexr rexx rexb + 0f 9f + Eb + + + + + sfence + + 0f ae /reg=7 /mod=11 /rm=0 + + + 0f ae /reg=7 /mod=11 /rm=1 + + + 0f ae /reg=7 /mod=11 /rm=2 + + + 0f ae /reg=7 /mod=11 /rm=3 + + + 0f ae /reg=7 /mod=11 /rm=4 + + + 0f ae /reg=7 /mod=11 /rm=5 + + + 0f ae /reg=7 /mod=11 /rm=6 + + + 0f ae /reg=7 /mod=11 /rm=7 + + + + + sgdt + + aso rexr rexx rexb + 0f 01 /reg=0 /mod=!11 + M + + + + + shld + + aso oso rexw rexr rexx rexb + 0f a4 + Ev Gv Ib + + + aso oso rexw rexr rexx rexb + 0f a5 + Ev Gv CL + + + + + shrd + + aso oso rexw rexr rexx rexb + 0f ac + Ev Gv Ib + + + aso oso rexw rexr rexx rexb + 0f ad + Ev Gv CL + + + + + shufpd + + aso rexr rexx rexb vexl + /sse=66 0f c6 + V H W Ib + sse2 avx + + + + + shufps + + aso rexr rexx rexb + 0f c6 + V H W Ib + sse2 avx + + + + + sidt + + aso rexr rexx rexb + 0f 01 /reg=1 /mod=!11 + M + + + + + sldt + + aso oso rexr rexw rexx rexb + 0f 00 /reg=0 + MwRv + + + + + smsw + + aso oso rexr rexw rexx rexb + 0f 01 /reg=4 /mod=!11 + MwRv + + + aso oso rexr rexw rexx rexb + 0f 01 /reg=4 /mod=11 + MwRv + + + + + sqrtps + + aso rexr rexx rexb vexl + 0f 51 + V W + sse avx + + + + + sqrtpd + + aso rexr rexx rexb + /sse=66 0f 51 + V W + sse2 avx + + + + + sqrtsd + + aso rexr rexx rexb + /sse=f2 0f 51 + V H W + sse2 avx + + + + + sqrtss + + aso rexr rexx rexb + /sse=f3 0f 51 + V H W + sse avx + + + + + stc + + f9 + + + + + std + + fd + + + + + stgi + amd + + 0f 01 /reg=3 /mod=11 /rm=4 + + + + + sti + + fb + + + + + skinit + amd + + 0f 01 /reg=3 /mod=11 /rm=6 + + + + + stmxcsr + + aso rexw rexr rexx rexb + 0f ae /mod=!11 /reg=3 + Md + sse avx + + + + + stosb + + rep seg + aa + + + + + stosw + + rep seg oso rexw + ab /o=16 + + + + + stosd + + rep seg oso rexw + ab /o=32 + + + + + stosq + + rep seg oso rexw + ab /o=64 + + + + + str + + aso oso rexr rexw rexx rexb + 0f 00 /reg=1 + MwRv + + + + + sub + + aso rexr rexx rexb + 28 + Eb Gb + + + aso oso rexw rexr rexx rexb + 29 + Ev Gv + + + aso rexr rexx rexb + 2a + Gb Eb + + + aso oso rexw rexr rexx rexb + 2b + Gv Ev + + + 2c + AL Ib + + + oso rexw + 2d + rAX sIz + + + aso rexr rexx rexb + 80 /reg=5 + Eb Ib + + + aso oso rexw rexr rexx rexb + 81 /reg=5 + Ev sIz + + + aso rexr rexx rexb + 82 /reg=5 /m=!64 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 83 /reg=5 + Ev sIb + + + + + subpd + + aso rexr rexx rexb vexl + /sse=66 0f 5c + V H W + sse2 avx + + + + + subps + + aso rexr rexx rexb vexl + 0f 5c + V H W + sse avx + + + + + subsd + + aso rexr rexx rexb + /sse=f2 0f 5c + V H W + sse2 avx + + + + + subss + + aso rexr rexx rexb + /sse=f3 0f 5c + V H W + sse avx + + + + + swapgs + + 0f 01 /reg=7 /mod=11 /rm=0 + + + + + syscall + + 0f 05 + + + + + sysenter + + 0f 34 /m=!64 + + + 0f 34 /m=64 + intel + + + + + sysexit + + 0f 35 /m=!64 + + + 0f 35 /m=64 + intel + + + + + sysret + + 0f 07 + + + + + test + + aso rexw rexr rexx rexb + f6 /reg=0 + Eb Ib + + + aso rexr rexx rexb + 84 + Eb Gb + + + aso oso rexw rexr rexx rexb + 85 + Ev Gv + + + a8 + AL Ib + + + oso rexw + a9 + rAX sIz + + + aso rexw rexr rexx rexb + f6 /reg=1 + Eb Ib + + + aso oso rexw rexr rexx rexb + f7 /reg=0 + Ev sIz + + + aso oso rexw rexr rexx rexb + f7 /reg=1 + Ev Iz + + + + + ucomisd + + aso rexr rexx rexb + /sse=66 0f 2e + V W + sse2 avx + + + + + ucomiss + + aso rexr rexx rexb + 0f 2e + V W + sse avx + + + + + ud2 + + 0f 0b + + + + + unpckhpd + + aso rexr rexx rexb vexl + /sse=66 0f 15 + V H W + sse2 avx + + + + + unpckhps + + aso rexr rexx rexb + 0f 15 + V H W + sse avx + + + + + unpcklps + + aso rexr rexx rexb + 0f 14 + V H W + sse avx + + + + + unpcklpd + + aso rexr rexx rexb vexl + /sse=66 0f 14 + V H W + sse2 avx + + + + + verr + + aso rexr rexx rexb + 0f 00 /reg=4 + Ew + + + + + verw + + aso rexr rexx rexb + 0f 00 /reg=5 + Ew + + + + + vmcall + intel + + 0f 01 /reg=0 /mod=11 /rm=1 + + + + + rdrand + + oso rexr rexw rexx rexb + 0f c7 /mod=11 /reg=6 + R + + rdrand + + + + vmclear + intel + + aso rexr rexx rexb + /sse=66 0f c7 /mod=!11 /reg=6 + Mq + + + + + vmxon + intel + + aso rexr rexx rexb + /sse=f3 0f c7 /mod=!11 /reg=6 + Mq + + + + + vmptrld + intel + + aso rexr rexx rexb + 0f c7 /mod=!11 /reg=6 + Mq + + + + + vmptrst + intel + + aso rexr rexx rexb + 0f c7 /mod=!11 /reg=7 + Mq + + + + + vmlaunch + intel + + 0f 01 /reg=0 /mod=11 /rm=2 + + + + + vmresume + intel + + 0f 01 /reg=0 /mod=11 /rm=3 + + + + + vmxoff + intel + + 0f 01 /reg=0 /mod=11 /rm=4 + + + + + vmread + intel + + aso rexr rexx rexb + 0f 78 + Ey Gy + def64 + + + + + vmwrite + intel + + aso rexr rexx rexb + 0f 79 + Gy Ey + def64 + + + + + vmrun + amd + + 0f 01 /reg=3 /mod=11 /rm=0 + + + + + vmmcall + amd + + 0f 01 /reg=3 /mod=11 /rm=1 + + + + + vmload + amd + + 0f 01 /reg=3 /mod=11 /rm=2 + + + + + vmsave + amd + + 0f 01 /reg=3 /mod=11 /rm=3 + + + + + wait + + 9b + + + + + wbinvd + + 0f 09 + + + + + wrmsr + + 0f 30 + + + + + xadd + + aso oso rexr rexx rexb + 0f c0 + Eb Gb + + + aso oso rexw rexr rexx rexb + 0f c1 + Ev Gv + + + + + xchg + + aso rexr rexx rexb + 86 + Eb Gb + + + aso oso rexw rexr rexx rexb + 87 + Ev Gv + + + oso rexw rexb + 90 + R0v rAX + + + oso rexw rexb + 91 + R1v rAX + + + oso rexw rexb + 92 + R2v rAX + + + oso rexw rexb + 93 + R3v rAX + + + oso rexw rexb + 94 + R4v rAX + + + oso rexw rexb + 95 + R5v rAX + + + oso rexw rexb + 96 + R6v rAX + + + oso rexw rexb + 97 + R7v rAX + + + + + xgetbv + + 0f 01 /mod=11 /reg=2 /rm=0 + + + + + xlatb + + rexw seg + d7 + + + + + xor + + aso rexr rexx rexb + 30 + Eb Gb + + + aso oso rexw rexr rexx rexb + 31 + Ev Gv + + + aso rexr rexx rexb + 32 + Gb Eb + + + aso oso rexw rexr rexx rexb + 33 + Gv Ev + + + 34 + AL Ib + + + oso rexw + 35 + rAX sIz + + + aso rexr rexx rexb + 80 /reg=6 + Eb Ib + + + aso oso rexw rexr rexx rexb + 81 /reg=6 + Ev sIz + + + aso rexr rexx rexb + 82 /reg=6 /m=!64 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 83 /reg=6 + Ev sIb + + + + + xorpd + + aso rexr rexx rexb vexl + /sse=66 0f 57 + V H W + sse2 avx + + + + + xorps + + aso rexr rexx rexb + 0f 57 + V H W + sse2 avx + + + + + xcryptecb + + 0f a7 /mod=11 /rm=0 /reg=1 + + + + + xcryptcbc + + 0f a7 /mod=11 /rm=0 /reg=2 + + + + + xcryptctr + + 0f a7 /mod=11 /rm=0 /reg=3 + + + + + xcryptcfb + + 0f a7 /mod=11 /rm=0 /reg=4 + + + + + xcryptofb + + 0f a7 /mod=11 /rm=0 /reg=5 + + + + + xrstor + + aso rexw rexr rexx rexb + 0f ae /reg=5 /mod=!11 + M + + + + + xsave + + aso rexw rexr rexx rexb + 0f ae /reg=4 /mod=!11 + M + + + + + xsetbv + + 0f 01 /mod=11 /reg=2 /rm=1 + + + + + xsha1 + + 0f a6 /mod=11 /rm=0 /reg=1 + + + + + xsha256 + + 0f a6 /mod=11 /rm=0 /reg=2 + + + + + xstore + + 0f a7 /mod=11 /rm=0 /reg=0 + + + + + pclmulqdq + + aso rexr rexx rexb + /sse=66 0f 3a 44 + V H W Ib + aesni avx + + + + + + + getsec + smx + + 0f 37 + + + + + + + movdqa + + aso rexr rexx rexb vexl + /sse=66 0f 7f + W V + + + aso rexr rexx rexb vexl + /sse=66 0f 6f + V W + + sse2 avx + + + + maskmovdqu + + aso rexr rexx rexb + /sse=66 0f f7 /mod=11 + V U + sse2 avx + + + + + movdq2q + + aso rexb + /sse=f2 0f d6 + P U + + + + + movdqu + + aso rexr rexx rexb vexl + /sse=f3 0f 6f + V W + + + aso rexr rexx rexb vexl + /sse=f3 0f 7f + W V + + sse2 avx + + + + movq2dq + + aso rexr + /sse=f3 0f d6 + V N + + + + + paddq + + aso rexr rexx rexb + 0f d4 + P Q + + + aso rexr rexx rexb + /sse=66 0f d4 + V H W + sse2 avx + + + + + psubq + + aso rexr rexx rexb + /sse=66 0f fb + V H W + sse2 avx + + + aso rexr rexx rexb + 0f fb + P Q + + + + + pmuludq + + aso rexr rexx rexb + 0f f4 + P Q + + + aso rexr rexx rexb + /sse=66 0f f4 + V W + + + + + pshufhw + + aso rexr rexx rexb + /sse=f3 0f 70 + V W Ib + sse2 avx + + + + + pshuflw + + aso rexr rexx rexb + /sse=f2 0f 70 + V W Ib + sse2 avx + + + + + pshufd + + aso rexr rexx rexb + /sse=66 0f 70 + V W Ib + sse2 avx + + + + + pslldq + + rexb + /sse=66 0f 73 /reg=7 + H U Ib + sse2 avx + + + + + psrldq + + rexb + /sse=66 0f 73 /reg=3 + H U Ib + sse2 avx + + + + + punpckhqdq + + aso rexr rexx rexb + /sse=66 0f 6d + V H W + sse2 avx + + + + + punpcklqdq + + aso rexr rexx rexb + /sse=66 0f 6c + V H W + sse2 avx + + + + + haddpd + + aso rexr rexx rexb vexl + /sse=66 0f 7c + V H W + sse3 avx + + + + + haddps + + aso rexr rexx rexb vexl + /sse=f2 0f 7c + V H W + sse3 avx + + + + + hsubpd + + aso rexr rexx rexb vexl + /sse=66 0f 7d + V H W + sse3 avx + + + + + hsubps + + aso rexr rexx rexb vexl + /sse=f2 0f 7d + V H W + sse3 avx + + + + + insertps + + aso rexr rexw rexx rexb + /sse=66 0f 3a 21 + V H Md Ib + sse4.1 avx + + + + + lddqu + + aso rexr rexx rexb vexl + /sse=f2 0f f0 + V M + sse3 avx + + + + + movddup + + aso rexr rexx rexb + /sse=f2 0f 12 /mod=11 + V W + + + aso rexr rexx rexb + /sse=f2 0f 12 /mod=!11 + V W + + sse3 avx + + + + movshdup + + aso rexr rexx rexb vexl + /sse=f3 0f 16 /mod=11 + V W + sse3 avx + + + aso rexr rexx rexb vexl + /sse=f3 0f 16 /mod=!11 + V W + sse3 avx + + + + + movsldup + + aso rexr rexx rexb vexl + /sse=f3 0f 12 /mod=11 + V W + sse3 avx + + + aso rexr rexx rexb vexl + /sse=f3 0f 12 /mod=!11 + V W + sse3 avx + + + + + + + pabsb + + aso rexr rexx rexb + 0f 38 1c + P Q + ssse3 + + + aso rexr rexx rexb vexl + /sse=66 0f 38 1c + V W + ssse3 avx + + + + + pabsw + + aso rexr rexx rexb + 0f 38 1d + P Q + ssse3 + + + aso rexr rexx rexb vexl + /sse=66 0f 38 1d + V W + ssse3 avx + + + + + pabsd + + aso rexr rexx rexb + 0f 38 1e + P Q + ssse3 + + + aso rexr rexx rexb vexl + /sse=66 0f 38 1e + V W + ssse3 avx + + + + + pshufb + + aso rexr rexx rexb + 0f 38 00 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 00 + V H W + ssse3 avx + + + + + phaddw + + aso rexr rexx rexb + 0f 38 01 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 01 + V H W + ssse3 avx + + + + + phaddd + + aso rexr rexx rexb + 0f 38 02 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 02 + V H W + ssse3 avx + + + + + phaddsw + + aso rexr rexx rexb + 0f 38 03 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 03 + V H W + ssse3 avx + + + + + pmaddubsw + + aso rexr rexx rexb + 0f 38 04 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 04 + V H W + ssse3 avx + + + + + phsubw + + aso rexr rexx rexb + 0f 38 05 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 05 + V H W + ssse3 avx + + + + + phsubd + + aso rexr rexx rexb + 0f 38 06 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 06 + V H W + ssse3 avx + + + + + phsubsw + + aso rexr rexx rexb + 0f 38 07 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 07 + V H W + ssse3 avx + + + + + psignb + + aso rexr rexx rexb + 0f 38 08 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 08 + V H W + ssse3 avx + + + + + psignd + + aso rexr rexx rexb + 0f 38 0a + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 0a + V H W + ssse3 avx + + + + + psignw + + aso rexr rexx rexb + 0f 38 09 + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 09 + V H W + ssse3 avx + + + + + pmulhrsw + + aso rexr rexx rexb + 0f 38 0b + P Q + + + aso rexr rexx rexb + /sse=66 0f 38 0b + V H W + ssse3 avx + + + + + palignr + + aso rexr rexx rexb + 0f 3a 0f + P Q Ib + + + aso rexr rexx rexb + /sse=66 0f 3a 0f + V H W Ib + ssse3 avx + + + + + + + pblendvb + + aso rexr rexx rexb + /sse=66 0f 38 10 + V W + sse4.1 + + + + + pmuldq + + aso rexr rexx rexb + /sse=66 0f 38 28 + V H W + sse4.1 avx + + + + + pminsb + + aso rexr rexx rexb + /sse=66 0f 38 38 + V H W + sse4.1 avx + + + + + pminsd + + aso rexr rexx rexb + /sse=66 0f 38 39 + V H W + sse4.1 avx + + + + + pminuw + + aso rexr rexx rexb + /sse=66 0f 38 3a + V H W + sse4.1 avx + + + + + pminud + + aso rexr rexx rexb + /sse=66 0f 38 3b + V H W + sse4.1 avx + + + + + pmaxsb + + aso rexr rexx rexb + /sse=66 0f 38 3c + V H W + sse4.1 avx + + + + + pmaxsd + + aso rexr rexx rexb + /sse=66 0f 38 3d + V H W + sse4.1 avx + + + + + pmaxud + + aso rexr rexx rexb + /sse=66 0f 38 3f + V H W + sse4.1 avx + + + + + pmaxuw + + aso rexr rexx rexb + /sse=66 0f 38 3e + V H W + sse4.1 avx + + + + + pmulld + + aso rexr rexx rexb + /sse=66 0f 38 40 + V H W + sse4.1 avx + + + + + phminposuw + + aso rexr rexx rexb + /sse=66 0f 38 41 + V W + sse4.1 avx + + + + + roundps + + aso rexr rexx rexb vexl + /sse=66 0f 3a 08 + V W Ib + sse avx + + + + + roundpd + + aso rexr rexx rexb vexl + /sse=66 0f 3a 09 + V W Ib + sse4.1 avx + + + + + roundss + + aso rexr rexx rexb + /sse=66 0f 3a 0a + V H W Ib + sse4.1 avx + + + + + roundsd + + aso rexr rexx rexb + /sse=66 0f 3a 0b + V H W Ib + sse4.1 avx + + + + + blendpd + + aso rexr rexx rexb vexl + /sse=66 0f 3a 0d + V H W Ib + sse4.1 avx + + + + + blendps + + aso rexr rexx rexb + /sse=66 0f 3a 0c + V H W Ib + sse4.1 avx + + + + + blendvpd + + aso rexr rexx rexb + /sse=66 0f 38 15 + V W + sse4.1 + + + + + blendvps + + aso rexr rexx rexb + /sse=66 0f 38 14 + V W + sse4.1 + + + + + bound + + aso oso + 62 /m=!64 + Gv M + + + + + bsf + + aso oso rexw rexr rexx rexb + 0f bc + Gv Ev + + + + + bsr + + aso oso rexw rexr rexx rexb + 0f bd + Gv Ev + + + + + bswap + + oso rexw rexb + 0f c8 + R0y + + + oso rexw rexb + 0f c9 + R1y + + + oso rexw rexb + 0f ca + R2y + + + oso rexw rexb + 0f cb + R3y + + + oso rexw rexb + 0f cc + R4y + + + oso rexw rexb + 0f cd + R5y + + + oso rexw rexb + 0f ce + R6y + + + oso rexw rexb + 0f cf + R7y + + + + + bt + + aso oso rexw rexr rexx rexb + 0f ba /reg=4 + Ev Ib + + + aso oso rexw rexr rexx rexb + 0f a3 + Ev Gv + + + + + btc + + aso oso rexw rexr rexx rexb + 0f bb + Ev Gv + + + aso oso rexw rexr rexx rexb + 0f ba /reg=7 + Ev Ib + + + + + btr + + aso oso rexw rexr rexx rexb + 0f b3 + Ev Gv + + + aso oso rexw rexr rexx rexb + 0f ba /reg=6 + Ev Ib + + + + + bts + + aso oso rexw rexr rexx rexb + 0f ab + Ev Gv + + + aso oso rexw rexr rexx rexb + 0f ba /reg=5 + Ev Ib + + + + + pblendw + + aso rexr rexx rexb + /sse=66 0f 3a 0e + V H W Ib + sse4.1 avx + + + + + mpsadbw + + aso rexr rexx rexb vexl + /sse=66 0f 3a 42 + V H W Ib + sse4.1 avx + + + + + movntdqa + + aso rexr rexw rexx rexb vexl + /sse=66 0f 38 2a + V M + sse4.1 avx + + + + + packusdw + + aso rexr rexw rexx rexb vexl + /sse=66 0f 38 2b + V H W + sse2 avx + + + + + pmovsxbw + + aso rexr rexw rexx rexb + /sse=66 0f 38 20 + V MqU + sse4.1 avx + + + + + pmovsxbd + + aso rexr rexw rexx rexb + /sse=66 0f 38 21 + V MdU + sse4.1 avx + + + + + pmovsxbq + + aso rexr rexw rexx rexb + /sse=66 0f 38 22 + V MwU + sse4.1 avx + + + + + pmovsxwd + + aso rexr rexw rexx rexb + /sse=66 0f 38 23 + V MqU + sse4.1 avx + + + + + pmovsxwq + + aso rexr rexw rexx rexb + /sse=66 0f 38 24 + V MdU + sse4.1 avx + + + + + pmovsxdq + + aso rexr rexw rexx rexb + /sse=66 0f 38 25 + V MqU + sse4.1 + + + + + pmovzxbw + + aso rexr rexw rexx rexb + /sse=66 0f 38 30 + V MqU + sse4.1 avx + + + + + pmovzxbd + + aso rexr rexw rexx rexb + /sse=66 0f 38 31 + V MdU + sse4.1 avx + + + + + pmovzxbq + + aso rexr rexw rexx rexb + /sse=66 0f 38 32 + V MwU + sse4.1 avx + + + + + pmovzxwd + + aso rexr rexw rexx rexb + /sse=66 0f 38 33 + V MqU + sse4.1 avx + + + + + pmovzxwq + + aso rexr rexw rexx rexb + /sse=66 0f 38 34 + V MdU + sse4.1 avx + + + + + pmovzxdq + + aso rexr rexw rexx rexb + /sse=66 0f 38 35 + V MqU + sse4.1 avx + + + + + pcmpeqq + + aso rexr rexw rexx rexb + /sse=66 0f 38 29 + V H W + sse4.1 avx + + + + + popcnt + + aso oso rexr rexw rexx rexb + /sse=f3 0f b8 + Gv Ev + + sse4.2 + + + + ptest + + aso rexr rexw rexx rexb vexl + /sse=66 0f 38 17 + V W + sse4.1 avx + + + + + pcmpestri + + aso rexr rexw rexx rexb + /sse=66 0f 3a 61 + V W Ib + sse4.2 avx + + + + + pcmpestrm + + aso rexr rexw rexx rexb + /sse=66 0f 3a 60 + V W Ib + sse4.2 avx + + + + + pcmpgtq + + aso rexr rexw rexx rexb + /sse=66 0f 38 37 + V H W + sse4.2 avx + + + + + pcmpistri + + aso rexr rexw rexx rexb + /sse=66 0f 3a 63 + V W Ib + sse4.2 avx + + + + + pcmpistrm + + aso rexr rexw rexx rexb + /sse=66 0f 3a 62 + V W Ib + sse4.2 avx + + + + + movbe + + aso oso rexr rexw rexx rexb + 0f 38 f0 + Gv Mv + sse3 atom + + + aso oso rexr rexw rexx rexb + 0f 38 f1 + Mv Gv + sse3 atom + + + + + crc32 + + aso oso rexr rexw rexx rexb + /sse=f2 0f 38 f0 + Gy Eb + sse4.2 + + + aso oso rexr rexw rexx rexb + /sse=f2 0f 38 f1 + Gy Ev + sse4.2 + + + + + invalid + + + + vbroadcastss + + aso rexr rexx rexb vexl + /vex=66_0f38 18 /vexw=0 + V Md + avx + + + + + vbroadcastsd + + aso rexr rexx rexb vexl + /vex=66_0f38 19 /vexw=0 /vexl=1 + Vqq Mq + avx + + + + + vextractf128 + + aso rexr rexx rexb vexl + /vex=66_0f3a 19 /vexw=0 /vexl=1 + Wdq Vqq Ib + avx + + + + + vinsertf128 + + aso rexr rexx rexb vexl + /vex=66_0f3a 18 /vexw=0 /vexl=1 + Vqq Hqq Wdq Ib + avx + + + + + vmaskmovps + + aso rexr rexx rexb vexl + /vex=66_0f38 2c /vexw=0 + V H M + avx + + + aso rexr rexx rexb vexl + /vex=66_0f38 2e /vexw=0 + M H V + avx + + + + + vmaskmovpd + + aso rexr rexx rexb vexl + /vex=66_0f38 2d /vexw=0 + V H M + avx + + + aso rexr rexx rexb vexl + /vex=66_0f38 2f /vexw=0 + M H V + avx + + + + + vpermilpd + + aso rexr rexx rexb vexl + /vex=66_0f38 0d /vexw=0 + Vx Hx Wx + avx + + + aso rexr rexx rexb vexl + /vex=66_0f3a 05 /vexw=0 + V W Ib + avx + + + + + vpermilps + + aso rexr rexx rexb vexl + /vex=66_0f38 0c /vexw=0 + Vx Hx Wx + avx + + + aso rexr rexx rexb vexl + /vex=66_0f3a 04 /vexw=0 + Vx Wx Ib + avx + + + + + vperm2f128 + + aso rexr rexx rexb vexl + /vex=66_0f3a 06 /vexw=0 /vexl=1 + Vqq Hqq Wqq Ib + avx + + + + + vtestps + + aso rexr rexx rexb vexl + /vex=66_0f38 0e /vexw=0 + Vx Wx + avx + + + + + vtestpd + + aso rexr rexx rexb vexl + /vex=66_0f38 0f /vexw=0 + Vx Wx + avx + + + + + vzeroupper + + /vex=0f 77 /vexl=0 + avx + + + + + vzeroall + + /vex=0f 77 /vexl=1 + avx + + + + + vblendvpd + + aso rexr rexx rexb vexl + /vex=66_0f3a 4b /vexw=0 + Vx Hx Wx Lx + avx + + + + + vblendvps + + aso rexr rexx rexb vexl + /vex=66_0f3a 4a /vexw=0 + Vx Hx Wx Lx + avx + + + + + vmovsd + + aso rexr rexx rexb + /vex=f2_0f 10 /mod=11 + V H U + avx + + + aso rexr rexx rexb + /vex=f2_0f 10 /mod=!11 + V Mq + avx + + + aso rexr rexx rexb + /vex=f2_0f 11 /mod=11 + U H V + avx + + + aso rexr rexx rexb + /vex=f2_0f 11 /mod=!11 + Mq V + avx + + + + + vmovss + + aso rexr rexx rexb + /vex=f3_0f 10 /mod=11 + V H U + avx + + + aso rexr rexx rexb + /vex=f3_0f 10 /mod=!11 + V Md + avx + + + aso rexr rexx rexb + /vex=f3_0f 11 /mod=11 + U H V + avx + + + aso rexr rexx rexb + /vex=f3_0f 11 /mod=!11 + Md V + avx + + + + + vpblendvb + + aso rexr rexx rexb + /vex=66_0f3a 4c /vexw=0 + V H W L + avx + + + + + vpsllw + + aso rexr rexx rexb + /vex=66_0f f1 /vexl=0 + V H W + avx + + + aso rexr rexx rexb + /vex=66_0f 71 /reg=6 /vexl=0 + H V W + avx + + + + + vpslld + + aso rexr rexx rexb + /vex=66_0f f2 /vexl=0 + V H W + avx + + + aso rexr rexx rexb + /vex=66_0f 72 /reg=6 /vexl=0 + H V W + avx + + + + + vpsllq + + aso rexr rexx rexb + /vex=66_0f f3 /vexl=0 + V H W + avx + + + aso rexr rexx rexb + /vex=66_0f 73 /reg=6 /vexl=0 + H V W + avx + + + + diff --git a/Source/JavaScriptCore/disassembler/udis86/ud_itab.py b/Source/JavaScriptCore/disassembler/udis86/ud_itab.py new file mode 100644 index 000000000..ef011d2ec --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/ud_itab.py @@ -0,0 +1,379 @@ +# udis86 - scripts/ud_itab.py +# +# Copyright (c) 2009, 2013 Vivek Thampi +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import os +import sys +from ud_opcode import UdOpcodeTable, UdOpcodeTables, UdInsnDef + +class UdItabGenerator: + + OperandDict = { + "Av" : [ "OP_A" , "SZ_V" ], + "E" : [ "OP_E" , "SZ_NA" ], + "Eb" : [ "OP_E" , "SZ_B" ], + "Ew" : [ "OP_E" , "SZ_W" ], + "Ev" : [ "OP_E" , "SZ_V" ], + "Ed" : [ "OP_E" , "SZ_D" ], + "Ey" : [ "OP_E" , "SZ_Y" ], + "Eq" : [ "OP_E" , "SZ_Q" ], + "Ez" : [ "OP_E" , "SZ_Z" ], + "Fv" : [ "OP_F" , "SZ_V" ], + "G" : [ "OP_G" , "SZ_NA" ], + "Gb" : [ "OP_G" , "SZ_B" ], + "Gw" : [ "OP_G" , "SZ_W" ], + "Gv" : [ "OP_G" , "SZ_V" ], + "Gy" : [ "OP_G" , "SZ_Y" ], + "Gd" : [ "OP_G" , "SZ_D" ], + "Gq" : [ "OP_G" , "SZ_Q" ], + "Gz" : [ "OP_G" , "SZ_Z" ], + "M" : [ "OP_M" , "SZ_NA" ], + "Mb" : [ "OP_M" , "SZ_B" ], + "Mw" : [ "OP_M" , "SZ_W" ], + "Ms" : [ "OP_M" , "SZ_W" ], + "Md" : [ "OP_M" , "SZ_D" ], + "Mq" : [ "OP_M" , "SZ_Q" ], + "Mdq" : [ "OP_M" , "SZ_DQ" ], + "Mv" : [ "OP_M" , "SZ_V" ], + "Mt" : [ "OP_M" , "SZ_T" ], + "Mo" : [ "OP_M" , "SZ_O" ], + "MbRd" : [ "OP_MR" , "SZ_BD" ], + "MbRv" : [ "OP_MR" , "SZ_BV" ], + "MwRv" : [ "OP_MR" , "SZ_WV" ], + "MwRd" : [ "OP_MR" , "SZ_WD" ], + "MwRy" : [ "OP_MR" , "SZ_WY" ], + "MdRy" : [ "OP_MR" , "SZ_DY" ], + "I1" : [ "OP_I1" , "SZ_NA" ], + "I3" : [ "OP_I3" , "SZ_NA" ], + "Ib" : [ "OP_I" , "SZ_B" ], + "Iw" : [ "OP_I" , "SZ_W" ], + "Iv" : [ "OP_I" , "SZ_V" ], + "Iz" : [ "OP_I" , "SZ_Z" ], + "sIb" : [ "OP_sI" , "SZ_B" ], + "sIz" : [ "OP_sI" , "SZ_Z" ], + "sIv" : [ "OP_sI" , "SZ_V" ], + "Jv" : [ "OP_J" , "SZ_V" ], + "Jz" : [ "OP_J" , "SZ_Z" ], + "Jb" : [ "OP_J" , "SZ_B" ], + "R" : [ "OP_R" , "SZ_RDQ" ], + "C" : [ "OP_C" , "SZ_NA" ], + "D" : [ "OP_D" , "SZ_NA" ], + "S" : [ "OP_S" , "SZ_W" ], + "Ob" : [ "OP_O" , "SZ_B" ], + "Ow" : [ "OP_O" , "SZ_W" ], + "Ov" : [ "OP_O" , "SZ_V" ], + "U" : [ "OP_U" , "SZ_O" ], + "Ux" : [ "OP_U" , "SZ_X" ], + "V" : [ "OP_V" , "SZ_DQ" ], + "Vdq" : [ "OP_V" , "SZ_DQ" ], + "Vqq" : [ "OP_V" , "SZ_QQ" ], + "Vsd" : [ "OP_V" , "SZ_Q" ], + "Vx" : [ "OP_V" , "SZ_X" ], + "H" : [ "OP_H" , "SZ_X" ], + "Hx" : [ "OP_H" , "SZ_X" ], + "Hqq" : [ "OP_H" , "SZ_QQ" ], + "W" : [ "OP_W" , "SZ_DQ" ], + "Wdq" : [ "OP_W" , "SZ_DQ" ], + "Wqq" : [ "OP_W" , "SZ_QQ" ], + "Wsd" : [ "OP_W" , "SZ_Q" ], + "Wx" : [ "OP_W" , "SZ_X" ], + "L" : [ "OP_L" , "SZ_O" ], + "Lx" : [ "OP_L" , "SZ_X" ], + "MwU" : [ "OP_MU" , "SZ_WO" ], + "MdU" : [ "OP_MU" , "SZ_DO" ], + "MqU" : [ "OP_MU" , "SZ_QO" ], + "N" : [ "OP_N" , "SZ_Q" ], + "P" : [ "OP_P" , "SZ_Q" ], + "Q" : [ "OP_Q" , "SZ_Q" ], + "AL" : [ "OP_AL" , "SZ_B" ], + "AX" : [ "OP_AX" , "SZ_W" ], + "eAX" : [ "OP_eAX" , "SZ_Z" ], + "rAX" : [ "OP_rAX" , "SZ_V" ], + "CL" : [ "OP_CL" , "SZ_B" ], + "CX" : [ "OP_CX" , "SZ_W" ], + "eCX" : [ "OP_eCX" , "SZ_Z" ], + "rCX" : [ "OP_rCX" , "SZ_V" ], + "DL" : [ "OP_DL" , "SZ_B" ], + "DX" : [ "OP_DX" , "SZ_W" ], + "eDX" : [ "OP_eDX" , "SZ_Z" ], + "rDX" : [ "OP_rDX" , "SZ_V" ], + "R0b" : [ "OP_R0" , "SZ_B" ], + "R1b" : [ "OP_R1" , "SZ_B" ], + "R2b" : [ "OP_R2" , "SZ_B" ], + "R3b" : [ "OP_R3" , "SZ_B" ], + "R4b" : [ "OP_R4" , "SZ_B" ], + "R5b" : [ "OP_R5" , "SZ_B" ], + "R6b" : [ "OP_R6" , "SZ_B" ], + "R7b" : [ "OP_R7" , "SZ_B" ], + "R0w" : [ "OP_R0" , "SZ_W" ], + "R1w" : [ "OP_R1" , "SZ_W" ], + "R2w" : [ "OP_R2" , "SZ_W" ], + "R3w" : [ "OP_R3" , "SZ_W" ], + "R4w" : [ "OP_R4" , "SZ_W" ], + "R5w" : [ "OP_R5" , "SZ_W" ], + "R6w" : [ "OP_R6" , "SZ_W" ], + "R7w" : [ "OP_R7" , "SZ_W" ], + "R0v" : [ "OP_R0" , "SZ_V" ], + "R1v" : [ "OP_R1" , "SZ_V" ], + "R2v" : [ "OP_R2" , "SZ_V" ], + "R3v" : [ "OP_R3" , "SZ_V" ], + "R4v" : [ "OP_R4" , "SZ_V" ], + "R5v" : [ "OP_R5" , "SZ_V" ], + "R6v" : [ "OP_R6" , "SZ_V" ], + "R7v" : [ "OP_R7" , "SZ_V" ], + "R0z" : [ "OP_R0" , "SZ_Z" ], + "R1z" : [ "OP_R1" , "SZ_Z" ], + "R2z" : [ "OP_R2" , "SZ_Z" ], + "R3z" : [ "OP_R3" , "SZ_Z" ], + "R4z" : [ "OP_R4" , "SZ_Z" ], + "R5z" : [ "OP_R5" , "SZ_Z" ], + "R6z" : [ "OP_R6" , "SZ_Z" ], + "R7z" : [ "OP_R7" , "SZ_Z" ], + "R0y" : [ "OP_R0" , "SZ_Y" ], + "R1y" : [ "OP_R1" , "SZ_Y" ], + "R2y" : [ "OP_R2" , "SZ_Y" ], + "R3y" : [ "OP_R3" , "SZ_Y" ], + "R4y" : [ "OP_R4" , "SZ_Y" ], + "R5y" : [ "OP_R5" , "SZ_Y" ], + "R6y" : [ "OP_R6" , "SZ_Y" ], + "R7y" : [ "OP_R7" , "SZ_Y" ], + "ES" : [ "OP_ES" , "SZ_NA" ], + "CS" : [ "OP_CS" , "SZ_NA" ], + "DS" : [ "OP_DS" , "SZ_NA" ], + "SS" : [ "OP_SS" , "SZ_NA" ], + "GS" : [ "OP_GS" , "SZ_NA" ], + "FS" : [ "OP_FS" , "SZ_NA" ], + "ST0" : [ "OP_ST0" , "SZ_NA" ], + "ST1" : [ "OP_ST1" , "SZ_NA" ], + "ST2" : [ "OP_ST2" , "SZ_NA" ], + "ST3" : [ "OP_ST3" , "SZ_NA" ], + "ST4" : [ "OP_ST4" , "SZ_NA" ], + "ST5" : [ "OP_ST5" , "SZ_NA" ], + "ST6" : [ "OP_ST6" , "SZ_NA" ], + "ST7" : [ "OP_ST7" , "SZ_NA" ], + "NONE" : [ "OP_NONE" , "SZ_NA" ], + } + + # + # opcode prefix dictionary + # + PrefixDict = { + "rep" : "P_str", + "repz" : "P_strz", + "aso" : "P_aso", + "oso" : "P_oso", + "rexw" : "P_rexw", + "rexb" : "P_rexb", + "rexx" : "P_rexx", + "rexr" : "P_rexr", + "vexl" : "P_vexl", + "vexw" : "P_vexw", + "seg" : "P_seg", + "inv64" : "P_inv64", + "def64" : "P_def64", + "cast" : "P_cast", + } + + MnemonicAliases = ( "invalid", "3dnow", "none", "db", "pause" ) + + def __init__(self, tables): + self.tables = tables + self._insnIndexMap, i = {}, 0 + for insn in tables.getInsnList(): + self._insnIndexMap[insn], i = i, i + 1 + + self._tableIndexMap, i = {}, 0 + for table in tables.getTableList(): + self._tableIndexMap[table], i = i, i + 1 + + def getInsnIndex(self, insn): + assert isinstance(insn, UdInsnDef) + return self._insnIndexMap[insn] + + def getTableIndex(self, table): + assert isinstance(table, UdOpcodeTable) + return self._tableIndexMap[table] + + def getTableName(self, table): + return "ud_itab__%d" % self.getTableIndex(table) + + def genOpcodeTable(self, table, isGlobal=False): + """Emit Opcode Table in C. + """ + self.ItabC.write( "\n" ); + if not isGlobal: + self.ItabC.write('static ') + self.ItabC.write( "const uint16_t %s[] = {\n" % self.getTableName(table)) + for i in range(table.size()): + if i > 0 and i % 4 == 0: + self.ItabC.write( "\n" ) + if i % 4 == 0: + self.ItabC.write( " /* %2x */" % i) + e = table.entryAt(i) + if e is None: + self.ItabC.write("%12s," % "INVALID") + elif isinstance(e, UdOpcodeTable): + self.ItabC.write("%12s," % ("GROUP(%d)" % self.getTableIndex(e))) + elif isinstance(e, UdInsnDef): + self.ItabC.write("%12s," % self.getInsnIndex(e)) + self.ItabC.write( "\n" ) + self.ItabC.write( "};\n" ) + + + def genOpcodeTables(self): + tables = self.tables.getTableList() + for table in tables: + self.genOpcodeTable(table, table is self.tables.root) + + + def genOpcodeTablesLookupIndex(self): + self.ItabC.write( "\n\n" ); + self.ItabC.write( "struct ud_lookup_table_list_entry ud_lookup_table_list[] = {\n" ) + for table in self.tables.getTableList(): + f0 = self.getTableName(table) + "," + f1 = table.label() + "," + f2 = "\"%s\"" % table.meta() + self.ItabC.write(" /* %03d */ { %s %s %s },\n" % + (self.getTableIndex(table), f0, f1, f2)) + self.ItabC.write( "};" ) + + + def genInsnTable( self ): + self.ItabC.write( "struct ud_itab_entry ud_itab[] = {\n" ); + for insn in self.tables.getInsnList(): + opr_c = [ "O_NONE", "O_NONE", "O_NONE", "O_NONE" ] + pfx_c = [] + opr = insn.operands + for i in range(len(opr)): + if not (opr[i] in self.OperandDict.keys()): + print("error: invalid operand declaration: %s\n" % opr[i]) + opr_c[i] = "O_" + opr[i] + opr = "%s %s %s %s" % (opr_c[0] + ",", opr_c[1] + ",", + opr_c[2] + ",", opr_c[3]) + + for p in insn.prefixes: + if not ( p in self.PrefixDict.keys() ): + print("error: invalid prefix specification: %s \n" % pfx) + pfx_c.append( self.PrefixDict[p] ) + if len(insn.prefixes) == 0: + pfx_c.append( "P_none" ) + pfx = "|".join( pfx_c ) + + self.ItabC.write( " /* %04d */ { UD_I%s %s, %s },\n" \ + % ( self.getInsnIndex(insn), insn.mnemonic + ',', opr, pfx ) ) + self.ItabC.write( "};\n" ) + + + def getMnemonicsList(self): + mnemonics = self.tables.getMnemonicsList() + mnemonics.extend(self.MnemonicAliases) + return mnemonics + + def genMnemonicsList(self): + mnemonics = self.getMnemonicsList() + self.ItabC.write( "\n\n" ); + self.ItabC.write( "const char* ud_mnemonics_str[] = {\n " ) + self.ItabC.write( ",\n ".join( [ "\"%s\"" % m for m in mnemonics ] ) ) + self.ItabC.write( "\n};\n" ) + + + def genItabH( self, filePath ): + self.ItabH = open( filePath, "w" ) + + # Generate Table Type Enumeration + self.ItabH.write( "#ifndef UD_ITAB_H\n" ) + self.ItabH.write( "#define UD_ITAB_H\n\n" ) + + self.ItabH.write("/* itab.h -- generated by udis86:scripts/ud_itab.py, do no edit */\n\n") + + # table type enumeration + self.ItabH.write( "/* ud_table_type -- lookup table types (see decode.c) */\n" ) + self.ItabH.write( "enum ud_table_type {\n " ) + enum = UdOpcodeTable.getLabels() + self.ItabH.write( ",\n ".join( enum ) ) + self.ItabH.write( "\n};\n\n" ); + + # mnemonic enumeration + self.ItabH.write( "/* ud_mnemonic -- mnemonic constants */\n" ) + enum = "enum ud_mnemonic_code {\n " + enum += ",\n ".join( [ "UD_I%s" % m for m in self.getMnemonicsList() ] ) + enum += ",\n UD_MAX_MNEMONIC_CODE" + enum += "\n};\n" + self.ItabH.write( enum ) + self.ItabH.write( "\n" ) + + self.ItabH.write( "extern const char * ud_mnemonics_str[];\n" ) + + self.ItabH.write( "\n#endif /* UD_ITAB_H */\n" ) + + self.ItabH.close() + + + def genItabC(self, filePath): + self.ItabC = open(filePath, "w") + self.ItabC.write("/* itab.c -- generated by udis86:scripts/ud_itab.py, do no edit") + self.ItabC.write(" */\n"); + self.ItabC.write("#include \"udis86_decode.h\"\n\n"); + + self.ItabC.write("#define GROUP(n) (0x8000 | (n))\n") + self.ItabC.write("#define INVALID %d\n\n" % self.getInsnIndex(self.tables.invalidInsn)) + + self.genOpcodeTables() + self.genOpcodeTablesLookupIndex() + + # + # Macros defining short-names for operands + # + self.ItabC.write("\n\n/* itab entry operand definitions (for readability) */\n"); + operands = self.OperandDict.keys() + operands = sorted(operands) + for o in operands: + self.ItabC.write("#define O_%-7s { %-12s %-8s }\n" % + (o, self.OperandDict[o][0] + ",", self.OperandDict[o][1])); + self.ItabC.write("\n"); + + self.genInsnTable() + self.genMnemonicsList() + + self.ItabC.close() + + def genItab( self, location ): + self.genItabC(os.path.join(location, "udis86_itab.c")) + self.genItabH(os.path.join(location, "udis86_itab.h")) + +def usage(): + print("usage: ud_itab.py ") + +def main(): + + if len(sys.argv) != 3: + usage() + sys.exit(1) + + tables = UdOpcodeTables(xml=sys.argv[1]) + itab = UdItabGenerator(tables) + itab.genItab(sys.argv[2]) + +if __name__ == '__main__': + main() diff --git a/Source/JavaScriptCore/disassembler/udis86/ud_opcode.py b/Source/JavaScriptCore/disassembler/udis86/ud_opcode.py new file mode 100644 index 000000000..fe1833dc7 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/ud_opcode.py @@ -0,0 +1,622 @@ +# udis86 - scripts/ud_opcode.py +# +# Copyright (c) 2009, 2013 Vivek Thampi +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import os + +# Some compatibility stuff for supporting python 2.x as well as python 3.x +def itemslist(dict): + try: + return dict.iteritems() # python 2.x + except AttributeError: + return list(dict.items()) # python 3.x + +class UdInsnDef: + """An x86 instruction definition + """ + def __init__(self, **insnDef): + self.mnemonic = insnDef['mnemonic'] + self.prefixes = insnDef['prefixes'] + self.opcodes = insnDef['opcodes'] + self.operands = insnDef['operands'] + self._cpuid = insnDef['cpuid'] + self._opcexts = {} + + for opc in self.opcodes: + if opc.startswith('/'): + e, v = opc.split('=') + self._opcexts[e] = v + + def lookupPrefix(self, pfx): + """Lookup prefix (if any, None otherwise), by name""" + return True if pfx in self.prefixes else None + + + @property + def vendor(self): + return self._opcexts.get('/vendor', None) + + @property + def mode(self): + return self._opcexts.get('/m', None) + + @property + def osize(self): + return self._opcexts.get('/o', None) + + def isDef64(self): + return 'def64' in self.prefixes + + def __str__(self): + return self.mnemonic + " " + ', '.join(self.operands) + \ + " " + ' '.join(self.opcodes) + + +class UdOpcodeTable: + """A single table of instruction definitions, indexed by + a decode field. + """ + + class CollisionError(Exception): + pass + + class IndexError(Exception): + """Invalid Index Error""" + pass + + @classmethod + def vendor2idx(cls, v): + return (0 if v == 'amd' + else (1 if v == 'intel' + else 2)) + + @classmethod + def vex2idx(cls, v): + if v.startswith("none_"): + v = v[5:] + vexOpcExtMap = { + 'none' : 0x0, + '0f' : 0x1, + '0f38' : 0x2, + '0f3a' : 0x3, + '66' : 0x4, + '66_0f' : 0x5, + '66_0f38' : 0x6, + '66_0f3a' : 0x7, + 'f3' : 0x8, + 'f3_0f' : 0x9, + 'f3_0f38' : 0xa, + 'f3_0f3a' : 0xb, + 'f2' : 0xc, + 'f2_0f' : 0xd, + 'f2_0f38' : 0xe, + 'f2_0f3a' : 0xf, + } + return vexOpcExtMap[v] + + + # A mapping of opcode extensions to their representational + # values used in the opcode map. + OpcExtMap = { + '/rm' : lambda v: int(v, 16), + '/x87' : lambda v: int(v, 16), + '/3dnow' : lambda v: int(v, 16), + '/reg' : lambda v: int(v, 16), + # modrm.mod + # (!11, 11) => (00b, 01b) + '/mod' : lambda v: 0 if v == '!11' else 1, + # Mode extensions: + # (16, 32, 64) => (00, 01, 02) + '/o' : lambda v: (int(v) / 32), + '/a' : lambda v: (int(v) / 32), + # Disassembly mode + # (!64, 64) => (00b, 01b) + '/m' : lambda v: 1 if v == '64' else 0, + # SSE + # none => 0 + # f2 => 1 + # f3 => 2 + # 66 => 3 + '/sse' : lambda v: (0 if v == 'none' + else (((int(v, 16) & 0xf) + 1) / 2)), + # AVX + '/vex' : lambda v: UdOpcodeTable.vex2idx(v), + '/vexw' : lambda v: 0 if v == '0' else 1, + '/vexl' : lambda v: 0 if v == '0' else 1, + # Vendor + '/vendor': lambda v: UdOpcodeTable.vendor2idx(v) + } + + + _TableInfo = { + 'opctbl' : { 'label' : 'UD_TAB__OPC_TABLE', 'size' : 256 }, + '/sse' : { 'label' : 'UD_TAB__OPC_SSE', 'size' : 4 }, + '/reg' : { 'label' : 'UD_TAB__OPC_REG', 'size' : 8 }, + '/rm' : { 'label' : 'UD_TAB__OPC_RM', 'size' : 8 }, + '/mod' : { 'label' : 'UD_TAB__OPC_MOD', 'size' : 2 }, + '/m' : { 'label' : 'UD_TAB__OPC_MODE', 'size' : 2 }, + '/x87' : { 'label' : 'UD_TAB__OPC_X87', 'size' : 64 }, + '/a' : { 'label' : 'UD_TAB__OPC_ASIZE', 'size' : 3 }, + '/o' : { 'label' : 'UD_TAB__OPC_OSIZE', 'size' : 3 }, + '/3dnow' : { 'label' : 'UD_TAB__OPC_3DNOW', 'size' : 256 }, + '/vendor' : { 'label' : 'UD_TAB__OPC_VENDOR', 'size' : 3 }, + '/vex' : { 'label' : 'UD_TAB__OPC_VEX', 'size' : 16 }, + '/vexw' : { 'label' : 'UD_TAB__OPC_VEX_W', 'size' : 2 }, + '/vexl' : { 'label' : 'UD_TAB__OPC_VEX_L', 'size' : 2 }, + } + + + def __init__(self, typ): + assert typ in self._TableInfo + self._typ = typ + self._entries = {} + + + def size(self): + return self._TableInfo[self._typ]['size'] + + def entries(self): + return itemslist(self._entries) + + def numEntries(self): + return len(self._entries.keys()) + + def label(self): + return self._TableInfo[self._typ]['label'] + + def typ(self): + return self._typ + + def meta(self): + return self._typ + + + def __str__(self): + return "table-%s" % self._typ + + + def add(self, opc, obj): + typ = UdOpcodeTable.getOpcodeTyp(opc) + idx = UdOpcodeTable.getOpcodeIdx(opc) + if self._typ != typ or idx in self._entries: + raise CollisionError() + self._entries[idx] = obj + + + def lookup(self, opc): + typ = UdOpcodeTable.getOpcodeTyp(opc) + idx = UdOpcodeTable.getOpcodeIdx(opc) + if self._typ != typ: + raise UdOpcodeTable.CollisionError("%s <-> %s" % (self._typ, typ)) + return self._entries.get(idx, None) + + + def entryAt(self, index): + """Returns the entry at a given index of the table, + None if there is none. Raises an exception if the + index is out of bounds. + """ + if index < self.size(): + return self._entries.get(index, None) + raise self.IndexError("index out of bounds: %s" % index) + + def setEntryAt(self, index, obj): + if index < self.size(): + self._entries[index] = obj + else: + raise self.IndexError("index out of bounds: %s" % index) + + @classmethod + def getOpcodeTyp(cls, opc): + if opc.startswith('/'): + return opc.split('=')[0] + else: + return 'opctbl' + + + @classmethod + def getOpcodeIdx(cls, opc): + if opc.startswith('/'): + typ, v = opc.split('=') + return cls.OpcExtMap[typ](v) + else: + # plain opctbl opcode + return int(opc, 16) + + + @classmethod + def getLabels(cls): + """Returns a list of all labels""" + return [cls._TableInfo[k]['label'] for k in cls._TableInfo.keys()] + + +class UdOpcodeTables(object): + """Collection of opcode tables + """ + + class CollisionError(Exception): + def __init__(self, obj1, obj2): + self.obj1, self.obj2 = obj1, obj2 + + def newTable(self, typ): + """Create a new opcode table of a give type `typ`. """ + tbl = UdOpcodeTable(typ) + self._tables.append(tbl) + return tbl + + def mkTrie(self, opcodes, obj): + """Recursively contruct a trie entry mapping a string of + opcodes to an object. + """ + if len(opcodes) == 0: + return obj + opc = opcodes[0] + tbl = self.newTable(UdOpcodeTable.getOpcodeTyp(opc)) + tbl.add(opc, self.mkTrie(opcodes[1:], obj)) + return tbl + + def walk(self, tbl, opcodes): + """Walk down the opcode trie, starting at a given opcode + table, given a string of opcodes. Return None if unable + to walk, the object at the leaf otherwise. + """ + opc = opcodes[0] + e = tbl.lookup(opc) + if e is None: + return None + elif isinstance(e, UdOpcodeTable) and len(opcodes[1:]): + return self.walk(e, opcodes[1:]) + return e + + def map(self, tbl, opcodes, obj): + """Create a mapping from a given string of opcodes to an + object in the opcode trie. Constructs trie branches as + needed. + """ + opc = opcodes[0] + e = tbl.lookup(opc) + if e is None: + tbl.add(opc, self.mkTrie(opcodes[1:], obj)) + else: + if len(opcodes[1:]) == 0: + raise self.CollisionError(e, obj) + self.map(e, opcodes[1:], obj) + + def __init__(self, xml): + self._tables = [] + self._insns = [] + self._mnemonics = {} + + # The root table is always a 256 entry opctbl, indexed + # by a plain opcode byte + self.root = self.newTable('opctbl') + + if os.getenv("UD_OPCODE_DEBUG"): + self._logFh = open("opcodeTables.log", "w") + + # add an invalid instruction entry without any mapping + # in the opcode tables. + self.invalidInsn = UdInsnDef(mnemonic="invalid", opcodes=[], cpuid=[], + operands=[], prefixes=[]) + self._insns.append(self.invalidInsn) + + # Construct UdOpcodeTables object from the given + # udis86 optable.xml + for insn in self.__class__.parseOptableXML(xml): + self.addInsnDef(insn) + self.patchAvx2byte() + self.mergeSSENONE() + self.printStats() + + def log(self, s): + if os.getenv("UD_OPCODE_DEBUG"): + self._logFh.write(s + "\n") + + + def mergeSSENONE(self): + """Merge sse tables with only one entry for /sse=none + """ + for table in self._tables: + for k, e in table.entries(): + if isinstance(e, UdOpcodeTable) and e.typ() == '/sse': + if e.numEntries() == 1: + sse = e.lookup("/sse=none") + if sse: + table.setEntryAt(k, sse) + uniqTables = {} + def genTableList(tbl): + if tbl not in uniqTables: + self._tables.append(tbl) + uniqTables[tbl] = 1 + for k, e in tbl.entries(): + if isinstance(e, UdOpcodeTable): + genTableList(e) + self._tables = [] + genTableList(self.root) + + + def patchAvx2byte(self): + # create avx tables + for pp in (None, 'f2', 'f3', '66'): + for m in (None, '0f', '0f38', '0f3a'): + if pp is None and m is None: + continue + if pp is None: + vex = m + elif m is None: + vex = pp + else: + vex = pp + '_' + m + table = self.walk(self.root, ('c4', '/vex=' + vex)) + self.map(self.root, ('c5', '/vex=' + vex), table) + + + def addInsn(self, **insnDef): + + # Canonicalize opcode list + opcexts = insnDef['opcexts'] + opcodes = list(insnDef['opcodes']) + + # Re-order vex + if '/vex' in opcexts: + assert opcodes[0] == 'c4' or opcodes[0] == 'c5' + opcodes.insert(1, '/vex=' + opcexts['/vex']) + + # Add extensions. The order is important, and determines how + # well the opcode table is packed. Also note, /sse must be + # before /o, because /sse may consume operand size prefix + # affect the outcome of /o. + for ext in ('/mod', '/x87', '/reg', '/rm', '/sse', '/o', '/a', '/m', + '/vexw', '/vexl', '/3dnow', '/vendor'): + if ext in opcexts: + opcodes.append(ext + '=' + opcexts[ext]) + + insn = UdInsnDef(mnemonic = insnDef['mnemonic'], + prefixes = insnDef['prefixes'], + operands = insnDef['operands'], + opcodes = opcodes, + cpuid = insnDef['cpuid']) + try: + self.map(self.root, opcodes, insn) + except self.CollisionError as e: + self.pprint() + print(opcodes, insn, str(e.obj1), str(e.obj2)) + raise + except Exception as e: + self.pprint() + raise + self._insns.append(insn) + # add to lookup by mnemonic structure + if insn.mnemonic not in self._mnemonics: + self._mnemonics[insn.mnemonic] = [ insn ] + else: + self._mnemonics[insn.mnemonic].append(insn) + + + def addInsnDef(self, insnDef): + opcodes = [] + opcexts = {} + + # pack plain opcodes first, and collect opcode + # extensions + for opc in insnDef['opcodes']: + if not opc.startswith('/'): + opcodes.append(opc) + else: + e, v = opc.split('=') + opcexts[e] = v + + # treat vendor as an opcode extension + if len(insnDef['vendor']): + opcexts['/vendor'] = insnDef['vendor'][0] + + if insnDef['mnemonic'] in ('lds', 'les'): + # + # Massage lds and les, which share the same prefix as AVX + # instructions, to work well with the opcode tree. + # + opcexts['/vex'] = 'none' + elif '/vex' in opcexts: + # A proper avx instruction definition; make sure there are + # no legacy opcode extensions + assert '/sse' not in opcodes + + # make sure the opcode definitions don't already include + # the avx prefixes. + assert opcodes[0] not in ('c4', 'c5') + + # An avx only instruction is defined by the /vex= opcode + # extension. They do not include the c4 (long form) or + # c5 (short form) prefix. As part of opcode table generate, + # here we create the long form definition, and then patch + # the table for c5 in a later stage. + # Construct a long-form definition of the avx instruction + opcodes.insert(0, 'c4') + elif (opcodes[0] == '0f' and opcodes[1] != '0f' and + '/sse' not in opcexts): + # Make all 2-byte opcode form isntructions play nice with sse + # opcode maps. + opcexts['/sse'] = 'none' + + # legacy sse defs that get promoted to avx + fn = self.addInsn + if 'avx' in insnDef['cpuid'] and '/sse' in opcexts: + fn = self.addSSE2AVXInsn + + fn(mnemonic = insnDef['mnemonic'], + prefixes = insnDef['prefixes'], + opcodes = opcodes, + opcexts = opcexts, + operands = insnDef['operands'], + cpuid = insnDef['cpuid']) + + + def addSSE2AVXInsn(self, **insnDef): + """Add an instruction definition containing an avx cpuid bit, but + declared in its legacy SSE form. The function splits the + definition to create two new definitions, one for SSE and one + promoted to an AVX form. + """ + + # SSE + ssemnemonic = insnDef['mnemonic'] + sseopcodes = insnDef['opcodes'] + # remove vex opcode extensions + sseopcexts = dict([(e, v) for e, v in itemslist(insnDef['opcexts']) + if not e.startswith('/vex')]) + # strip out avx operands, preserving relative ordering + # of remaining operands + sseoperands = [opr for opr in insnDef['operands'] + if opr not in ('H', 'L')] + # strip out avx prefixes + sseprefixes = [pfx for pfx in insnDef['prefixes'] + if not pfx.startswith('vex')] + # strip out avx bits from cpuid + ssecpuid = [flag for flag in insnDef['cpuid'] + if not flag.startswith('avx')] + + self.addInsn(mnemonic = ssemnemonic, + prefixes = sseprefixes, + opcodes = sseopcodes, + opcexts = sseopcexts, + operands = sseoperands, + cpuid = ssecpuid) + + # AVX + vexmnemonic = 'v' + insnDef['mnemonic'] + vexprefixes = insnDef['prefixes'] + vexopcodes = ['c4'] + vexopcexts = dict([(e, insnDef['opcexts'][e]) + for e in insnDef['opcexts'] if e != '/sse']) + vexopcexts['/vex'] = insnDef['opcexts']['/sse'] + '_' + '0f' + if insnDef['opcodes'][1] == '38' or insnDef['opcodes'][1] == '3a': + vexopcexts['/vex'] += insnDef['opcodes'][1] + vexopcodes.extend(insnDef['opcodes'][2:]) + else: + vexopcodes.extend(insnDef['opcodes'][1:]) + vexoperands = [] + for o in insnDef['operands']: + # make the operand size explicit: x + if o in ('V', 'W', 'H', 'U'): + o = o + 'x' + vexoperands.append(o) + vexcpuid = [flag for flag in insnDef['cpuid'] + if not flag.startswith('sse')] + + self.addInsn(mnemonic = vexmnemonic, + prefixes = vexprefixes, + opcodes = vexopcodes, + opcexts = vexopcexts, + operands = vexoperands, + cpuid = vexcpuid) + + def getInsnList(self): + """Returns a list of all instructions in the collection""" + return self._insns + + + def getTableList(self): + """Returns a list of all tables in the collection""" + return self._tables + + def getMnemonicsList(self): + """Returns a sorted list of mnemonics""" + return sorted(self._mnemonics.keys()) + + + def pprint(self): + def printWalk(tbl, indent=""): + entries = tbl.entries() + for k, e in entries: + if isinstance(e, UdOpcodeTable): + self.log("%s |-<%02x> %s" % (indent, k, e)) + printWalk(e, indent + " |") + elif isinstance(e, UdInsnDef): + self.log("%s |-<%02x> %s" % (indent, k, e)) + printWalk(self.root) + + + def printStats(self): + tables = self.getTableList() + self.log("stats: ") + self.log(" Num tables = %d" % len(tables)) + self.log(" Num insnDefs = %d" % len(self.getInsnList())) + self.log(" Num insns = %d" % len(self.getMnemonicsList())) + + totalSize = 0 + totalEntries = 0 + for table in tables: + totalSize += table.size() + totalEntries += table.numEntries() + self.log(" Packing Ratio = %d%%" % ((totalEntries * 100) / totalSize)) + self.log("--------------------") + + self.pprint() + + + @staticmethod + def parseOptableXML(xml): + """Parse udis86 optable.xml file and return list of + instruction definitions. + """ + from xml.dom import minidom + + xmlDoc = minidom.parse(xml) + tlNode = xmlDoc.firstChild + insns = [] + + while tlNode and tlNode.localName != "x86optable": + tlNode = tlNode.nextSibling + + for insnNode in tlNode.childNodes: + if not insnNode.localName: + continue + if insnNode.localName != "instruction": + raise Exception("warning: invalid insn node - %s" % insnNode.localName) + mnemonic = insnNode.getElementsByTagName('mnemonic')[0].firstChild.data + vendor, cpuid = '', [] + + for node in insnNode.childNodes: + if node.localName == 'vendor': + vendor = node.firstChild.data.split() + elif node.localName == 'cpuid': + cpuid = node.firstChild.data.split() + + for node in insnNode.childNodes: + if node.localName == 'def': + insnDef = { 'pfx' : [] } + for node in node.childNodes: + if not node.localName: + continue + if node.localName in ('pfx', 'opc', 'opr', 'vendor', 'cpuid'): + insnDef[node.localName] = node.firstChild.data.split() + elif node.localName == 'mode': + insnDef['pfx'].extend(node.firstChild.data.split()) + insns.append({'prefixes' : insnDef.get('pfx', []), + 'mnemonic' : mnemonic, + 'opcodes' : insnDef.get('opc', []), + 'operands' : insnDef.get('opr', []), + 'vendor' : insnDef.get('vendor', vendor), + 'cpuid' : insnDef.get('cpuid', cpuid)}) + return insns diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86.c b/Source/JavaScriptCore/disassembler/udis86/udis86.c new file mode 100644 index 000000000..56ab1a79b --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86.c @@ -0,0 +1,462 @@ +/* udis86 - libudis86/udis86.c + * + * Copyright (c) 2002-2013 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if USE(UDIS86) + +#include "udis86_udint.h" +#include "udis86_extern.h" +#include "udis86_decode.h" + +#if !defined(__UD_STANDALONE__) +#include +#endif /* !__UD_STANDALONE__ */ + +static void ud_inp_init(struct ud *u); + +/* ============================================================================= + * ud_init + * Initializes ud_t object. + * ============================================================================= + */ +extern void +ud_init(struct ud* u) +{ + memset((void*)u, 0, sizeof(struct ud)); + ud_set_mode(u, 16); + u->mnemonic = UD_Iinvalid; + ud_set_pc(u, 0); +#ifndef __UD_STANDALONE__ + ud_set_input_file(u, stdin); +#endif /* __UD_STANDALONE__ */ + + ud_set_asm_buffer(u, u->asm_buf_int, sizeof(u->asm_buf_int)); +} + + +/* ============================================================================= + * ud_disassemble + * Disassembles one instruction and returns the number of + * bytes disassembled. A zero means end of disassembly. + * ============================================================================= + */ +extern unsigned int +ud_disassemble(struct ud* u) +{ + int len; + if (u->inp_end) { + return 0; + } + if ((len = ud_decode(u)) > 0) { + if (u->translator != NULL) { + u->asm_buf[0] = '\0'; + u->translator(u); + } + } + return len; +} + + +/* ============================================================================= + * ud_set_mode() - Set Disassemly Mode. + * ============================================================================= + */ +extern void +ud_set_mode(struct ud* u, uint8_t m) +{ + switch(m) { + case 16: + case 32: + case 64: u->dis_mode = m ; return; + default: u->dis_mode = 16; return; + } +} + +/* ============================================================================= + * ud_set_vendor() - Set vendor. + * ============================================================================= + */ +extern void +ud_set_vendor(struct ud* u, unsigned v) +{ + switch(v) { + case UD_VENDOR_INTEL: + u->vendor = v; + break; + case UD_VENDOR_ANY: + u->vendor = v; + break; + default: + u->vendor = UD_VENDOR_AMD; + } +} + +/* ============================================================================= + * ud_set_pc() - Sets code origin. + * ============================================================================= + */ +extern void +ud_set_pc(struct ud* u, uint64_t o) +{ + u->pc = o; +} + +/* ============================================================================= + * ud_set_syntax() - Sets the output syntax. + * ============================================================================= + */ +extern void +ud_set_syntax(struct ud* u, void (*t)(struct ud*)) +{ + u->translator = t; +} + +/* ============================================================================= + * ud_insn() - returns the disassembled instruction + * ============================================================================= + */ +const char* +ud_insn_asm(const struct ud* u) +{ + return u->asm_buf; +} + +/* ============================================================================= + * ud_insn_offset() - Returns the offset. + * ============================================================================= + */ +uint64_t +ud_insn_off(const struct ud* u) +{ + return u->insn_offset; +} + + +/* ============================================================================= + * ud_insn_hex() - Returns hex form of disassembled instruction. + * ============================================================================= + */ +const char* +ud_insn_hex(struct ud* u) +{ + u->insn_hexcode[0] = 0; + if (!u->error) { + unsigned int i; + const unsigned char *src_ptr = ud_insn_ptr(u); + char* src_hex; + src_hex = (char*) u->insn_hexcode; + /* for each byte used to decode instruction */ + for (i = 0; i < ud_insn_len(u) && i < sizeof(u->insn_hexcode) / 2; + ++i, ++src_ptr) { + sprintf(src_hex, "%02x", *src_ptr & 0xFF); + src_hex += 2; + } + } + return u->insn_hexcode; +} + + +/* ============================================================================= + * ud_insn_ptr + * Returns a pointer to buffer containing the bytes that were + * disassembled. + * ============================================================================= + */ +extern const uint8_t* +ud_insn_ptr(const struct ud* u) +{ + return (u->inp_buf == NULL) ? + u->inp_sess : u->inp_buf + (u->inp_buf_index - u->inp_ctr); +} + + +/* ============================================================================= + * ud_insn_len + * Returns the count of bytes disassembled. + * ============================================================================= + */ +extern unsigned int +ud_insn_len(const struct ud* u) +{ + return u->inp_ctr; +} + + +/* ============================================================================= + * ud_insn_get_opr + * Return the operand struct representing the nth operand of + * the currently disassembled instruction. Returns NULL if + * there's no such operand. + * ============================================================================= + */ +const struct ud_operand* +ud_insn_opr(const struct ud *u, unsigned int n) +{ + if (n > 3 || u->operand[n].type == UD_NONE) { + return NULL; + } else { + return &u->operand[n]; + } +} + + +/* ============================================================================= + * ud_opr_is_sreg + * Returns non-zero if the given operand is of a segment register type. + * ============================================================================= + */ +int +ud_opr_is_sreg(const struct ud_operand *opr) +{ + return opr->type == UD_OP_REG && + opr->base >= UD_R_ES && + opr->base <= UD_R_GS; +} + + +/* ============================================================================= + * ud_opr_is_sreg + * Returns non-zero if the given operand is of a general purpose + * register type. + * ============================================================================= + */ +int +ud_opr_is_gpr(const struct ud_operand *opr) +{ + return opr->type == UD_OP_REG && + opr->base >= UD_R_AL && + opr->base <= UD_R_R15; +} + + +/* ============================================================================= + * ud_set_user_opaque_data + * ud_get_user_opaque_data + * Get/set user opaqute data pointer + * ============================================================================= + */ +void +ud_set_user_opaque_data(struct ud * u, void* opaque) +{ + u->user_opaque_data = opaque; +} + +void* +ud_get_user_opaque_data(const struct ud *u) +{ + return u->user_opaque_data; +} + + +/* ============================================================================= + * ud_set_asm_buffer + * Allow the user to set an assembler output buffer. If `buf` is NULL, + * we switch back to the internal buffer. + * ============================================================================= + */ +void +ud_set_asm_buffer(struct ud *u, char *buf, size_t size) +{ + if (buf == NULL) { + ud_set_asm_buffer(u, u->asm_buf_int, sizeof(u->asm_buf_int)); + } else { + u->asm_buf = buf; + u->asm_buf_size = size; + } +} + + +/* ============================================================================= + * ud_set_sym_resolver + * Set symbol resolver for relative targets used in the translation + * phase. + * + * The resolver is a function that takes a uint64_t address and returns a + * symbolic name for the that address. The function also takes a second + * argument pointing to an integer that the client can optionally set to a + * non-zero value for offsetted targets. (symbol+offset) The function may + * also return NULL, in which case the translator only prints the target + * address. + * + * The function pointer maybe NULL which resets symbol resolution. + * ============================================================================= + */ +void +ud_set_sym_resolver(struct ud *u, const char* (*resolver)(struct ud*, + uint64_t addr, + int64_t *offset)) +{ + u->sym_resolver = resolver; +} + + +/* ============================================================================= + * ud_insn_mnemonic + * Return the current instruction mnemonic. + * ============================================================================= + */ +enum ud_mnemonic_code +ud_insn_mnemonic(const struct ud *u) +{ + return u->mnemonic; +} + + +/* ============================================================================= + * ud_lookup_mnemonic + * Looks up mnemonic code in the mnemonic string table. + * Returns NULL if the mnemonic code is invalid. + * ============================================================================= + */ +const char* +ud_lookup_mnemonic(enum ud_mnemonic_code c) +{ + if (c < UD_MAX_MNEMONIC_CODE) { + return ud_mnemonics_str[c]; + } else { + return NULL; + } +} + + +/* + * ud_inp_init + * Initializes the input system. + */ +static void +ud_inp_init(struct ud *u) +{ + u->inp_hook = NULL; + u->inp_buf = NULL; + u->inp_buf_size = 0; + u->inp_buf_index = 0; + u->inp_curr = 0; + u->inp_ctr = 0; + u->inp_end = 0; + u->inp_peek = UD_EOI; + UD_NON_STANDALONE(u->inp_file = NULL); +} + + +/* ============================================================================= + * ud_inp_set_hook + * Sets input hook. + * ============================================================================= + */ +void +ud_set_input_hook(register struct ud* u, int (*hook)(struct ud*)) +{ + ud_inp_init(u); + u->inp_hook = hook; +} + +/* ============================================================================= + * ud_inp_set_buffer + * Set buffer as input. + * ============================================================================= + */ +void +ud_set_input_buffer(register struct ud* u, const uint8_t* buf, size_t len) +{ + ud_inp_init(u); + u->inp_buf = buf; + u->inp_buf_size = len; + u->inp_buf_index = 0; +} + + +#ifndef __UD_STANDALONE__ +/* ============================================================================= + * ud_input_set_file + * Set FILE as input. + * ============================================================================= + */ +static int +inp_file_hook(struct ud* u) +{ + return fgetc(u->inp_file); +} + +void +ud_set_input_file(register struct ud* u, FILE* f) +{ + ud_inp_init(u); + u->inp_hook = inp_file_hook; + u->inp_file = f; +} +#endif /* __UD_STANDALONE__ */ + + +/* ============================================================================= + * ud_input_skip + * Skip n input bytes. + * ============================================================================ + */ +void +ud_input_skip(struct ud* u, size_t n) +{ + if (u->inp_end) { + return; + } + if (u->inp_buf == NULL) { + while (n--) { + int c = u->inp_hook(u); + if (c == UD_EOI) { + goto eoi; + } + } + return; + } else { + if (n > u->inp_buf_size || + u->inp_buf_index > u->inp_buf_size - n) { + u->inp_buf_index = u->inp_buf_size; + goto eoi; + } + u->inp_buf_index += n; + return; + } +eoi: + u->inp_end = 1; + UDERR(u, "cannot skip, eoi received\b"); + return; +} + + +/* ============================================================================= + * ud_input_end + * Returns non-zero on end-of-input. + * ============================================================================= + */ +int +ud_input_end(const struct ud *u) +{ + return u->inp_end; +} + +#endif // USE(UDIS86) + +/* vim:set ts=2 sw=2 expandtab */ diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86.h b/Source/JavaScriptCore/disassembler/udis86/udis86.h new file mode 100644 index 000000000..baaf495e0 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86.h @@ -0,0 +1,33 @@ +/* udis86 - udis86.h + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UDIS86_H +#define UDIS86_H + +#include "udis86_types.h" +#include "udis86_extern.h" +#include "udis86_itab.h" + +#endif diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_decode.c b/Source/JavaScriptCore/disassembler/udis86/udis86_decode.c new file mode 100644 index 000000000..c0ea28362 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_decode.c @@ -0,0 +1,1273 @@ +/* udis86 - libudis86/decode.c + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if USE(UDIS86) + +#include "udis86_udint.h" +#include "udis86_types.h" +#include "udis86_extern.h" +#include "udis86_decode.h" + +#ifndef __UD_STANDALONE__ +# include +#endif /* __UD_STANDALONE__ */ + +/* The max number of prefixes to an instruction */ +#define MAX_PREFIXES 15 + +/* rex prefix bits */ +#define REX_W(r) ( ( 0xF & ( r ) ) >> 3 ) +#define REX_R(r) ( ( 0x7 & ( r ) ) >> 2 ) +#define REX_X(r) ( ( 0x3 & ( r ) ) >> 1 ) +#define REX_B(r) ( ( 0x1 & ( r ) ) >> 0 ) +#define REX_PFX_MASK(n) ( ( P_REXW(n) << 3 ) | \ + ( P_REXR(n) << 2 ) | \ + ( P_REXX(n) << 1 ) | \ + ( P_REXB(n) << 0 ) ) + +/* scable-index-base bits */ +#define SIB_S(b) ( ( b ) >> 6 ) +#define SIB_I(b) ( ( ( b ) >> 3 ) & 7 ) +#define SIB_B(b) ( ( b ) & 7 ) + +/* modrm bits */ +#define MODRM_REG(b) ( ( ( b ) >> 3 ) & 7 ) +#define MODRM_NNN(b) ( ( ( b ) >> 3 ) & 7 ) +#define MODRM_MOD(b) ( ( ( b ) >> 6 ) & 3 ) +#define MODRM_RM(b) ( ( b ) & 7 ) + +static int decode_ext(struct ud *u, uint16_t ptr); +static int decode_opcode(struct ud *u); + +enum reg_class { /* register classes */ + REGCLASS_GPR, + REGCLASS_MMX, + REGCLASS_CR, + REGCLASS_DB, + REGCLASS_SEG, + REGCLASS_XMM +}; + + /* + * inp_start + * Should be called before each de-code operation. + */ +static void +inp_start(struct ud *u) +{ + u->inp_ctr = 0; +} + +static uint8_t +inp_peek(struct ud *u) +{ + if (u->inp_end == 0) { + if (u->inp_buf != NULL) { + if (u->inp_buf_index < u->inp_buf_size) { + return u->inp_buf[u->inp_buf_index]; + } + } else if (u->inp_peek != UD_EOI) { + return u->inp_peek; + } else { + int c; + if ((c = u->inp_hook(u)) != UD_EOI) { + u->inp_peek = c; + return u->inp_peek; + } + } + } + u->inp_end = 1; + UDERR(u, "byte expected, eoi received\n"); + return 0; +} + +static uint8_t +inp_next(struct ud *u) +{ + if (u->inp_end == 0) { + if (u->inp_buf != NULL) { + if (u->inp_buf_index < u->inp_buf_size) { + u->inp_ctr++; + return (u->inp_curr = u->inp_buf[u->inp_buf_index++]); + } + } else { + int c = u->inp_peek; + if (c != UD_EOI || (c = u->inp_hook(u)) != UD_EOI) { + u->inp_peek = UD_EOI; + u->inp_curr = c; + u->inp_sess[u->inp_ctr++] = u->inp_curr; + return u->inp_curr; + } + } + } + u->inp_end = 1; + UDERR(u, "byte expected, eoi received\n"); + return 0; +} + +static uint8_t +inp_curr(struct ud *u) +{ + return u->inp_curr; +} + + +/* + * inp_uint8 + * int_uint16 + * int_uint32 + * int_uint64 + * Load little-endian values from input + */ +static uint8_t +inp_uint8(struct ud* u) +{ + return inp_next(u); +} + +static uint16_t +inp_uint16(struct ud* u) +{ + uint16_t r, ret; + + ret = inp_next(u); + r = inp_next(u); + return ret | (r << 8); +} + +static uint32_t +inp_uint32(struct ud* u) +{ + uint32_t r, ret; + + ret = inp_next(u); + r = inp_next(u); + ret = ret | (r << 8); + r = inp_next(u); + ret = ret | (r << 16); + r = inp_next(u); + return ret | (r << 24); +} + +static uint64_t +inp_uint64(struct ud* u) +{ + uint64_t r, ret; + + ret = inp_next(u); + r = inp_next(u); + ret = ret | (r << 8); + r = inp_next(u); + ret = ret | (r << 16); + r = inp_next(u); + ret = ret | (r << 24); + r = inp_next(u); + ret = ret | (r << 32); + r = inp_next(u); + ret = ret | (r << 40); + r = inp_next(u); + ret = ret | (r << 48); + r = inp_next(u); + return ret | (r << 56); +} + + +static UD_INLINE int +eff_opr_mode(int dis_mode, int rex_w, int pfx_opr) +{ + if (dis_mode == 64) { + return rex_w ? 64 : (pfx_opr ? 16 : 32); + } else if (dis_mode == 32) { + return pfx_opr ? 16 : 32; + } else { + UD_ASSERT(dis_mode == 16); + return pfx_opr ? 32 : 16; + } +} + + +static UD_INLINE int +eff_adr_mode(int dis_mode, int pfx_adr) +{ + if (dis_mode == 64) { + return pfx_adr ? 32 : 64; + } else if (dis_mode == 32) { + return pfx_adr ? 16 : 32; + } else { + UD_ASSERT(dis_mode == 16); + return pfx_adr ? 32 : 16; + } +} + + +/* + * decode_prefixes + * + * Extracts instruction prefixes. + */ +static int +decode_prefixes(struct ud *u) +{ + int done = 0; + uint8_t curr = 0, last = 0; + UD_RETURN_ON_ERROR(u); + + do { + last = curr; + curr = inp_next(u); + UD_RETURN_ON_ERROR(u); + if (u->inp_ctr == MAX_INSN_LENGTH) { + UD_RETURN_WITH_ERROR(u, "max instruction length"); + } + + switch (curr) + { + case 0x2E: + u->pfx_seg = UD_R_CS; + break; + case 0x36: + u->pfx_seg = UD_R_SS; + break; + case 0x3E: + u->pfx_seg = UD_R_DS; + break; + case 0x26: + u->pfx_seg = UD_R_ES; + break; + case 0x64: + u->pfx_seg = UD_R_FS; + break; + case 0x65: + u->pfx_seg = UD_R_GS; + break; + case 0x67: /* adress-size override prefix */ + u->pfx_adr = 0x67; + break; + case 0xF0: + u->pfx_lock = 0xF0; + break; + case 0x66: + u->pfx_opr = 0x66; + break; + case 0xF2: + u->pfx_str = 0xf2; + break; + case 0xF3: + u->pfx_str = 0xf3; + break; + default: + /* consume if rex */ + done = (u->dis_mode == 64 && (curr & 0xF0) == 0x40) ? 0 : 1; + break; + } + } while (!done); + /* rex prefixes in 64bit mode, must be the last prefix */ + if (u->dis_mode == 64 && (last & 0xF0) == 0x40) { + u->pfx_rex = last; + } + return 0; +} + + +/* + * vex_l, vex_w + * Return the vex.L and vex.W bits + */ +static UD_INLINE uint8_t +vex_l(const struct ud *u) +{ + UD_ASSERT(u->vex_op != 0); + return ((u->vex_op == 0xc4 ? u->vex_b2 : u->vex_b1) >> 2) & 1; +} + +static UD_INLINE uint8_t +vex_w(const struct ud *u) +{ + UD_ASSERT(u->vex_op != 0); + return u->vex_op == 0xc4 ? ((u->vex_b2 >> 7) & 1) : 0; +} + + +static UD_INLINE uint8_t +modrm(struct ud * u) +{ + if ( !u->have_modrm ) { + u->modrm = inp_next( u ); + u->modrm_offset = (uint8_t) (u->inp_ctr - 1); + u->have_modrm = 1; + } + return u->modrm; +} + + +static unsigned int +resolve_operand_size(const struct ud* u, ud_operand_size_t osize) +{ + switch (osize) { + case SZ_V: + return u->opr_mode; + case SZ_Z: + return u->opr_mode == 16 ? 16 : 32; + case SZ_Y: + return u->opr_mode == 16 ? 32 : u->opr_mode; + case SZ_RDQ: + return u->dis_mode == 64 ? 64 : 32; + case SZ_X: + UD_ASSERT(u->vex_op != 0); + return (P_VEXL(u->itab_entry->prefix) && vex_l(u)) ? SZ_QQ : SZ_DQ; + default: + return osize; + } +} + + +static int resolve_mnemonic( struct ud* u ) +{ + /* resolve 3dnow weirdness. */ + if ( u->mnemonic == UD_I3dnow ) { + u->mnemonic = ud_itab[ u->le->table[ inp_curr( u ) ] ].mnemonic; + } + /* SWAPGS is only valid in 64bits mode */ + if ( u->mnemonic == UD_Iswapgs && u->dis_mode != 64 ) { + UDERR(u, "swapgs invalid in 64bits mode\n"); + return -1; + } + + if (u->mnemonic == UD_Ixchg) { + if ((u->operand[0].type == UD_OP_REG && u->operand[0].base == UD_R_AX && + u->operand[1].type == UD_OP_REG && u->operand[1].base == UD_R_AX) || + (u->operand[0].type == UD_OP_REG && u->operand[0].base == UD_R_EAX && + u->operand[1].type == UD_OP_REG && u->operand[1].base == UD_R_EAX)) { + u->operand[0].type = UD_NONE; + u->operand[1].type = UD_NONE; + u->mnemonic = UD_Inop; + } + } + + if (u->mnemonic == UD_Inop && u->pfx_repe) { + u->pfx_repe = 0; + u->mnemonic = UD_Ipause; + } + return 0; +} + + +/* ----------------------------------------------------------------------------- + * decode_a()- Decodes operands of the type seg:offset + * ----------------------------------------------------------------------------- + */ +static void +decode_a(struct ud* u, struct ud_operand *op) +{ + if (u->opr_mode == 16) { + /* seg16:off16 */ + op->type = UD_OP_PTR; + op->size = 32; + op->lval.ptr.off = inp_uint16(u); + op->lval.ptr.seg = inp_uint16(u); + } else { + /* seg16:off32 */ + op->type = UD_OP_PTR; + op->size = 48; + op->lval.ptr.off = inp_uint32(u); + op->lval.ptr.seg = inp_uint16(u); + } +} + +/* ----------------------------------------------------------------------------- + * decode_gpr() - Returns decoded General Purpose Register + * ----------------------------------------------------------------------------- + */ +static enum ud_type +decode_gpr(register struct ud* u, unsigned int s, unsigned char rm) +{ + switch (s) { + case 64: + return UD_R_RAX + rm; + case 32: + return UD_R_EAX + rm; + case 16: + return UD_R_AX + rm; + case 8: + if (u->dis_mode == 64 && u->pfx_rex) { + if (rm >= 4) + return UD_R_SPL + (rm-4); + return UD_R_AL + rm; + } else return UD_R_AL + rm; + case 0: + /* invalid size in case of a decode error */ + UD_ASSERT(u->error); + return UD_NONE; + default: + UD_ASSERT(!"invalid operand size"); + return UD_NONE; + } +} + +static void +decode_reg(struct ud *u, + struct ud_operand *opr, + int type, + int num, + int size) +{ + int reg; + size = resolve_operand_size(u, size); + switch (type) { + case REGCLASS_GPR : reg = decode_gpr(u, size, num); break; + case REGCLASS_MMX : reg = UD_R_MM0 + (num & 7); break; + case REGCLASS_XMM : + reg = num + (size == SZ_QQ ? UD_R_YMM0 : UD_R_XMM0); + break; + case REGCLASS_CR : reg = UD_R_CR0 + num; break; + case REGCLASS_DB : reg = UD_R_DR0 + num; break; + case REGCLASS_SEG : { + /* + * Only 6 segment registers, anything else is an error. + */ + if ((num & 7) > 5) { + UDERR(u, "invalid segment register value\n"); + return; + } else { + reg = UD_R_ES + (num & 7); + } + break; + } + default: + UD_ASSERT(!"invalid register type"); + return; + } + opr->type = UD_OP_REG; + opr->base = reg; + opr->size = size; +} + + +/* + * decode_imm + * + * Decode Immediate values. + */ +static void +decode_imm(struct ud* u, unsigned int size, struct ud_operand *op) +{ + op->size = resolve_operand_size(u, size); + op->type = UD_OP_IMM; + + switch (op->size) { + case 8: op->lval.sbyte = inp_uint8(u); break; + case 16: op->lval.uword = inp_uint16(u); break; + case 32: op->lval.udword = inp_uint32(u); break; + case 64: op->lval.uqword = inp_uint64(u); break; + default: return; + } +} + + +/* + * decode_mem_disp + * + * Decode mem address displacement. + */ +static void +decode_mem_disp(struct ud* u, unsigned int size, struct ud_operand *op) +{ + switch (size) { + case 8: + op->offset = 8; + op->lval.ubyte = inp_uint8(u); + break; + case 16: + op->offset = 16; + op->lval.uword = inp_uint16(u); + break; + case 32: + op->offset = 32; + op->lval.udword = inp_uint32(u); + break; + case 64: + op->offset = 64; + op->lval.uqword = inp_uint64(u); + break; + default: + return; + } +} + + +/* + * decode_modrm_reg + * + * Decodes reg field of mod/rm byte + * + */ +static UD_INLINE void +decode_modrm_reg(struct ud *u, + struct ud_operand *operand, + unsigned int type, + unsigned int size) +{ + uint8_t reg = (REX_R(u->_rex) << 3) | MODRM_REG(modrm(u)); + decode_reg(u, operand, type, reg, size); +} + + +/* + * decode_modrm_rm + * + * Decodes rm field of mod/rm byte + * + */ +static void +decode_modrm_rm(struct ud *u, + struct ud_operand *op, + unsigned char type, /* register type */ + unsigned int size) /* operand size */ + +{ + size_t offset = 0; + unsigned char mod, rm; + + /* get mod, r/m and reg fields */ + mod = MODRM_MOD(modrm(u)); + rm = (REX_B(u->_rex) << 3) | MODRM_RM(modrm(u)); + + /* + * If mod is 11b, then the modrm.rm specifies a register. + * + */ + if (mod == 3) { + decode_reg(u, op, type, rm, size); + return; + } + + /* + * !11b => Memory Address + */ + op->type = UD_OP_MEM; + op->size = resolve_operand_size(u, size); + + if (u->adr_mode == 64) { + op->base = UD_R_RAX + rm; + if (mod == 1) { + offset = 8; + } else if (mod == 2) { + offset = 32; + } else if (mod == 0 && (rm & 7) == 5) { + op->base = UD_R_RIP; + offset = 32; + } else { + offset = 0; + } + /* + * Scale-Index-Base (SIB) + */ + if ((rm & 7) == 4) { + inp_next(u); + + op->base = UD_R_RAX + (SIB_B(inp_curr(u)) | (REX_B(u->_rex) << 3)); + op->index = UD_R_RAX + (SIB_I(inp_curr(u)) | (REX_X(u->_rex) << 3)); + /* special conditions for base reference */ + if (op->index == UD_R_RSP) { + op->index = UD_NONE; + op->scale = UD_NONE; + } else { + op->scale = (1 << SIB_S(inp_curr(u))) & ~1; + } + + if (op->base == UD_R_RBP || op->base == UD_R_R13) { + if (mod == 0) { + op->base = UD_NONE; + } + if (mod == 1) { + offset = 8; + } else { + offset = 32; + } + } + } else { + op->scale = UD_NONE; + op->index = UD_NONE; + } + } else if (u->adr_mode == 32) { + op->base = UD_R_EAX + rm; + if (mod == 1) { + offset = 8; + } else if (mod == 2) { + offset = 32; + } else if (mod == 0 && rm == 5) { + op->base = UD_NONE; + offset = 32; + } else { + offset = 0; + } + + /* Scale-Index-Base (SIB) */ + if ((rm & 7) == 4) { + inp_next(u); + + op->scale = (1 << SIB_S(inp_curr(u))) & ~1; + op->index = UD_R_EAX + (SIB_I(inp_curr(u)) | (REX_X(u->pfx_rex) << 3)); + op->base = UD_R_EAX + (SIB_B(inp_curr(u)) | (REX_B(u->pfx_rex) << 3)); + + if (op->index == UD_R_ESP) { + op->index = UD_NONE; + op->scale = UD_NONE; + } + + /* special condition for base reference */ + if (op->base == UD_R_EBP) { + if (mod == 0) { + op->base = UD_NONE; + } + if (mod == 1) { + offset = 8; + } else { + offset = 32; + } + } + } else { + op->scale = UD_NONE; + op->index = UD_NONE; + } + } else { + const unsigned int bases[] = { UD_R_BX, UD_R_BX, UD_R_BP, UD_R_BP, + UD_R_SI, UD_R_DI, UD_R_BP, UD_R_BX }; + const unsigned int indices[] = { UD_R_SI, UD_R_DI, UD_R_SI, UD_R_DI, + UD_NONE, UD_NONE, UD_NONE, UD_NONE }; + op->base = bases[rm & 7]; + op->index = indices[rm & 7]; + op->scale = UD_NONE; + if (mod == 0 && rm == 6) { + offset = 16; + op->base = UD_NONE; + } else if (mod == 1) { + offset = 8; + } else if (mod == 2) { + offset = 16; + } + } + + if (offset) { + decode_mem_disp(u, offset, op); + } else { + op->offset = 0; + } +} + + +/* + * decode_moffset + * Decode offset-only memory operand + */ +static void +decode_moffset(struct ud *u, unsigned int size, struct ud_operand *opr) +{ + opr->type = UD_OP_MEM; + opr->base = UD_NONE; + opr->index = UD_NONE; + opr->scale = UD_NONE; + opr->size = resolve_operand_size(u, size); + decode_mem_disp(u, u->adr_mode, opr); +} + + +static void +decode_vex_vvvv(struct ud *u, struct ud_operand *opr, unsigned size) +{ + uint8_t vvvv; + UD_ASSERT(u->vex_op != 0); + vvvv = ((u->vex_op == 0xc4 ? u->vex_b2 : u->vex_b1) >> 3) & 0xf; + decode_reg(u, opr, REGCLASS_XMM, (0xf & ~vvvv), size); +} + + +/* + * decode_vex_immreg + * Decode source operand encoded in immediate byte [7:4] + */ +static int +decode_vex_immreg(struct ud *u, struct ud_operand *opr, unsigned size) +{ + uint8_t imm = inp_next(u); + uint8_t mask = u->dis_mode == 64 ? 0xf : 0x7; + UD_RETURN_ON_ERROR(u); + UD_ASSERT(u->vex_op != 0); + decode_reg(u, opr, REGCLASS_XMM, mask & (imm >> 4), size); + return 0; +} + + +/* + * decode_operand + * + * Decodes a single operand. + * Returns the type of the operand (UD_NONE if none) + */ +static int +decode_operand(struct ud *u, + struct ud_operand *operand, + enum ud_operand_code type, + unsigned int size) +{ + operand->type = UD_NONE; + operand->_oprcode = type; + + switch (type) { + case OP_A : + decode_a(u, operand); + break; + case OP_MR: + decode_modrm_rm(u, operand, REGCLASS_GPR, + MODRM_MOD(modrm(u)) == 3 ? + Mx_reg_size(size) : Mx_mem_size(size)); + break; + case OP_F: + u->br_far = 1; + /* intended fall through */ + case OP_M: + if (MODRM_MOD(modrm(u)) == 3) { + UDERR(u, "expected modrm.mod != 3\n"); + } + /* intended fall through */ + case OP_E: + decode_modrm_rm(u, operand, REGCLASS_GPR, size); + break; + case OP_G: + decode_modrm_reg(u, operand, REGCLASS_GPR, size); + break; + case OP_sI: + case OP_I: + decode_imm(u, size, operand); + break; + case OP_I1: + operand->type = UD_OP_CONST; + operand->lval.udword = 1; + break; + case OP_N: + if (MODRM_MOD(modrm(u)) != 3) { + UDERR(u, "expected modrm.mod == 3\n"); + } + /* intended fall through */ + case OP_Q: + decode_modrm_rm(u, operand, REGCLASS_MMX, size); + break; + case OP_P: + decode_modrm_reg(u, operand, REGCLASS_MMX, size); + break; + case OP_U: + if (MODRM_MOD(modrm(u)) != 3) { + UDERR(u, "expected modrm.mod == 3\n"); + } + /* intended fall through */ + case OP_W: + decode_modrm_rm(u, operand, REGCLASS_XMM, size); + break; + case OP_V: + decode_modrm_reg(u, operand, REGCLASS_XMM, size); + break; + case OP_H: + decode_vex_vvvv(u, operand, size); + break; + case OP_MU: + decode_modrm_rm(u, operand, REGCLASS_XMM, + MODRM_MOD(modrm(u)) == 3 ? + Mx_reg_size(size) : Mx_mem_size(size)); + break; + case OP_S: + decode_modrm_reg(u, operand, REGCLASS_SEG, size); + break; + case OP_O: + decode_moffset(u, size, operand); + break; + case OP_R0: + case OP_R1: + case OP_R2: + case OP_R3: + case OP_R4: + case OP_R5: + case OP_R6: + case OP_R7: + decode_reg(u, operand, REGCLASS_GPR, + (REX_B(u->_rex) << 3) | (type - OP_R0), size); + break; + case OP_AL: + case OP_AX: + case OP_eAX: + case OP_rAX: + decode_reg(u, operand, REGCLASS_GPR, 0, size); + break; + case OP_CL: + case OP_CX: + case OP_eCX: + decode_reg(u, operand, REGCLASS_GPR, 1, size); + break; + case OP_DL: + case OP_DX: + case OP_eDX: + decode_reg(u, operand, REGCLASS_GPR, 2, size); + break; + case OP_ES: + case OP_CS: + case OP_DS: + case OP_SS: + case OP_FS: + case OP_GS: + /* in 64bits mode, only fs and gs are allowed */ + if (u->dis_mode == 64) { + if (type != OP_FS && type != OP_GS) { + UDERR(u, "invalid segment register in 64bits\n"); + } + } + operand->type = UD_OP_REG; + operand->base = (type - OP_ES) + UD_R_ES; + operand->size = 16; + break; + case OP_J : + decode_imm(u, size, operand); + operand->type = UD_OP_JIMM; + break ; + case OP_R : + if (MODRM_MOD(modrm(u)) != 3) { + UDERR(u, "expected modrm.mod == 3\n"); + } + decode_modrm_rm(u, operand, REGCLASS_GPR, size); + break; + case OP_C: + decode_modrm_reg(u, operand, REGCLASS_CR, size); + break; + case OP_D: + decode_modrm_reg(u, operand, REGCLASS_DB, size); + break; + case OP_I3 : + operand->type = UD_OP_CONST; + operand->lval.sbyte = 3; + break; + case OP_ST0: + case OP_ST1: + case OP_ST2: + case OP_ST3: + case OP_ST4: + case OP_ST5: + case OP_ST6: + case OP_ST7: + operand->type = UD_OP_REG; + operand->base = (type - OP_ST0) + UD_R_ST0; + operand->size = 80; + break; + case OP_L: + decode_vex_immreg(u, operand, size); + break; + default : + operand->type = UD_NONE; + break; + } + return operand->type; +} + + +/* + * decode_operands + * + * Disassemble upto 3 operands of the current instruction being + * disassembled. By the end of the function, the operand fields + * of the ud structure will have been filled. + */ +static int +decode_operands(struct ud* u) +{ + decode_operand(u, &u->operand[0], + u->itab_entry->operand1.type, + u->itab_entry->operand1.size); + if (u->operand[0].type != UD_NONE) { + decode_operand(u, &u->operand[1], + u->itab_entry->operand2.type, + u->itab_entry->operand2.size); + } + if (u->operand[1].type != UD_NONE) { + decode_operand(u, &u->operand[2], + u->itab_entry->operand3.type, + u->itab_entry->operand3.size); + } + if (u->operand[2].type != UD_NONE) { + decode_operand(u, &u->operand[3], + u->itab_entry->operand4.type, + u->itab_entry->operand4.size); + } + return 0; +} + +/* ----------------------------------------------------------------------------- + * clear_insn() - clear instruction structure + * ----------------------------------------------------------------------------- + */ +static void +clear_insn(register struct ud* u) +{ + u->error = 0; + u->pfx_seg = 0; + u->pfx_opr = 0; + u->pfx_adr = 0; + u->pfx_lock = 0; + u->pfx_repne = 0; + u->pfx_rep = 0; + u->pfx_repe = 0; + u->pfx_rex = 0; + u->pfx_str = 0; + u->mnemonic = UD_Inone; + u->itab_entry = NULL; + u->have_modrm = 0; + u->br_far = 0; + u->vex_op = 0; + u->_rex = 0; + u->operand[0].type = UD_NONE; + u->operand[1].type = UD_NONE; + u->operand[2].type = UD_NONE; + u->operand[3].type = UD_NONE; +} + + +static UD_INLINE int +resolve_pfx_str(struct ud* u) +{ + if (u->pfx_str == 0xf3) { + if (P_STR(u->itab_entry->prefix)) { + u->pfx_rep = 0xf3; + } else { + u->pfx_repe = 0xf3; + } + } else if (u->pfx_str == 0xf2) { + u->pfx_repne = 0xf3; + } + return 0; +} + + +static int +resolve_mode( struct ud* u ) +{ + int default64; + /* if in error state, bail out */ + if ( u->error ) return -1; + + /* propagate prefix effects */ + if ( u->dis_mode == 64 ) { /* set 64bit-mode flags */ + + /* Check validity of instruction m64 */ + if ( P_INV64( u->itab_entry->prefix ) ) { + UDERR(u, "instruction invalid in 64bits\n"); + return -1; + } + + /* compute effective rex based on, + * - vex prefix (if any) + * - rex prefix (if any, and not vex) + * - allowed prefixes specified by the opcode map + */ + if (u->vex_op == 0xc4) { + /* vex has rex.rxb in 1's complement */ + u->_rex = ((~(u->vex_b1 >> 5) & 0x7) /* rex.0rxb */ | + ((u->vex_b2 >> 4) & 0x8) /* rex.w000 */); + } else if (u->vex_op == 0xc5) { + /* vex has rex.r in 1's complement */ + u->_rex = (~(u->vex_b1 >> 5)) & 4; + } else { + UD_ASSERT(u->vex_op == 0); + u->_rex = u->pfx_rex; + } + u->_rex &= REX_PFX_MASK(u->itab_entry->prefix); + + /* whether this instruction has a default operand size of + * 64bit, also hardcoded into the opcode map. + */ + default64 = P_DEF64( u->itab_entry->prefix ); + /* calculate effective operand size */ + if (REX_W(u->_rex)) { + u->opr_mode = 64; + } else if ( u->pfx_opr ) { + u->opr_mode = 16; + } else { + /* unless the default opr size of instruction is 64, + * the effective operand size in the absence of rex.w + * prefix is 32. + */ + u->opr_mode = default64 ? 64 : 32; + } + + /* calculate effective address size */ + u->adr_mode = (u->pfx_adr) ? 32 : 64; + } else if ( u->dis_mode == 32 ) { /* set 32bit-mode flags */ + u->opr_mode = ( u->pfx_opr ) ? 16 : 32; + u->adr_mode = ( u->pfx_adr ) ? 16 : 32; + } else if ( u->dis_mode == 16 ) { /* set 16bit-mode flags */ + u->opr_mode = ( u->pfx_opr ) ? 32 : 16; + u->adr_mode = ( u->pfx_adr ) ? 32 : 16; + } + + return 0; +} + + +static UD_INLINE int +decode_insn(struct ud *u, uint16_t ptr) +{ + UD_ASSERT((ptr & 0x8000) == 0); + u->itab_entry = &ud_itab[ ptr ]; + u->mnemonic = u->itab_entry->mnemonic; + return (resolve_pfx_str(u) == 0 && + resolve_mode(u) == 0 && + decode_operands(u) == 0 && + resolve_mnemonic(u) == 0) ? 0 : -1; +} + + +/* + * decode_3dnow() + * + * Decoding 3dnow is a little tricky because of its strange opcode + * structure. The final opcode disambiguation depends on the last + * byte that comes after the operands have been decoded. Fortunately, + * all 3dnow instructions have the same set of operand types. So we + * go ahead and decode the instruction by picking an arbitrarily chosen + * valid entry in the table, decode the operands, and read the final + * byte to resolve the menmonic. + */ +static UD_INLINE int +decode_3dnow(struct ud* u) +{ + uint16_t ptr; + UD_ASSERT(u->le->type == UD_TAB__OPC_3DNOW); + UD_ASSERT(u->le->table[0xc] != 0); + decode_insn(u, u->le->table[0xc]); + inp_next(u); + if (u->error) { + return -1; + } + ptr = u->le->table[inp_curr(u)]; + UD_ASSERT((ptr & 0x8000) == 0); + u->mnemonic = ud_itab[ptr].mnemonic; + return 0; +} + + +static int +decode_ssepfx(struct ud *u) +{ + uint8_t idx; + uint8_t pfx; + + /* + * String prefixes (f2, f3) take precedence over operand + * size prefix (66). + */ + pfx = u->pfx_str; + if (pfx == 0) { + pfx = u->pfx_opr; + } + idx = ((pfx & 0xf) + 1) / 2; + if (u->le->table[idx] == 0) { + idx = 0; + } + if (idx && u->le->table[idx] != 0) { + /* + * "Consume" the prefix as a part of the opcode, so it is no + * longer exported as an instruction prefix. + */ + u->pfx_str = 0; + if (pfx == 0x66) { + /* + * consume "66" only if it was used for decoding, leaving + * it to be used as an operands size override for some + * simd instructions. + */ + u->pfx_opr = 0; + } + } + return decode_ext(u, u->le->table[idx]); +} + + +static int +decode_vex(struct ud *u) +{ + uint8_t index; + if (u->dis_mode != 64 && MODRM_MOD(inp_peek(u)) != 0x3) { + index = 0; + } else { + u->vex_op = inp_curr(u); + u->vex_b1 = inp_next(u); + if (u->vex_op == 0xc4) { + uint8_t pp, m; + /* 3-byte vex */ + u->vex_b2 = inp_next(u); + UD_RETURN_ON_ERROR(u); + m = u->vex_b1 & 0x1f; + if (m == 0 || m > 3) { + UD_RETURN_WITH_ERROR(u, "reserved vex.m-mmmm value"); + } + pp = u->vex_b2 & 0x3; + index = (pp << 2) | m; + } else { + /* 2-byte vex */ + UD_ASSERT(u->vex_op == 0xc5); + index = 0x1 | ((u->vex_b1 & 0x3) << 2); + } + } + return decode_ext(u, u->le->table[index]); +} + + +/* + * decode_ext() + * + * Decode opcode extensions (if any) + */ +static int +decode_ext(struct ud *u, uint16_t ptr) +{ + uint8_t idx = 0; + if ((ptr & 0x8000) == 0) { + return decode_insn(u, ptr); + } + u->le = &ud_lookup_table_list[(~0x8000 & ptr)]; + if (u->le->type == UD_TAB__OPC_3DNOW) { + return decode_3dnow(u); + } + + switch (u->le->type) { + case UD_TAB__OPC_MOD: + /* !11 = 0, 11 = 1 */ + idx = (MODRM_MOD(modrm(u)) + 1) / 4; + break; + /* disassembly mode/operand size/address size based tables. + * 16 = 0,, 32 = 1, 64 = 2 + */ + case UD_TAB__OPC_MODE: + idx = u->dis_mode != 64 ? 0 : 1; + break; + case UD_TAB__OPC_OSIZE: + idx = eff_opr_mode(u->dis_mode, REX_W(u->pfx_rex), u->pfx_opr) / 32; + break; + case UD_TAB__OPC_ASIZE: + idx = eff_adr_mode(u->dis_mode, u->pfx_adr) / 32; + break; + case UD_TAB__OPC_X87: + idx = modrm(u) - 0xC0; + break; + case UD_TAB__OPC_VENDOR: + if (u->vendor == UD_VENDOR_ANY) { + /* choose a valid entry */ + idx = (u->le->table[idx] != 0) ? 0 : 1; + } else if (u->vendor == UD_VENDOR_AMD) { + idx = 0; + } else { + idx = 1; + } + break; + case UD_TAB__OPC_RM: + idx = MODRM_RM(modrm(u)); + break; + case UD_TAB__OPC_REG: + idx = MODRM_REG(modrm(u)); + break; + case UD_TAB__OPC_SSE: + return decode_ssepfx(u); + case UD_TAB__OPC_VEX: + return decode_vex(u); + case UD_TAB__OPC_VEX_W: + idx = vex_w(u); + break; + case UD_TAB__OPC_VEX_L: + idx = vex_l(u); + break; + case UD_TAB__OPC_TABLE: + inp_next(u); + return decode_opcode(u); + default: + UD_ASSERT(!"not reached"); + break; + } + + return decode_ext(u, u->le->table[idx]); +} + + +static int +decode_opcode(struct ud *u) +{ + uint16_t ptr; + UD_ASSERT(u->le->type == UD_TAB__OPC_TABLE); + UD_RETURN_ON_ERROR(u); + ptr = u->le->table[inp_curr(u)]; + return decode_ext(u, ptr); +} + + +/* ============================================================================= + * ud_decode() - Instruction decoder. Returns the number of bytes decoded. + * ============================================================================= + */ +unsigned int +ud_decode(struct ud *u) +{ + inp_start(u); + clear_insn(u); + u->le = &ud_lookup_table_list[0]; + u->error = decode_prefixes(u) == -1 || + decode_opcode(u) == -1 || + u->error; + /* Handle decode error. */ + if (u->error) { + /* clear out the decode data. */ + clear_insn(u); + /* mark the sequence of bytes as invalid. */ + u->itab_entry = &ud_itab[0]; /* entry 0 is invalid */ + u->mnemonic = u->itab_entry->mnemonic; + } + + /* maybe this stray segment override byte + * should be spewed out? + */ + if ( !P_SEG( u->itab_entry->prefix ) && + u->operand[0].type != UD_OP_MEM && + u->operand[1].type != UD_OP_MEM ) + u->pfx_seg = 0; + + u->insn_offset = u->pc; /* set offset of instruction */ + u->asm_buf_fill = 0; /* set translation buffer index to 0 */ + u->pc += u->inp_ctr; /* move program counter by bytes decoded */ + + /* return number of bytes disassembled. */ + return u->inp_ctr; +} + +#endif // USE(UDIS86) + +/* +vim: set ts=2 sw=2 expandtab +*/ diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_decode.h b/Source/JavaScriptCore/disassembler/udis86/udis86_decode.h new file mode 100644 index 000000000..411c8830e --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_decode.h @@ -0,0 +1,197 @@ +/* udis86 - libudis86/decode.h + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UD_DECODE_H +#define UD_DECODE_H + +#include "udis86_types.h" +#include "udis86_udint.h" +#include "udis86_itab.h" + +#define MAX_INSN_LENGTH 15 + +/* itab prefix bits */ +#define P_none ( 0 ) + +#define P_inv64 ( 1 << 0 ) +#define P_INV64(n) ( ( n >> 0 ) & 1 ) +#define P_def64 ( 1 << 1 ) +#define P_DEF64(n) ( ( n >> 1 ) & 1 ) + +#define P_oso ( 1 << 2 ) +#define P_OSO(n) ( ( n >> 2 ) & 1 ) +#define P_aso ( 1 << 3 ) +#define P_ASO(n) ( ( n >> 3 ) & 1 ) + +#define P_rexb ( 1 << 4 ) +#define P_REXB(n) ( ( n >> 4 ) & 1 ) +#define P_rexw ( 1 << 5 ) +#define P_REXW(n) ( ( n >> 5 ) & 1 ) +#define P_rexr ( 1 << 6 ) +#define P_REXR(n) ( ( n >> 6 ) & 1 ) +#define P_rexx ( 1 << 7 ) +#define P_REXX(n) ( ( n >> 7 ) & 1 ) + +#define P_seg ( 1 << 8 ) +#define P_SEG(n) ( ( n >> 8 ) & 1 ) + +#define P_vexl ( 1 << 9 ) +#define P_VEXL(n) ( ( n >> 9 ) & 1 ) +#define P_vexw ( 1 << 10 ) +#define P_VEXW(n) ( ( n >> 10 ) & 1 ) + +#define P_str ( 1 << 11 ) +#define P_STR(n) ( ( n >> 11 ) & 1 ) +#define P_strz ( 1 << 12 ) +#define P_STR_ZF(n) ( ( n >> 12 ) & 1 ) + +/* operand type constants -- order is important! */ + +enum ud_operand_code { + OP_NONE, + + OP_A, OP_E, OP_M, OP_G, + OP_I, OP_F, + + OP_R0, OP_R1, OP_R2, OP_R3, + OP_R4, OP_R5, OP_R6, OP_R7, + + OP_AL, OP_CL, OP_DL, + OP_AX, OP_CX, OP_DX, + OP_eAX, OP_eCX, OP_eDX, + OP_rAX, OP_rCX, OP_rDX, + + OP_ES, OP_CS, OP_SS, OP_DS, + OP_FS, OP_GS, + + OP_ST0, OP_ST1, OP_ST2, OP_ST3, + OP_ST4, OP_ST5, OP_ST6, OP_ST7, + + OP_J, OP_S, OP_O, + OP_I1, OP_I3, OP_sI, + + OP_V, OP_W, OP_Q, OP_P, + OP_U, OP_N, OP_MU, OP_H, + OP_L, + + OP_R, OP_C, OP_D, + + OP_MR +} UD_ATTR_PACKED; + + +/* + * Operand size constants + * + * Symbolic constants for various operand sizes. Some of these constants + * are given a value equal to the width of the data (SZ_B == 8), such + * that they maybe used interchangeably in the internals. Modifying them + * will most certainly break things! + */ +typedef uint16_t ud_operand_size_t; + +#define SZ_NA 0 +#define SZ_Z 1 +#define SZ_V 2 +#define SZ_Y 3 +#define SZ_X 4 +#define SZ_RDQ 7 +#define SZ_B 8 +#define SZ_W 16 +#define SZ_D 32 +#define SZ_Q 64 +#define SZ_T 80 +#define SZ_O 12 +#define SZ_DQ 128 /* double quad */ +#define SZ_QQ 256 /* quad quad */ + +/* + * Complex size types; that encode sizes for operands of type MR (memory or + * register); for internal use only. Id space above 256. + */ +#define SZ_BD ((SZ_B << 8) | SZ_D) +#define SZ_BV ((SZ_B << 8) | SZ_V) +#define SZ_WD ((SZ_W << 8) | SZ_D) +#define SZ_WV ((SZ_W << 8) | SZ_V) +#define SZ_WY ((SZ_W << 8) | SZ_Y) +#define SZ_DY ((SZ_D << 8) | SZ_Y) +#define SZ_WO ((SZ_W << 8) | SZ_O) +#define SZ_DO ((SZ_D << 8) | SZ_O) +#define SZ_QO ((SZ_Q << 8) | SZ_O) + + +/* resolve complex size type. + */ +static UD_INLINE ud_operand_size_t +Mx_mem_size(ud_operand_size_t size) +{ + return (size >> 8) & 0xff; +} + +static UD_INLINE ud_operand_size_t +Mx_reg_size(ud_operand_size_t size) +{ + return size & 0xff; +} + +/* A single operand of an entry in the instruction table. + * (internal use only) + */ +struct ud_itab_entry_operand +{ + enum ud_operand_code type; + ud_operand_size_t size; +}; + + +/* A single entry in an instruction table. + *(internal use only) + */ +struct ud_itab_entry +{ + enum ud_mnemonic_code mnemonic; + struct ud_itab_entry_operand operand1; + struct ud_itab_entry_operand operand2; + struct ud_itab_entry_operand operand3; + struct ud_itab_entry_operand operand4; + uint32_t prefix; +}; + +struct ud_lookup_table_list_entry { + const uint16_t *table; + enum ud_table_type type; + const char *meta; +}; + +extern struct ud_itab_entry ud_itab[]; +extern struct ud_lookup_table_list_entry ud_lookup_table_list[]; + +#endif /* UD_DECODE_H */ + +/* vim:cindent + * vim:expandtab + * vim:ts=4 + * vim:sw=4 + */ diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_extern.h b/Source/JavaScriptCore/disassembler/udis86/udis86_extern.h new file mode 100644 index 000000000..bf3314d09 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_extern.h @@ -0,0 +1,113 @@ +/* udis86 - libudis86/extern.h + * + * Copyright (c) 2002-2009, 2013 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UD_EXTERN_H +#define UD_EXTERN_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "udis86_types.h" + +#if defined(_MSC_VER) && defined(_USRDLL) +# ifdef LIBUDIS86_EXPORTS +# define LIBUDIS86_DLLEXTERN __declspec(dllexport) +# else +# define LIBUDIS86_DLLEXTERN __declspec(dllimport) +# endif +#else +# define LIBUDIS86_DLLEXTERN +#endif + +/* ============================= PUBLIC API ================================= */ + +extern LIBUDIS86_DLLEXTERN void ud_init(struct ud*); + +extern LIBUDIS86_DLLEXTERN void ud_set_mode(struct ud*, uint8_t); + +extern LIBUDIS86_DLLEXTERN void ud_set_pc(struct ud*, uint64_t); + +extern LIBUDIS86_DLLEXTERN void ud_set_input_hook(struct ud*, int (*)(struct ud*)); + +extern LIBUDIS86_DLLEXTERN void ud_set_input_buffer(struct ud*, const uint8_t*, size_t); + +#ifndef __UD_STANDALONE__ +extern LIBUDIS86_DLLEXTERN void ud_set_input_file(struct ud*, FILE*); +#endif /* __UD_STANDALONE__ */ + +extern LIBUDIS86_DLLEXTERN void ud_set_vendor(struct ud*, unsigned); + +extern LIBUDIS86_DLLEXTERN void ud_set_syntax(struct ud*, void (*)(struct ud*)); + +extern LIBUDIS86_DLLEXTERN void ud_input_skip(struct ud*, size_t); + +extern LIBUDIS86_DLLEXTERN int ud_input_end(const struct ud*); + +extern LIBUDIS86_DLLEXTERN unsigned int ud_decode(struct ud*); + +extern LIBUDIS86_DLLEXTERN unsigned int ud_disassemble(struct ud*); + +extern LIBUDIS86_DLLEXTERN void ud_translate_intel(struct ud*); + +extern LIBUDIS86_DLLEXTERN void ud_translate_att(struct ud*); + +extern LIBUDIS86_DLLEXTERN const char* ud_insn_asm(const struct ud* u); + +extern LIBUDIS86_DLLEXTERN const uint8_t* ud_insn_ptr(const struct ud* u); + +extern LIBUDIS86_DLLEXTERN uint64_t ud_insn_off(const struct ud*); + +extern LIBUDIS86_DLLEXTERN const char* ud_insn_hex(struct ud*); + +extern LIBUDIS86_DLLEXTERN unsigned int ud_insn_len(const struct ud* u); + +extern LIBUDIS86_DLLEXTERN const struct ud_operand* ud_insn_opr(const struct ud *u, unsigned int n); + +extern LIBUDIS86_DLLEXTERN int ud_opr_is_sreg(const struct ud_operand *opr); + +extern LIBUDIS86_DLLEXTERN int ud_opr_is_gpr(const struct ud_operand *opr); + +extern LIBUDIS86_DLLEXTERN enum ud_mnemonic_code ud_insn_mnemonic(const struct ud *u); + +extern LIBUDIS86_DLLEXTERN const char* ud_lookup_mnemonic(enum ud_mnemonic_code c); + +extern LIBUDIS86_DLLEXTERN void ud_set_user_opaque_data(struct ud*, void*); + +extern LIBUDIS86_DLLEXTERN void* ud_get_user_opaque_data(const struct ud*); + +extern LIBUDIS86_DLLEXTERN void ud_set_asm_buffer(struct ud *u, char *buf, size_t size); + +extern LIBUDIS86_DLLEXTERN void ud_set_sym_resolver(struct ud *u, + const char* (*resolver)(struct ud*, + uint64_t addr, + int64_t *offset)); + +/* ========================================================================== */ + +#ifdef __cplusplus +} +#endif +#endif /* UD_EXTERN_H */ diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_itab_holder.c b/Source/JavaScriptCore/disassembler/udis86/udis86_itab_holder.c new file mode 100644 index 000000000..80dda3a19 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_itab_holder.c @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2012 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if USE(UDIS86) + +#include "udis86_itab.c" + +#endif + diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_syn-att.c b/Source/JavaScriptCore/disassembler/udis86/udis86_syn-att.c new file mode 100644 index 000000000..7d5646e4a --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_syn-att.c @@ -0,0 +1,235 @@ +/* udis86 - libudis86/syn-att.c + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if USE(UDIS86) + +#include "udis86_types.h" +#include "udis86_extern.h" +#include "udis86_decode.h" +#include "udis86_itab.h" +#include "udis86_syn.h" +#include "udis86_udint.h" + +/* ----------------------------------------------------------------------------- + * opr_cast() - Prints an operand cast. + * ----------------------------------------------------------------------------- + */ +static void +opr_cast(struct ud* u, struct ud_operand* op) +{ + switch(op->size) { + case 16 : case 32 : + ud_asmprintf(u, "*"); break; + default: break; + } +} + +/* ----------------------------------------------------------------------------- + * gen_operand() - Generates assembly output for each operand. + * ----------------------------------------------------------------------------- + */ +static void +gen_operand(struct ud* u, struct ud_operand* op) +{ + switch(op->type) { + case UD_OP_CONST: + ud_asmprintf(u, "$0x%x", op->lval.udword); + break; + + case UD_OP_REG: + ud_asmprintf(u, "%%%s", ud_reg_tab[op->base - UD_R_AL]); + break; + + case UD_OP_MEM: + if (u->br_far) { + opr_cast(u, op); + } + if (u->pfx_seg) { + ud_asmprintf(u, "%%%s:", ud_reg_tab[u->pfx_seg - UD_R_AL]); + } + if (op->offset != 0) { + ud_syn_print_mem_disp(u, op, 0); + } + if (op->base) { + ud_asmprintf(u, "(%%%s", ud_reg_tab[op->base - UD_R_AL]); + } + if (op->index) { + if (op->base) { + ud_asmprintf(u, ","); + } else { + ud_asmprintf(u, "("); + } + ud_asmprintf(u, "%%%s", ud_reg_tab[op->index - UD_R_AL]); + } + if (op->scale) { + ud_asmprintf(u, ",%d", op->scale); + } + if (op->base || op->index) { + ud_asmprintf(u, ")"); + } + break; + + case UD_OP_IMM: + ud_asmprintf(u, "$"); + ud_syn_print_imm(u, op); + break; + + case UD_OP_JIMM: + ud_syn_print_addr(u, ud_syn_rel_target(u, op)); + break; + + case UD_OP_PTR: + switch (op->size) { + case 32: + ud_asmprintf(u, "$0x%x, $0x%x", op->lval.ptr.seg, + op->lval.ptr.off & 0xFFFF); + break; + case 48: + ud_asmprintf(u, "$0x%x, $0x%x", op->lval.ptr.seg, + op->lval.ptr.off); + break; + } + break; + + default: return; + } +} + +/* ============================================================================= + * translates to AT&T syntax + * ============================================================================= + */ +extern void +ud_translate_att(struct ud *u) +{ + int size = 0; + int star = 0; + + /* check if P_OSO prefix is used */ + if (! P_OSO(u->itab_entry->prefix) && u->pfx_opr) { + switch (u->dis_mode) { + case 16: + ud_asmprintf(u, "o32 "); + break; + case 32: + case 64: + ud_asmprintf(u, "o16 "); + break; + } + } + + /* check if P_ASO prefix was used */ + if (! P_ASO(u->itab_entry->prefix) && u->pfx_adr) { + switch (u->dis_mode) { + case 16: + ud_asmprintf(u, "a32 "); + break; + case 32: + ud_asmprintf(u, "a16 "); + break; + case 64: + ud_asmprintf(u, "a32 "); + break; + } + } + + if (u->pfx_lock) + ud_asmprintf(u, "lock "); + if (u->pfx_rep) { + ud_asmprintf(u, "rep "); + } else if (u->pfx_repe) { + ud_asmprintf(u, "repe "); + } else if (u->pfx_repne) { + ud_asmprintf(u, "repne "); + } + + /* special instructions */ + switch (u->mnemonic) { + case UD_Iretf: + ud_asmprintf(u, "lret "); + break; + case UD_Idb: + ud_asmprintf(u, ".byte 0x%x", u->operand[0].lval.ubyte); + return; + case UD_Ijmp: + case UD_Icall: + if (u->br_far) ud_asmprintf(u, "l"); + if (u->operand[0].type == UD_OP_REG) { + star = 1; + } + ud_asmprintf(u, "%s", ud_lookup_mnemonic(u->mnemonic)); + break; + case UD_Ibound: + case UD_Ienter: + if (u->operand[0].type != UD_NONE) + gen_operand(u, &u->operand[0]); + if (u->operand[1].type != UD_NONE) { + ud_asmprintf(u, ","); + gen_operand(u, &u->operand[1]); + } + return; + default: + ud_asmprintf(u, "%s", ud_lookup_mnemonic(u->mnemonic)); + } + + if (size == 8) { + ud_asmprintf(u, "b"); + } else if (size == 16) { + ud_asmprintf(u, "w"); + } else if (size == 64) { + ud_asmprintf(u, "q"); + } + + if (star) { + ud_asmprintf(u, " *"); + } else { + ud_asmprintf(u, " "); + } + + if (u->operand[3].type != UD_NONE) { + gen_operand(u, &u->operand[3]); + ud_asmprintf(u, ", "); + } + if (u->operand[2].type != UD_NONE) { + gen_operand(u, &u->operand[2]); + ud_asmprintf(u, ", "); + } + if (u->operand[1].type != UD_NONE) { + gen_operand(u, &u->operand[1]); + ud_asmprintf(u, ", "); + } + if (u->operand[0].type != UD_NONE) { + gen_operand(u, &u->operand[0]); + } +} + +#endif // USE(UDIS86) + +/* +vim: set ts=2 sw=2 expandtab +*/ diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_syn-intel.c b/Source/JavaScriptCore/disassembler/udis86/udis86_syn-intel.c new file mode 100644 index 000000000..769df8901 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_syn-intel.c @@ -0,0 +1,231 @@ +/* udis86 - libudis86/syn-intel.c + * + * Copyright (c) 2002-2013 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if USE(UDIS86) + +#include "udis86_types.h" +#include "udis86_extern.h" +#include "udis86_decode.h" +#include "udis86_itab.h" +#include "udis86_syn.h" +#include "udis86_udint.h" + +/* ----------------------------------------------------------------------------- + * opr_cast() - Prints an operand cast. + * ----------------------------------------------------------------------------- + */ +static void +opr_cast(struct ud* u, struct ud_operand* op) +{ + if (u->br_far) { + ud_asmprintf(u, "far "); + } + switch(op->size) { + case 8: ud_asmprintf(u, "byte " ); break; + case 16: ud_asmprintf(u, "word " ); break; + case 32: ud_asmprintf(u, "dword "); break; + case 64: ud_asmprintf(u, "qword "); break; + case 80: ud_asmprintf(u, "tword "); break; + case 128: ud_asmprintf(u, "oword "); break; + case 256: ud_asmprintf(u, "yword "); break; + default: break; + } +} + +/* ----------------------------------------------------------------------------- + * gen_operand() - Generates assembly output for each operand. + * ----------------------------------------------------------------------------- + */ +static void gen_operand(struct ud* u, struct ud_operand* op, int syn_cast) +{ + switch(op->type) { + case UD_OP_REG: + ud_asmprintf(u, "%s", ud_reg_tab[op->base - UD_R_AL]); + break; + + case UD_OP_MEM: + if (syn_cast) { + opr_cast(u, op); + } + ud_asmprintf(u, "["); + if (u->pfx_seg) { + ud_asmprintf(u, "%s:", ud_reg_tab[u->pfx_seg - UD_R_AL]); + } + if (op->base) { + ud_asmprintf(u, "%s", ud_reg_tab[op->base - UD_R_AL]); + } + if (op->index) { + ud_asmprintf(u, "%s%s", op->base != UD_NONE? "+" : "", + ud_reg_tab[op->index - UD_R_AL]); + if (op->scale) { + ud_asmprintf(u, "*%d", op->scale); + } + } + if (op->offset != 0) { + ud_syn_print_mem_disp(u, op, (op->base != UD_NONE || + op->index != UD_NONE) ? 1 : 0); + } + ud_asmprintf(u, "]"); + break; + + case UD_OP_IMM: + ud_syn_print_imm(u, op); + break; + + + case UD_OP_JIMM: + ud_syn_print_addr(u, ud_syn_rel_target(u, op)); + break; + + case UD_OP_PTR: + switch (op->size) { + case 32: + ud_asmprintf(u, "word 0x%x:0x%x", op->lval.ptr.seg, + op->lval.ptr.off & 0xFFFF); + break; + case 48: + ud_asmprintf(u, "dword 0x%x:0x%x", op->lval.ptr.seg, + op->lval.ptr.off); + break; + } + break; + + case UD_OP_CONST: + if (syn_cast) opr_cast(u, op); + ud_asmprintf(u, "%d", op->lval.udword); + break; + + default: return; + } +} + +/* ============================================================================= + * translates to intel syntax + * ============================================================================= + */ +extern void +ud_translate_intel(struct ud* u) +{ + /* check if P_OSO prefix is used */ + if (!P_OSO(u->itab_entry->prefix) && u->pfx_opr) { + switch (u->dis_mode) { + case 16: ud_asmprintf(u, "o32 "); break; + case 32: + case 64: ud_asmprintf(u, "o16 "); break; + } + } + + /* check if P_ASO prefix was used */ + if (!P_ASO(u->itab_entry->prefix) && u->pfx_adr) { + switch (u->dis_mode) { + case 16: ud_asmprintf(u, "a32 "); break; + case 32: ud_asmprintf(u, "a16 "); break; + case 64: ud_asmprintf(u, "a32 "); break; + } + } + + if (u->pfx_seg && + u->operand[0].type != UD_OP_MEM && + u->operand[1].type != UD_OP_MEM ) { + ud_asmprintf(u, "%s ", ud_reg_tab[u->pfx_seg - UD_R_AL]); + } + + if (u->pfx_lock) { + ud_asmprintf(u, "lock "); + } + if (u->pfx_rep) { + ud_asmprintf(u, "rep "); + } else if (u->pfx_repe) { + ud_asmprintf(u, "repe "); + } else if (u->pfx_repne) { + ud_asmprintf(u, "repne "); + } + + /* print the instruction mnemonic */ + ud_asmprintf(u, "%s", ud_lookup_mnemonic(u->mnemonic)); + + if (u->operand[0].type != UD_NONE) { + int cast = 0; + ud_asmprintf(u, " "); + if (u->operand[0].type == UD_OP_MEM) { + if (u->operand[1].type == UD_OP_IMM || + u->operand[1].type == UD_OP_CONST || + u->operand[1].type == UD_NONE || + (u->operand[0].size != u->operand[1].size)) { + cast = 1; + } else if (u->operand[1].type == UD_OP_REG && + u->operand[1].base == UD_R_CL) { + switch (u->mnemonic) { + case UD_Ircl: + case UD_Irol: + case UD_Iror: + case UD_Ircr: + case UD_Ishl: + case UD_Ishr: + case UD_Isar: + cast = 1; + break; + default: break; + } + } + } + gen_operand(u, &u->operand[0], cast); + } + + if (u->operand[1].type != UD_NONE) { + int cast = 0; + ud_asmprintf(u, ", "); + if (u->operand[1].type == UD_OP_MEM && + u->operand[0].size != u->operand[1].size && + !ud_opr_is_sreg(&u->operand[0])) { + cast = 1; + } + gen_operand(u, &u->operand[1], cast); + } + + if (u->operand[2].type != UD_NONE) { + int cast = 0; + ud_asmprintf(u, ", "); + if (u->operand[2].type == UD_OP_MEM && + u->operand[2].size != u->operand[1].size) { + cast = 1; + } + gen_operand(u, &u->operand[2], cast); + } + + if (u->operand[3].type != UD_NONE) { + ud_asmprintf(u, ", "); + gen_operand(u, &u->operand[3], 0); + } +} + +#endif // USE(UDIS86) + +/* +vim: set ts=2 sw=2 expandtab +*/ diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_syn.c b/Source/JavaScriptCore/disassembler/udis86/udis86_syn.c new file mode 100644 index 000000000..4417d9997 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_syn.c @@ -0,0 +1,219 @@ +/* udis86 - libudis86/syn.c + * + * Copyright (c) 2002-2013 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if USE(UDIS86) + +#include "udis86_types.h" +#include "udis86_decode.h" +#include "udis86_syn.h" +#include "udis86_udint.h" + +/* + * Register Table - Order Matters (types.h)! + * + */ +const char* ud_reg_tab[] = +{ + "al", "cl", "dl", "bl", + "ah", "ch", "dh", "bh", + "spl", "bpl", "sil", "dil", + "r8b", "r9b", "r10b", "r11b", + "r12b", "r13b", "r14b", "r15b", + + "ax", "cx", "dx", "bx", + "sp", "bp", "si", "di", + "r8w", "r9w", "r10w", "r11w", + "r12w", "r13w", "r14w", "r15w", + + "eax", "ecx", "edx", "ebx", + "esp", "ebp", "esi", "edi", + "r8d", "r9d", "r10d", "r11d", + "r12d", "r13d", "r14d", "r15d", + + "rax", "rcx", "rdx", "rbx", + "rsp", "rbp", "rsi", "rdi", + "r8", "r9", "r10", "r11", + "r12", "r13", "r14", "r15", + + "es", "cs", "ss", "ds", + "fs", "gs", + + "cr0", "cr1", "cr2", "cr3", + "cr4", "cr5", "cr6", "cr7", + "cr8", "cr9", "cr10", "cr11", + "cr12", "cr13", "cr14", "cr15", + + "dr0", "dr1", "dr2", "dr3", + "dr4", "dr5", "dr6", "dr7", + "dr8", "dr9", "dr10", "dr11", + "dr12", "dr13", "dr14", "dr15", + + "mm0", "mm1", "mm2", "mm3", + "mm4", "mm5", "mm6", "mm7", + + "st0", "st1", "st2", "st3", + "st4", "st5", "st6", "st7", + + "xmm0", "xmm1", "xmm2", "xmm3", + "xmm4", "xmm5", "xmm6", "xmm7", + "xmm8", "xmm9", "xmm10", "xmm11", + "xmm12", "xmm13", "xmm14", "xmm15", + + "ymm0", "ymm1", "ymm2", "ymm3", + "ymm4", "ymm5", "ymm6", "ymm7", + "ymm8", "ymm9", "ymm10", "ymm11", + "ymm12", "ymm13", "ymm14", "ymm15", + + "rip" +}; + + +uint64_t +ud_syn_rel_target(struct ud *u, struct ud_operand *opr) +{ + const uint64_t trunc_mask = 0xffffffffffffffffull >> (64 - u->opr_mode); + switch (opr->size) { + case 8 : return (u->pc + opr->lval.sbyte) & trunc_mask; + case 16: return (u->pc + opr->lval.sword) & trunc_mask; + case 32: return (u->pc + opr->lval.sdword) & trunc_mask; + default: UD_ASSERT(!"invalid relative offset size."); + return 0ull; + } +} + + +/* + * asmprintf + * Printf style function for printing translated assembly + * output. Returns the number of characters written and + * moves the buffer pointer forward. On an overflow, + * returns a negative number and truncates the output. + */ +int +ud_asmprintf(struct ud *u, const char *fmt, ...) +{ + int ret; + int avail; + va_list ap; + va_start(ap, fmt); + avail = u->asm_buf_size - u->asm_buf_fill - 1 /* nullchar */; + ret = vsnprintf((char*) u->asm_buf + u->asm_buf_fill, avail, fmt, ap); + if (ret < 0 || ret > avail) { + u->asm_buf_fill = u->asm_buf_size - 1; + } else { + u->asm_buf_fill += ret; + } + va_end(ap); + return ret; +} + + +void +ud_syn_print_addr(struct ud *u, uint64_t addr) +{ + const char *name = NULL; + if (u->sym_resolver) { + int64_t offset = 0; + name = u->sym_resolver(u, addr, &offset); + if (name) { + if (offset) { + ud_asmprintf(u, "%s%+" FMT64 "d", name, offset); + } else { + ud_asmprintf(u, "%s", name); + } + return; + } + } + ud_asmprintf(u, "0x%" FMT64 "x", addr); +} + + +void +ud_syn_print_imm(struct ud* u, const struct ud_operand *op) +{ + uint64_t v; + if (op->_oprcode == OP_sI && op->size != u->opr_mode) { + if (op->size == 8) { + v = (int64_t)op->lval.sbyte; + } else { + UD_ASSERT(op->size == 32); + v = (int64_t)op->lval.sdword; + } + if (u->opr_mode < 64) { + v = v & ((1ull << u->opr_mode) - 1ull); + } + } else { + switch (op->size) { + case 8 : v = op->lval.ubyte; break; + case 16: v = op->lval.uword; break; + case 32: v = op->lval.udword; break; + case 64: v = op->lval.uqword; break; + default: UD_ASSERT(!"invalid offset"); v = 0; /* keep cc happy */ + } + } + ud_asmprintf(u, "0x%" FMT64 "x", v); +} + + +void +ud_syn_print_mem_disp(struct ud* u, const struct ud_operand *op, int sign) +{ + UD_ASSERT(op->offset != 0); + if (op->base == UD_NONE && op->index == UD_NONE) { + uint64_t v; + UD_ASSERT(op->scale == UD_NONE && op->offset != 8); + /* unsigned mem-offset */ + switch (op->offset) { + case 16: v = op->lval.uword; break; + case 32: v = op->lval.udword; break; + case 64: v = op->lval.uqword; break; + default: UD_ASSERT(!"invalid offset"); v = 0; /* keep cc happy */ + } + ud_asmprintf(u, "0x%" FMT64 "x", v); + } else { + int64_t v; + UD_ASSERT(op->offset != 64); + switch (op->offset) { + case 8 : v = op->lval.sbyte; break; + case 16: v = op->lval.sword; break; + case 32: v = op->lval.sdword; break; + default: UD_ASSERT(!"invalid offset"); v = 0; /* keep cc happy */ + } + if (v < 0) { + ud_asmprintf(u, "-0x%" FMT64 "x", -v); + } else if (v > 0) { + ud_asmprintf(u, "%s0x%" FMT64 "x", sign? "+" : "", v); + } + } +} + +#endif // USE(UDIS86) + +/* +vim: set ts=2 sw=2 expandtab +*/ diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_syn.h b/Source/JavaScriptCore/disassembler/udis86/udis86_syn.h new file mode 100644 index 000000000..712ec37ae --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_syn.h @@ -0,0 +1,53 @@ +/* udis86 - libudis86/syn.h + * + * Copyright (c) 2002-2009 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UD_SYN_H +#define UD_SYN_H + +#include "udis86_types.h" +#ifndef __UD_STANDALONE__ +# include +#endif /* __UD_STANDALONE__ */ + +extern const char* ud_reg_tab[]; + +uint64_t ud_syn_rel_target(struct ud*, struct ud_operand*); + +#ifdef __GNUC__ +int ud_asmprintf(struct ud *u, const char *fmt, ...) + __attribute__ ((format (printf, 2, 3))); +#else +int ud_asmprintf(struct ud *u, const char *fmt, ...); +#endif + +void ud_syn_print_addr(struct ud *u, uint64_t addr); +void ud_syn_print_imm(struct ud* u, const struct ud_operand *op); +void ud_syn_print_mem_disp(struct ud* u, const struct ud_operand *, int sign); + +#endif /* UD_SYN_H */ + +/* +vim: set ts=2 sw=2 expandtab +*/ diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_types.h b/Source/JavaScriptCore/disassembler/udis86/udis86_types.h new file mode 100644 index 000000000..604f08e51 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_types.h @@ -0,0 +1,260 @@ +/* udis86 - libudis86/types.h + * + * Copyright (c) 2002-2013 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UD_TYPES_H +#define UD_TYPES_H + +#ifdef __KERNEL__ + /* + * -D__KERNEL__ is automatically passed on the command line when + * building something as part of the Linux kernel. Assume standalone + * mode. + */ +# include +# include +# ifndef __UD_STANDALONE__ +# define __UD_STANDALONE__ 1 +# endif +#endif /* __KERNEL__ */ + +#if !defined(__UD_STANDALONE__) +# include +# include +#endif + +/* gcc specific extensions */ +#ifdef __GNUC__ +# define UD_ATTR_PACKED __attribute__((packed)) +#else +# define UD_ATTR_PACKED +#endif /* UD_ATTR_PACKED */ + + +/* ----------------------------------------------------------------------------- + * All possible "types" of objects in udis86. Order is Important! + * ----------------------------------------------------------------------------- + */ +enum ud_type +{ + UD_NONE, + + /* 8 bit GPRs */ + UD_R_AL, UD_R_CL, UD_R_DL, UD_R_BL, + UD_R_AH, UD_R_CH, UD_R_DH, UD_R_BH, + UD_R_SPL, UD_R_BPL, UD_R_SIL, UD_R_DIL, + UD_R_R8B, UD_R_R9B, UD_R_R10B, UD_R_R11B, + UD_R_R12B, UD_R_R13B, UD_R_R14B, UD_R_R15B, + + /* 16 bit GPRs */ + UD_R_AX, UD_R_CX, UD_R_DX, UD_R_BX, + UD_R_SP, UD_R_BP, UD_R_SI, UD_R_DI, + UD_R_R8W, UD_R_R9W, UD_R_R10W, UD_R_R11W, + UD_R_R12W, UD_R_R13W, UD_R_R14W, UD_R_R15W, + + /* 32 bit GPRs */ + UD_R_EAX, UD_R_ECX, UD_R_EDX, UD_R_EBX, + UD_R_ESP, UD_R_EBP, UD_R_ESI, UD_R_EDI, + UD_R_R8D, UD_R_R9D, UD_R_R10D, UD_R_R11D, + UD_R_R12D, UD_R_R13D, UD_R_R14D, UD_R_R15D, + + /* 64 bit GPRs */ + UD_R_RAX, UD_R_RCX, UD_R_RDX, UD_R_RBX, + UD_R_RSP, UD_R_RBP, UD_R_RSI, UD_R_RDI, + UD_R_R8, UD_R_R9, UD_R_R10, UD_R_R11, + UD_R_R12, UD_R_R13, UD_R_R14, UD_R_R15, + + /* segment registers */ + UD_R_ES, UD_R_CS, UD_R_SS, UD_R_DS, + UD_R_FS, UD_R_GS, + + /* control registers*/ + UD_R_CR0, UD_R_CR1, UD_R_CR2, UD_R_CR3, + UD_R_CR4, UD_R_CR5, UD_R_CR6, UD_R_CR7, + UD_R_CR8, UD_R_CR9, UD_R_CR10, UD_R_CR11, + UD_R_CR12, UD_R_CR13, UD_R_CR14, UD_R_CR15, + + /* debug registers */ + UD_R_DR0, UD_R_DR1, UD_R_DR2, UD_R_DR3, + UD_R_DR4, UD_R_DR5, UD_R_DR6, UD_R_DR7, + UD_R_DR8, UD_R_DR9, UD_R_DR10, UD_R_DR11, + UD_R_DR12, UD_R_DR13, UD_R_DR14, UD_R_DR15, + + /* mmx registers */ + UD_R_MM0, UD_R_MM1, UD_R_MM2, UD_R_MM3, + UD_R_MM4, UD_R_MM5, UD_R_MM6, UD_R_MM7, + + /* x87 registers */ + UD_R_ST0, UD_R_ST1, UD_R_ST2, UD_R_ST3, + UD_R_ST4, UD_R_ST5, UD_R_ST6, UD_R_ST7, + + /* extended multimedia registers */ + UD_R_XMM0, UD_R_XMM1, UD_R_XMM2, UD_R_XMM3, + UD_R_XMM4, UD_R_XMM5, UD_R_XMM6, UD_R_XMM7, + UD_R_XMM8, UD_R_XMM9, UD_R_XMM10, UD_R_XMM11, + UD_R_XMM12, UD_R_XMM13, UD_R_XMM14, UD_R_XMM15, + + /* 256B multimedia registers */ + UD_R_YMM0, UD_R_YMM1, UD_R_YMM2, UD_R_YMM3, + UD_R_YMM4, UD_R_YMM5, UD_R_YMM6, UD_R_YMM7, + UD_R_YMM8, UD_R_YMM9, UD_R_YMM10, UD_R_YMM11, + UD_R_YMM12, UD_R_YMM13, UD_R_YMM14, UD_R_YMM15, + + UD_R_RIP, + + /* Operand Types */ + UD_OP_REG, UD_OP_MEM, UD_OP_PTR, UD_OP_IMM, + UD_OP_JIMM, UD_OP_CONST +}; + +#include "udis86_itab.h" + +union ud_lval { + int8_t sbyte; + uint8_t ubyte; + int16_t sword; + uint16_t uword; + int32_t sdword; + uint32_t udword; + int64_t sqword; + uint64_t uqword; + struct { + uint16_t seg; + uint32_t off; + } ptr; +}; + +/* ----------------------------------------------------------------------------- + * struct ud_operand - Disassembled instruction Operand. + * ----------------------------------------------------------------------------- + */ +struct ud_operand { + enum ud_type type; + uint16_t size; + enum ud_type base; + enum ud_type index; + uint8_t scale; + uint8_t offset; + union ud_lval lval; + /* + * internal use only + */ + uint64_t _legacy; /* this will be removed in 1.8 */ + uint8_t _oprcode; +}; + +/* ----------------------------------------------------------------------------- + * struct ud - The udis86 object. + * ----------------------------------------------------------------------------- + */ +struct ud +{ + /* + * input buffering + */ + int (*inp_hook) (struct ud*); +#ifndef __UD_STANDALONE__ + FILE* inp_file; +#endif + const uint8_t* inp_buf; + size_t inp_buf_size; + size_t inp_buf_index; + uint8_t inp_curr; + size_t inp_ctr; + uint8_t inp_sess[64]; + int inp_end; + int inp_peek; + + void (*translator)(struct ud*); + uint64_t insn_offset; + char insn_hexcode[64]; + + /* + * Assembly output buffer + */ + char *asm_buf; + size_t asm_buf_size; + size_t asm_buf_fill; + char asm_buf_int[128]; + + /* + * Symbol resolver for use in the translation phase. + */ + const char* (*sym_resolver)(struct ud*, uint64_t addr, int64_t *offset); + + uint8_t dis_mode; + uint64_t pc; + uint8_t vendor; + enum ud_mnemonic_code mnemonic; + struct ud_operand operand[4]; + uint8_t error; + uint8_t _rex; + uint8_t pfx_rex; + uint8_t pfx_seg; + uint8_t pfx_opr; + uint8_t pfx_adr; + uint8_t pfx_lock; + uint8_t pfx_str; + uint8_t pfx_rep; + uint8_t pfx_repe; + uint8_t pfx_repne; + uint8_t opr_mode; + uint8_t adr_mode; + uint8_t br_far; + uint8_t br_near; + uint8_t have_modrm; + uint8_t modrm; + uint8_t modrm_offset; + uint8_t vex_op; + uint8_t vex_b1; + uint8_t vex_b2; + uint8_t primary_opcode; + void * user_opaque_data; + struct ud_itab_entry * itab_entry; + struct ud_lookup_table_list_entry *le; +}; + +/* ----------------------------------------------------------------------------- + * Type-definitions + * ----------------------------------------------------------------------------- + */ +typedef enum ud_type ud_type_t; +typedef enum ud_mnemonic_code ud_mnemonic_code_t; + +typedef struct ud ud_t; +typedef struct ud_operand ud_operand_t; + +#define UD_SYN_INTEL ud_translate_intel +#define UD_SYN_ATT ud_translate_att +#define UD_EOI (-1) +#define UD_INP_CACHE_SZ 32 +#define UD_VENDOR_AMD 0 +#define UD_VENDOR_INTEL 1 +#define UD_VENDOR_ANY 2 + +#endif + +/* +vim: set ts=2 sw=2 expandtab +*/ diff --git a/Source/JavaScriptCore/disassembler/udis86/udis86_udint.h b/Source/JavaScriptCore/disassembler/udis86/udis86_udint.h new file mode 100644 index 000000000..d166b9173 --- /dev/null +++ b/Source/JavaScriptCore/disassembler/udis86/udis86_udint.h @@ -0,0 +1,98 @@ +/* udis86 - libudis86/udint.h -- definitions for internal use only + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef _UDINT_H_ +#define _UDINT_H_ + +#include "udis86_types.h" + +#ifdef HAVE_CONFIG_H +# include +#endif /* HAVE_CONFIG_H */ + +#if defined(UD_DEBUG) && HAVE_ASSERT_H +# define UD_ASSERT(_x) ASSERT(_x) +#else +# define UD_ASSERT(_x) +#endif /* !HAVE_ASSERT_H */ + +#if defined(UD_DEBUG) + #define UDERR(u, msg) \ + do { \ + (u)->error = 1; \ + fprintf(stderr, "decode-error: %s:%d: %s", \ + __FILE__, __LINE__, (msg)); \ + } while (0) +#else + #define UDERR(u, m) \ + do { \ + (u)->error = 1; \ + } while (0) +#endif /* !LOGERR */ + +#define UD_RETURN_ON_ERROR(u) \ + do { \ + if ((u)->error != 0) { \ + return (u)->error; \ + } \ + } while (0) + +#define UD_RETURN_WITH_ERROR(u, m) \ + do { \ + UDERR(u, m); \ + return (u)->error; \ + } while (0) + +#ifndef __UD_STANDALONE__ +# define UD_NON_STANDALONE(x) x +#else +# define UD_NON_STANDALONE(x) +#endif + +/* printf formatting int64 specifier */ +#ifdef FMT64 +# undef FMT64 +#endif +#if defined(_MSC_VER) || defined(__BORLANDC__) +# define FMT64 "I64" +#else +# if defined(__APPLE__) +# define FMT64 "ll" +# elif defined(__amd64__) || defined(__x86_64__) +# define FMT64 "l" +# else +# define FMT64 "ll" +# endif /* !x64 */ +#endif + +/* define an inline macro */ +#if defined(_MSC_VER) || defined(__BORLANDC__) +# define UD_INLINE __inline /* MS Visual Studio requires __inline + instead of inline for C code */ +#else +# define UD_INLINE inline +#endif + +#endif /* _UDINT_H_ */ -- cgit v1.2.1