------------------------------------------------------------------------------ LuaJIT x86 disassembler module.---- Copyright (C) 2005-2007 Mike Pall. All rights reserved.-- Released under the MIT/X license. See luajit.h for full copyright notice.------------------------------------------------------------------------------ This is a helper module used by the LuaJIT machine code dumper module.---- Sending small code snippets to an external disassembler and mixing the-- output with our own stuff was too fragile. So I had to bite the bullet-- and write yet another x86 disassembler. Oh well ...---- The output format is very similar to what ndisasm generates. But it has-- been developed independently by looking at the opcode tables from the-- Intel and AMD manuals. The supported instruction set is quite extensive-- and reflects what a current generation P4 or K8 implements in 32 bit-- mode. Yes, this includes MMX, SSE, SSE2, SSE3, SSSE3 and even privileged-- instructions.---- Notes:-- * The (useless) a16 prefix, 3DNow and pre-586 opcodes are unsupported.-- * No attempt at optimization has been made -- it's fast enough for my needs.-- * The public API may change when more architectures are added.---- TODO:-- * More testing with arbitrary x86 code (not just LuaJIT generated code).-- * The output for a few MMX/SSE opcodes could be improved.-- * Adding x64 support would be straightforward.-- * Better input API (iterator) and output API (structured access to instr).------------------------------------------------------------------------------local type = typelocal sub, byte, format = string.sub, string.byte, string.formatlocal match, gmatch, gsub = string.match, string.gmatch, string.gsub-- Map for 1st opcode byte. Ugly? Well ... read on.local map_opc1 = {--0x[0]="addBmr","addVmr","addBrm","addVrm","addBai","addVai","push es","pop es","orBmr","orVmr","orBrm","orVrm","orBai","orVai","push cs","opc2*",--1x"adcBmr","adcVmr","adcBrm","adcVrm","adcBai","adcVai","push ss","pop ss","sbbBmr","sbbVmr","sbbBrm","sbbVrm","sbbBai","sbbVai","push ds","pop ds",--2x"andBmr","andVmr","andBrm","andVrm","andBai","andVai","es:seg","daa","subBmr","subVmr","subBrm","subVrm","subBai","subVai","cs:seg","das",--3x"xorBmr","xorVmr","xorBrm","xorVrm","xorBai","xorVai","ss:seg","aaa","cmpBmr","cmpVmr","cmpBrm","cmpVrm","cmpBai","cmpVai","ds:seg","aas",--4x"incVR","incVR","incVR","incVR","incVR","incVR","incVR","incVR","decVR","decVR","decVR","decVR","decVR","decVR","decVR","decVR",--5x"pushVR","pushVR","pushVR","pushVR","pushVR","pushVR","pushVR","pushVR","popVR","popVR","popVR","popVR","popVR","popVR","popVR","popVR",--6x"pusha/pushaw","popa/popaw","boundVrm","arplWmr","fs:seg","gs:seg","o16:","a16","pushVi","imulVrmi","pushBs","imulVrms","insb","insd/insw","outsb","outsd/outsw",--7x"joBj","jnoBj","jbBj","jnbBj","jzBj","jnzBj","jbeBj","jaBj","jsBj","jnsBj","jpeBj","jpoBj","jlBj","jgeBj","jleBj","jgBj",--8x"arith!Bmi","arith!Vmi","arith!Bmi","arith!Vms","testBmr","testVmr","xchgBrm","xchgVrm","movBmr","movVmr","movBrm","movVrm","movVmg","leaVrm","movWgm","popVm",--9x"nop|pause|xchgWaR|repne nop","xchgVaR","xchgVaR","xchgVaR","xchgVaR","xchgVaR","xchgVaR","xchgVaR","cwde/cbw","cdq/cwd","call farViw","wait","pushf/pushfw","popf/popfw","sahf","lahf",--Ax"movBao","movVao","movBoa","movVoa","movsb","movsd/movsb","cmpsb","cmpsd/cmpsw","testBai","testVai","stosb","stosd/stosw","lodsb","lodsd/lodsw","scasb","scasd/scasw",--Bx"movBRi","movBRi","movBRi","movBRi","movBRi","movBRi","movBRi","movBRi","movVRi","movVRi","movVRi","movVRi","movVRi","movVRi","movVRi","movVRi",--Cx"shift!Bmu","shift!Vmu","retBw","ret","lesVrm","ldsVrm","movBmi","movVmi","enterBwu","leave","retfBw","retf","int3","intBu","into","iret/iretw",--Dx"shift!Bm1","shift!Vm1","shift!Bmc","shift!Vmc","aamBu","aadBu","salc","xlatb","fp*0","fp*1","fp*2","fp*3","fp*4","fp*5","fp*6","fp*7",--Ex"loopneBj","loopeBj","loopBj","jecxz/jcxzBj","inBau","inVau","outBua","outVua","callDj","jmpDj","jmp farViw","jmpBj","inBad","inVad","outBda","outVda",--Fx"lock:","int1","repne:rep","rep:","hlt","cmc","testb!Bm","testv!Vm","clc","stc","cli","sti","cld","std","inc!Bm","inc!Vm",}assert(#map_opc1 == 255)-- Map for 2nd opcode byte (0f xx). True CISC hell. Hey, I told you.-- Prefix dependent MMX/SSE opcodes: (none)|rep|o16|repnelocal map_opc2 = {--0x[0]="sldt!Dmp","sgdt!Dmp","larVrm","lslVrm",nil,"syscall","clts","sysret","invd","wbinvd",nil,"ud1",nil,"prefetch!Bm","femms","3dnowMrmu",--1x"movupsXrm|movssXrm|movupdXrm|movsdXrm","movupsXmr|movssXmr|movupdXmr|movsdXmr","movhlpsXrm|movsldupXrm|movlpdXrm|movddupXrm", -- TODO: movlpsXrMm (mem case)."movlpsXmr||movlpdXmr","unpcklpsXrm||unpcklpdXrm","unpckhpsXrm||unpckhpdXrm","movlhpsXrm|movshdupXrm|movhpdXrm", -- TODO: movhpsXrMm (mem case)."movhpsXmr||movhpdXmr","prefetcht!Bm","hintnopBm","hintnopBm","hintnopBm","hintnopBm","hintnopBm","hintnopBm","hintnopBm",--2x"movDmx","movDmy","movDxm","movDym","movDmz",nil,"movDzm",nil,"movapsXrm||movapdXrm","movapsXmr||movapdXmr","cvtpi2psXrMm|cvtsi2ssXrDm|cvtpi2pdXrMm|cvtsi2sdXrDm","movntpsXmr||movntpdXmr","cvttps2piMrXm|cvttss2siDrXm|cvttpd2piMrXm|cvttsd2siDrXm","cvtps2piMrXm|cvtss2siDrXm|cvtpd2piMrXm|cvtsd2siDrXm","ucomissXrm||ucomisdXrm","comissXrm||comisdXrm",--3x"wrmsr","rdtsc","rdmsr","rdpmc","sysenter","sysexit",nil,nil,"ssse3*38",nil,"ssse3*3a",nil,nil,nil,nil,nil,--4x"cmovoVrm","cmovnoVrm","cmovbVrm","cmovnbVrm","cmovzVrm","cmovnzVrm","cmovbeVrm","cmovaVrm","cmovsVrm","cmovnsVrm","cmovpeVrm","cmovpoVrm","cmovlVrm","cmovgeVrm","cmovleVrm","cmovgVrm",--5x"movmskpsDrXm||movmskpdDrXm","sqrtpsXrm|sqrtssXrm|sqrtpdXrm|sqrtsdXrm","rsqrtpsXrm|rsqrtssXrm","rcppsXrm|rcpssXrm","andpsXrm||andpdXrm","andnpsXrm||andnpdXrm","orpsXrm||orpdXrm","xorpsXrm||xorpdXrm","addpsXrm|addssXrm|addpdXrm|addsdXrm","mulpsXrm|mulssXrm|mulpdXrm|mulsdXrm","cvtps2pdXrm|cvtss2sdXrm|cvtpd2psXrm|cvtsd2ssXrm","cvtdq2psXrm|cvttps2dqXrm|cvtps2dqXrm","subpsXrm|subssXrm|subpdXrm|subsdXrm","minpsXrm|minssXrm|minpdXrm|minsdXrm","divpsXrm|divssXrm|divpdXrm|divsdXrm","maxpsXrm|maxssXrm|maxpdXrm|maxsdXrm",--6x"punpcklbwMrm||punpcklbqXrm","punpcklwdPrm","punpckldqPrm","packsswbPrm","pcmpgtbPrm","pcmpgtwPrm","pcmpgtdPrm","packuswbPrm","punpckhbwPrm","punpckhwdPrm","punpckhdqPrm","packssdwPrm","||punpcklqdqXrm","||punpckhqdqXrm","movdPrDm","movqMrm|movdquXrm|movdqaXrm",--7x"pshufwPrmu","pshiftw!Pmu","pshiftd!Pmu","pshiftq!Mmu||pshiftdq!Xmu","pcmpeqbPrm","pcmpeqwPrm","pcmpeqdPrm","emms|",nil,nil,nil,nil,"||haddpdXrm|haddpsXrm","||hsubpdXrm|hsubpsXrm","movdDmMr|movqXrm|movdDmXr","movqMmr|movdquXmr|movdqaXmr",--8x"joVj","jnoVj","jbVj","jnbVj","jzVj","jnzVj","jbeVj","jaVj","jsVj","jnsVj","jpeVj","jpoVj","jlVj","jgeVj","jleVj","jgVj",--9x"setoBm","setnoBm","setbBm","setnbBm","setzBm","setnzBm","setbeBm","setaBm","setsBm","setnsBm","setpeBm","setpoBm","setlBm","setgeBm","setleBm","setgBm",--Ax"push fs","pop fs","cpuid","btVmr","shldVmru","shldVmrc",nil,nil,"push gs","pop gs","rsm","btsVmr","shrdVmru","shrdVmrc","fxsave!Dmp","imulVrm",--Bx"cmpxchgBmr","cmpxchgVmr","lssVrm","btrVmr","lfsVrm","lgsVrm","movzxVrBm","movzxDrWm",nil,"ud2","bt!Vmu","btcVmr","bsfVrm","bsrVrm","movsxVrBm","movsxDrWm",--Cx"xaddBmr","xaddVmr","cmppsXrmu|cmpssXrmu|cmppdXrmu|cmpsdXrmu","movntiDmr|","pinsrwPrWmu","pextrwDrPmu","shufpsXrmu||shufpdXrmu","cmpxchg!Dmp","bswapDR","bswapDR","bswapDR","bswapDR","bswapDR","bswapDR","bswapDR","bswapDR",--Dx"||addsubpdXrm|addsubpsXrm","psrlwPrm","psrldPrm","psrlqPrm","paddqPrm","pmullwPrm","|movq2dqXrMm|movqXmr|movdq2qMrXm","pmovmskbDrPm","psubusbPrm","psubuswPrm","pminubPrm","pandPrm","paddusbPrm","padduswPrm","pmaxubPrm","pandnPrm",--Ex"pavgbPrm","psrawPrm","psradPrm","pavgwPrm","pmulhuwPrm","pmulhwPrm","|cvtdq2pdXrm|cvttpd2dqXrm|cvtpd2dqXrm","movntqMmr||movntdqXmr","psubsbPrm","psubswPrm","pminswPrm","porPrm","paddsbPrm","paddswPrm","pmaxswPrm","pxorPrm",--Fx"|||lddquXrm","psllwPrm","pslldPrm","psllqPrm","pmuludqPrm","pmaddwdPrm","psadbwPrm","maskmovqMrm||maskmovdquXrm","psubbPrm","psubwPrm","psubdPrm","psubqPrm","paddbPrm","paddwPrm","padddPrm","ud",}assert(map_opc2[255] == "ud")-- Map for SSSE3 opcodes.local map_ssse3 = {["38"] = { -- [66] 0f 38 xx--0x[0]="pshufbPrm","phaddwPrm","phadddPrm","phaddswPrm","pmaddubswPrm","phsubwPrm","phsubdPrm","phsubswPrm","psignbPrm","psignwPrm","psigndPrm","pmulhrswPrm",nil,nil,nil,nil,--1xnil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,nil,"pabsbPrm","pabswPrm","pabsdPrm",nil,},["3a"] = { -- [66] 0f 3a xx[0x0f] = "palignrPrmu",},}-- Map for FP opcodes. And you thought stack machines are simple?local map_opcfp = {-- D8-DF 00-BF: opcodes with a memory operand.-- D8[0]="faddFm","fmulFm","fcomFm","fcompFm","fsubFm","fsubrFm","fdivFm","fdivrFm","fldFm",nil,"fstFm","fstpFm","fldenvDmp","fldcwWm","fnstenvDmp","fnstcwWm",-- DA"fiaddDm","fimulDm","ficomDm","ficompDm","fisubDm","fisubrDm","fidivDm","fidivrDm",-- DB"fildDm","fisttpDm","fistDm","fistpDm",nil,"fld twordFmp",nil,"fstp twordFmp",-- DC"faddGm","fmulGm","fcomGm","fcompGm","fsubGm","fsubrGm","fdivGm","fdivrGm",-- DD"fldGm","fisttpQm","fstGm","fstpGm","frstorDmp",nil,"fnsaveDmp","fnstswWm",-- DE"fiaddWm","fimulWm","ficomWm","ficompWm","fisubWm","fisubrWm","fidivWm","fidivrWm",-- DF"fildWm","fisttpWm","fistWm","fistpWm","fbld twordFmp","fildQm","fbstp twordFmp","fistpQm",-- xx C0-FF: opcodes with a pseudo-register operand.-- D8"faddFf","fmulFf","fcomFf","fcompFf","fsubFf","fsubrFf","fdivFf","fdivrFf",-- D9"fldFf","fxchFf",{"fnop"},nil,{"fchs","fabs",nil,nil,"ftst","fxam"},{"fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz"},{"f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp"},{"fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos"},-- DA"fcmovbFf","fcmoveFf","fcmovbeFf","fcmovuFf",nil,{nil,"fucompp"},nil,nil,-- DB"fcmovnbFf","fcmovneFf","fcmovnbeFf","fcmovnuFf",{nil,nil,"fnclex","fninit"},"fucomiFf","fcomiFf",nil,-- DC"fadd toFf","fmul toFf",nil,nil,"fsub toFf","fsubr toFf","fdivr toFf","fdiv toFf",-- DD"ffreeFf",nil,"fstFf","fstpFf","fucomFf","fucompFf",nil,nil,-- DE"faddpFf","fmulpFf",nil,{nil,"fcompp"},"fsubrpFf","fsubpFf","fdivrpFf","fdivpFf",-- DFnil,nil,nil,nil,{"fnstsw ax"},"fucomipFf","fcomipFf",nil,}assert(map_opcfp[126] == "fcomipFf")-- Map for opcode groups. The subkey is sp from the ModRM byte.local map_opcgroup = {  arith = { "add", "or", "adc", "sbb", "and", "sub", "xor", "cmp" },  shift = { "rol", "ror", "rcl", "rcr", "shl", "shr", "sal", "sar" },  testb = { "testBmi", "testBmi", "not", "neg", "mul", "imul", "div", "idiv" },  testv = { "testVmi", "testVmi", "not", "neg", "mul", "imul", "div", "idiv" },  inc = { "inc", "dec", "callDmp", "call farDmp",	  "jmpDmp", "jmp farDmp", "push" },  sldt = { "sldt", "str", "lldt", "ltr", "verr", "verw" },  sgdt = { "sgdt", "sidt", "lgdt", "lidt", "smsw", nil, "lmsw", "invlpg" },  bt = { nil, nil, nil, nil, "bt", "bts", "btr", "btc" },  cmpxchg = { nil, "cmpxchg8b" },  pshiftw = { nil, nil, "psrlw", nil, "psraw", nil, "psllw" },  pshiftd = { nil, nil, "psrld", nil, "psrad", nil, "pslld" },  pshiftq = { nil, nil, "psrlq", nil, nil, nil, "psllq" },  pshiftdq = { nil, nil, "psrlq", "psrldq", nil, nil, "psllq", "pslldq" },  fxsave = { "fxsave", "fxrstor", "ldmxcsr", "stmxcsr",	     nil, "lfenceDp", "mfenceDp", "sfenceDp" }, -- TODO: clflush.  prefetch = { "prefetch", "prefetchw" },  prefetcht = { "prefetchnta", "prefetcht0", "prefetcht1", "prefetcht2" },}-------------------------------------------------------------------------------- Maps for register names.local map_aregs = { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi" }local map_regs = {  B = { "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh" },  W = { "ax", "cx", "dx", "bx", "sp", "bp", "si", "di" },  D = map_aregs,  M = { "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7" },  X = { "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7" },}local map_segregs = { "es", "cs", "ss", "ds", "fs", "gs", "segr6", "segr7" }-- Maps for size names.local map_sz2n = {  B = 1, W = 2, D = 4, Q = 8, M = 8, X = 16,}local map_sz2prefix = {  B = "byte", W = "word", D = "dword",  Q = "qword", -- No associated reg in 32 bit mode.  F = "dword", G = "qword", -- No need for sizes/register names for these two.  M = "qword", X = "xword",}-------------------------------------------------------------------------------- Output a nicely formatted line with an opcode and operands.local function putop(ctx, text, operands)  local code, pos, hex = ctx.code, ctx.pos, ""  for i=ctx.start,pos-1 do    hex = hex..format("%02X", byte(code, i, i))  end