luna - luajit/src/jit/dis

  1----------------------------------------------------------------------------
  2-- LuaJIT x86/x64 disassembler module.
  3--
  4-- Copyright (C) 2005-2026 Mike Pall. All rights reserved.
  5-- Released under the MIT license. See Copyright Notice in luajit.h
  6----------------------------------------------------------------------------
  7-- This is a helper module used by the LuaJIT machine code dumper module.
  8--
  9-- Sending small code snippets to an external disassembler and mixing the
 10-- output with our own stuff was too fragile. So I had to bite the bullet
 11-- and write yet another x86 disassembler. Oh well ...
 12--
 13-- The output format is very similar to what ndisasm generates. But it has
 14-- been developed independently by looking at the opcode tables from the
 15-- Intel and AMD manuals. The supported instruction set is quite extensive
 16-- and reflects what a current generation Intel or AMD CPU implements in
 17-- 32 bit and 64 bit mode. Yes, this includes MMX, SSE, SSE2, SSE3, SSSE3,
 18-- SSE4.1, SSE4.2, SSE4a, AVX, AVX2 and even privileged and hypervisor
 19-- (VMX/SVM) instructions.
 20--
 21-- Notes:
 22-- * The (useless) a16 prefix, 3DNow and pre-586 opcodes are unsupported.
 23-- * No attempt at optimization has been made -- it's fast enough for my needs.
 24------------------------------------------------------------------------------
 25
 26local type = type
 27local sub, byte, format = string.sub, string.byte, string.format
 28local match, gmatch, gsub = string.match, string.gmatch, string.gsub
 29local lower, rep = string.lower, string.rep
 30local bit = require("bit")
 31local tohex = bit.tohex
 32
 33-- Map for 1st opcode byte in 32 bit mode. Ugly? Well ... read on.
 34local map_opc1_32 = {
 35--0x
 36[0]="addBmr","addVmr","addBrm","addVrm","addBai","addVai","push es","pop es",
 37"orBmr","orVmr","orBrm","orVrm","orBai","orVai","push cs","opc2*",
 38--1x
 39"adcBmr","adcVmr","adcBrm","adcVrm","adcBai","adcVai","push ss","pop ss",
 40"sbbBmr","sbbVmr","sbbBrm","sbbVrm","sbbBai","sbbVai","push ds","pop ds",
 41--2x
 42"andBmr","andVmr","andBrm","andVrm","andBai","andVai","es:seg","daa",
 43"subBmr","subVmr","subBrm","subVrm","subBai","subVai","cs:seg","das",
 44--3x
 45"xorBmr","xorVmr","xorBrm","xorVrm","xorBai","xorVai","ss:seg","aaa",
 46"cmpBmr","cmpVmr","cmpBrm","cmpVrm","cmpBai","cmpVai","ds:seg","aas",
 47--4x
 48"incVR","incVR","incVR","incVR","incVR","incVR","incVR","incVR",
 49"decVR","decVR","decVR","decVR","decVR","decVR","decVR","decVR",
 50--5x
 51"pushUR","pushUR","pushUR","pushUR","pushUR","pushUR","pushUR","pushUR",
 52"popUR","popUR","popUR","popUR","popUR","popUR","popUR","popUR",
 53--6x
 54"sz*pushaw,pusha","sz*popaw,popa","boundVrm","arplWmr",
 55"fs:seg","gs:seg","o16:","a16",
 56"pushUi","imulVrmi","pushBs","imulVrms",
 57"insb","insVS","outsb","outsVS",
 58--7x
 59"joBj","jnoBj","jbBj","jnbBj","jzBj","jnzBj","jbeBj","jaBj",
 60"jsBj","jnsBj","jpeBj","jpoBj","jlBj","jgeBj","jleBj","jgBj",
 61--8x
 62"arith!Bmi","arith!Vmi","arith!Bmi","arith!Vms",
 63"testBmr","testVmr","xchgBrm","xchgVrm",
 64"movBmr","movVmr","movBrm","movVrm",
 65"movVmg","leaVrm","movWgm","popUm",
 66--9x
 67"nop*xchgVaR|pause|xchgWaR|repne nop","xchgVaR","xchgVaR","xchgVaR",
 68"xchgVaR","xchgVaR","xchgVaR","xchgVaR",
 69"sz*cbw,cwde,cdqe","sz*cwd,cdq,cqo","call farViw","wait",
 70"sz*pushfw,pushf","sz*popfw,popf","sahf","lahf",
 71--Ax
 72"movBao","movVao","movBoa","movVoa",
 73"movsb","movsVS","cmpsb","cmpsVS",
 74"testBai","testVai","stosb","stosVS",
 75"lodsb","lodsVS","scasb","scasVS",
 76--Bx
 77"movBRi","movBRi","movBRi","movBRi","movBRi","movBRi","movBRi","movBRi",
 78"movVRI","movVRI","movVRI","movVRI","movVRI","movVRI","movVRI","movVRI",
 79--Cx
 80"shift!Bmu","shift!Vmu","retBw","ret","vex*3$lesVrm","vex*2$ldsVrm","movBmi","movVmi",
 81"enterBwu","leave","retfBw","retf","int3","intBu","into","iretVS",
 82--Dx
 83"shift!Bm1","shift!Vm1","shift!Bmc","shift!Vmc","aamBu","aadBu","salc","xlatb",
 84"fp*0","fp*1","fp*2","fp*3","fp*4","fp*5","fp*6","fp*7",
 85--Ex
 86"loopneBj","loopeBj","loopBj","sz*jcxzBj,jecxzBj,jrcxzBj",
 87"inBau","inVau","outBua","outVua",
 88"callVj","jmpVj","jmp farViw","jmpBj","inBad","inVad","outBda","outVda",
 89--Fx
 90"lock:","int1","repne:rep","rep:","hlt","cmc","testb!Bm","testv!Vm",
 91"clc","stc","cli","sti","cld","std","incb!Bm","incd!Vm",
 92}
 93assert(#map_opc1_32 == 255)
 94
 95-- Map for 1st opcode byte in 64 bit mode (overrides only).
 96local map_opc1_64 = setmetatable({
 97  [0x06]=false, [0x07]=false, [0x0e]=false,
 98  [0x16]=false, [0x17]=false, [0x1e]=false, [0x1f]=false,
 99  [0x27]=false, [0x2f]=false, [0x37]=false, [0x3f]=false,
100  [0x60]=false, [0x61]=false, [0x62]=false, [0x63]="movsxdVrDmt", [0x67]="a32:",
101  [0x40]="rex*",   [0x41]="rex*b",   [0x42]="rex*x",   [0x43]="rex*xb",
102  [0x44]="rex*r",  [0x45]="rex*rb",  [0x46]="rex*rx",  [0x47]="rex*rxb",
103  [0x48]="rex*w",  [0x49]="rex*wb",  [0x4a]="rex*wx",  [0x4b]="rex*wxb",
104  [0x4c]="rex*wr", [0x4d]="rex*wrb", [0x4e]="rex*wrx", [0x4f]="rex*wrxb",
105  [0x82]=false, [0x9a]=false, [0xc4]="vex*3", [0xc5]="vex*2", [0xce]=false,
106  [0xd4]=false, [0xd5]=false, [0xd6]=false, [0xea]=false,
107}, { __index = map_opc1_32 })
108
109-- Map for 2nd opcode byte (0F xx). True CISC hell. Hey, I told you.
110-- Prefix dependent MMX/SSE opcodes: (none)|rep|o16|repne, -|F3|66|F2
111local map_opc2 = {
112--0x
113[0]="sldt!Dmp","sgdt!Ump","larVrm","lslVrm",nil,"syscall","clts","sysret",
114"invd","wbinvd",nil,"ud1",nil,"$prefetch!Bm","femms","3dnowMrmu",
115--1x
116"movupsXrm|movssXrvm|movupdXrm|movsdXrvm",
117"movupsXmr|movssXmvr|movupdXmr|movsdXmvr",
118"movhlpsXrm$movlpsXrm|movsldupXrm|movlpdXrm|movddupXrm",
119"movlpsXmr||movlpdXmr",
120"unpcklpsXrvm||unpcklpdXrvm",
121"unpckhpsXrvm||unpckhpdXrvm",
122"movlhpsXrm$movhpsXrm|movshdupXrm|movhpdXrm",
123"movhpsXmr||movhpdXmr",
124"$prefetcht!Bm","hintnopVm","hintnopVm","hintnopVm",
125"hintnopVm","hintnopVm","endbr*hintnopVm","hintnopVm",
126--2x
127"movUmx$","movUmy$","movUxm$","movUym$","movUmz$",nil,"movUzm$",nil,
128"movapsXrm||movapdXrm",
129"movapsXmr||movapdXmr",
130"cvtpi2psXrMm|cvtsi2ssXrvVmt|cvtpi2pdXrMm|cvtsi2sdXrvVmt",
131"movntpsXmr|movntssXmr|movntpdXmr|movntsdXmr",
132"cvttps2piMrXm|cvttss2siVrXm|cvttpd2piMrXm|cvttsd2siVrXm",
133"cvtps2piMrXm|cvtss2siVrXm|cvtpd2piMrXm|cvtsd2siVrXm",
134"ucomissXrm||ucomisdXrm",
135"comissXrm||comisdXrm",
136--3x
137"wrmsr","rdtsc","rdmsr","rdpmc","sysenter","sysexit",nil,"getsec",
138"opc3*38",nil,"opc3*3a",nil,nil,nil,nil,nil,
139--4x
140"cmovoVrm","cmovnoVrm","cmovbVrm","cmovnbVrm",
141"cmovzVrm","cmovnzVrm","cmovbeVrm","cmovaVrm",
142"cmovsVrm","cmovnsVrm","cmovpeVrm","cmovpoVrm",
143"cmovlVrm","cmovgeVrm","cmovleVrm","cmovgVrm",
144--5x
145"movmskpsVrXm$||movmskpdVrXm$","sqrtpsXrm|sqrtssXrm|sqrtpdXrm|sqrtsdXrm",
146"rsqrtpsXrm|rsqrtssXrvm","rcppsXrm|rcpssXrvm",
147"andpsXrvm||andpdXrvm","andnpsXrvm||andnpdXrvm",
148"orpsXrvm||orpdXrvm","xorpsXrvm||xorpdXrvm",
149"addpsXrvm|addssXrvm|addpdXrvm|addsdXrvm","mulpsXrvm|mulssXrvm|mulpdXrvm|mulsdXrvm",
150"cvtps2pdXrm|cvtss2sdXrvm|cvtpd2psXrm|cvtsd2ssXrvm",
151"cvtdq2psXrm|cvttps2dqXrm|cvtps2dqXrm",
152"subpsXrvm|subssXrvm|subpdXrvm|subsdXrvm","minpsXrvm|minssXrvm|minpdXrvm|minsdXrvm",
153"divpsXrvm|divssXrvm|divpdXrvm|divsdXrvm","maxpsXrvm|maxssXrvm|maxpdXrvm|maxsdXrvm",
154--6x
155"punpcklbwPrvm","punpcklwdPrvm","punpckldqPrvm","packsswbPrvm",
156"pcmpgtbPrvm","pcmpgtwPrvm","pcmpgtdPrvm","packuswbPrvm",
157"punpckhbwPrvm","punpckhwdPrvm","punpckhdqPrvm","packssdwPrvm",
158"||punpcklqdqXrvm","||punpckhqdqXrvm",
159"movPrVSm","movqMrm|movdquXrm|movdqaXrm",
160--7x
161"pshufwMrmu|pshufhwXrmu|pshufdXrmu|pshuflwXrmu","pshiftw!Pvmu",
162"pshiftd!Pvmu","pshiftq!Mvmu||pshiftdq!Xvmu",
163"pcmpeqbPrvm","pcmpeqwPrvm","pcmpeqdPrvm","emms*|",
164"vmreadUmr||extrqXmuu$|insertqXrmuu$","vmwriteUrm||extrqXrm$|insertqXrm$",
165nil,nil,
166"||haddpdXrvm|haddpsXrvm","||hsubpdXrvm|hsubpsXrvm",
167"movVSmMr|movqXrm|movVSmXr","movqMmr|movdquXmr|movdqaXmr",
168--8x
169"joVj","jnoVj","jbVj","jnbVj","jzVj","jnzVj","jbeVj","jaVj",
170"jsVj","jnsVj","jpeVj","jpoVj","jlVj","jgeVj","jleVj","jgVj",
171--9x
172"setoBm","setnoBm","setbBm","setnbBm","setzBm","setnzBm","setbeBm","setaBm",
173"setsBm","setnsBm","setpeBm","setpoBm","setlBm","setgeBm","setleBm","setgBm",
174--Ax
175"push fs","pop fs","cpuid","btVmr","shldVmru","shldVmrc",nil,nil,
176"push gs","pop gs","rsm","btsVmr","shrdVmru","shrdVmrc","fxsave!Dmp","imulVrm",
177--Bx
178"cmpxchgBmr","cmpxchgVmr","$lssVrm","btrVmr",
179"$lfsVrm","$lgsVrm","movzxVrBmt","movzxVrWmt",
180"|popcntVrm","ud2Dp","bt!Vmu","btcVmr",
181"bsfVrm","bsrVrm|lzcntVrm|bsrWrm","movsxVrBmt","movsxVrWmt",
182--Cx
183"xaddBmr","xaddVmr",
184"cmppsXrvmu|cmpssXrvmu|cmppdXrvmu|cmpsdXrvmu","$movntiVmr|",
185"pinsrwPrvWmu","pextrwDrPmu",
186"shufpsXrvmu||shufpdXrvmu","$cmpxchg!Qmp",
187"bswapVR","bswapVR","bswapVR","bswapVR","bswapVR","bswapVR","bswapVR","bswapVR",
188--Dx
189"||addsubpdXrvm|addsubpsXrvm","psrlwPrvm","psrldPrvm","psrlqPrvm",
190"paddqPrvm","pmullwPrvm",
191"|movq2dqXrMm|movqXmr|movdq2qMrXm$","pmovmskbVrMm||pmovmskbVrXm",
192"psubusbPrvm","psubuswPrvm","pminubPrvm","pandPrvm",
193"paddusbPrvm","padduswPrvm","pmaxubPrvm","pandnPrvm",
194--Ex
195"pavgbPrvm","psrawPrvm","psradPrvm","pavgwPrvm",
196"pmulhuwPrvm","pmulhwPrvm",
197"|cvtdq2pdXrm|cvttpd2dqXrm|cvtpd2dqXrm","$movntqMmr||$movntdqXmr",
198"psubsbPrvm","psubswPrvm","pminswPrvm","porPrvm",
199"paddsbPrvm","paddswPrvm","pmaxswPrvm","pxorPrvm",
200--Fx
201"|||lddquXrm","psllwPrvm","pslldPrvm","psllqPrvm",
202"pmuludqPrvm","pmaddwdPrvm","psadbwPrvm","maskmovqMrm||maskmovdquXrm$",
203"psubbPrvm","psubwPrvm","psubdPrvm","psubqPrvm",
204"paddbPrvm","paddwPrvm","padddPrvm","ud",
205}
206assert(map_opc2[255] == "ud")
207
208-- Map for three-byte opcodes. Can't wait for their next invention.
209local map_opc3 = {
210["38"] = { -- [66] 0f 38 xx
211--0x
212[0]="pshufbPrvm","phaddwPrvm","phadddPrvm","phaddswPrvm",
213"pmaddubswPrvm","phsubwPrvm","phsubdPrvm","phsubswPrvm",
214"psignbPrvm","psignwPrvm","psigndPrvm","pmulhrswPrvm",
215"||permilpsXrvm","||permilpdXrvm",nil,nil,
216--1x
217"||pblendvbXrma",nil,nil,nil,
218"||blendvpsXrma","||blendvpdXrma","||permpsXrvm","||ptestXrm",
219"||broadcastssXrm","||broadcastsdXrm","||broadcastf128XrlXm",nil,
220"pabsbPrm","pabswPrm","pabsdPrm",nil,
221--2x
222"||pmovsxbwXrm","||pmovsxbdXrm","||pmovsxbqXrm","||pmovsxwdXrm",
223"||pmovsxwqXrm","||pmovsxdqXrm",nil,nil,
224"||pmuldqXrvm","||pcmpeqqXrvm","||$movntdqaXrm","||packusdwXrvm",
225"||maskmovpsXrvm","||maskmovpdXrvm","||maskmovpsXmvr","||maskmovpdXmvr",
226--3x
227"||pmovzxbwXrm","||pmovzxbdXrm","||pmovzxbqXrm","||pmovzxwdXrm",
228"||pmovzxwqXrm","||pmovzxdqXrm","||permdXrvm","||pcmpgtqXrvm",
229"||pminsbXrvm","||pminsdXrvm","||pminuwXrvm","||pminudXrvm",
230"||pmaxsbXrvm","||pmaxsdXrvm","||pmaxuwXrvm","||pmaxudXrvm",
231--4x
232"||pmulddXrvm","||phminposuwXrm",nil,nil,
233nil,"||psrlvVSXrvm","||psravdXrvm","||psllvVSXrvm",
234--5x
235[0x58] = "||pbroadcastdXrlXm",[0x59] = "||pbroadcastqXrlXm",
236[0x5a] = "||broadcasti128XrlXm",
237--7x
238[0x78] = "||pbroadcastbXrlXm",[0x79] = "||pbroadcastwXrlXm",
239--8x
240[0x8c] = "||pmaskmovXrvVSm",
241[0x8e] = "||pmaskmovVSmXvr",
242--9x
243[0x96] = "||fmaddsub132pHXrvm",[0x97] = "||fmsubadd132pHXrvm",
244[0x98] = "||fmadd132pHXrvm",[0x99] = "||fmadd132sHXrvm",
245[0x9a] = "||fmsub132pHXrvm",[0x9b] = "||fmsub132sHXrvm",
246[0x9c] = "||fnmadd132pHXrvm",[0x9d] = "||fnmadd132sHXrvm",
247[0x9e] = "||fnmsub132pHXrvm",[0x9f] = "||fnmsub132sHXrvm",
248--Ax
249[0xa6] = "||fmaddsub213pHXrvm",[0xa7] = "||fmsubadd213pHXrvm",
250[0xa8] = "||fmadd213pHXrvm",[0xa9] = "||fmadd213sHXrvm",
251[0xaa] = "||fmsub213pHXrvm",[0xab] = "||fmsub213sHXrvm",
252[0xac] = "||fnmadd213pHXrvm",[0xad] = "||fnmadd213sHXrvm",
253[0xae] = "||fnmsub213pHXrvm",[0xaf] = "||fnmsub213sHXrvm",
254--Bx
255[0xb6] = "||fmaddsub231pHXrvm",[0xb7] = "||fmsubadd231pHXrvm",
256[0xb8] = "||fmadd231pHXrvm",[0xb9] = "||fmadd231sHXrvm",
257[0xba] = "||fmsub231pHXrvm",[0xbb] = "||fmsub231sHXrvm",
258[0xbc] = "||fnmadd231pHXrvm",[0xbd] = "||fnmadd231sHXrvm",
259[0xbe] = "||fnmsub231pHXrvm",[0xbf] = "||fnmsub231sHXrvm",
260--Dx
261[0xdc] = "||aesencXrvm", [0xdd] = "||aesenclastXrvm",
262[0xde] = "||aesdecXrvm", [0xdf] = "||aesdeclastXrvm",
263--Fx
264[0xf0] = "|||crc32TrBmt",[0xf1] = "|||crc32TrVmt",
265[0xf7] = "| sarxVrmv| shlxVrmv| shrxVrmv",
266},
267
268["3a"] = { -- [66] 0f 3a xx
269--0x
270[0x00]="||permqXrmu","||permpdXrmu","||pblenddXrvmu",nil,
271"||permilpsXrmu","||permilpdXrmu","||perm2f128Xrvmu",nil,
272"||roundpsXrmu","||roundpdXrmu","||roundssXrvmu","||roundsdXrvmu",
273"||blendpsXrvmu","||blendpdXrvmu","||pblendwXrvmu","palignrPrvmu",
274--1x
275nil,nil,nil,nil,
276"||pextrbVmXru","||pextrwVmXru","||pextrVmSXru","||extractpsVmXru",
277"||insertf128XrvlXmu","||extractf128XlXmYru",nil,nil,
278nil,nil,nil,nil,
279--2x
280"||pinsrbXrvVmu","||insertpsXrvmu","||pinsrXrvVmuS",nil,
281--3x
282[0x38] = "||inserti128Xrvmu",[0x39] = "||extracti128XlXmYru",
283--4x
284[0x40] = "||dppsXrvmu",
285[0x41] = "||dppdXrvmu",
286[0x42] = "||mpsadbwXrvmu",
287[0x44] = "||pclmulqdqXrvmu",
288[0x46] = "||perm2i128Xrvmu",
289[0x4a] = "||blendvpsXrvmb",[0x4b] = "||blendvpdXrvmb",
290[0x4c] = "||pblendvbXrvmb",
291--6x
292[0x60] = "||pcmpestrmXrmu",[0x61] = "||pcmpestriXrmu",
293[0x62] = "||pcmpistrmXrmu",[0x63] = "||pcmpistriXrmu",
294[0xdf] = "||aeskeygenassistXrmu",
295--Fx
296[0xf0] = "||| rorxVrmu",
297},
298}
299
300-- Map for VMX/SVM opcodes 0F 01 C0-FF (sgdt group with register operands).
301local map_opcvm = {
302[0xc1]="vmcall",[0xc2]="vmlaunch",[0xc3]="vmresume",[0xc4]="vmxoff",
303[0xc8]="monitor",[0xc9]="mwait",
304[0xd8]="vmrun",[0xd9]="vmmcall",[0xda]="vmload",[0xdb]="vmsave",
305[0xdc]="stgi",[0xdd]="clgi",[0xde]="skinit",[0xdf]="invlpga",
306[0xf8]="swapgs",[0xf9]="rdtscp",
307}
308
309-- Map for FP opcodes. And you thought stack machines are simple?
310local map_opcfp = {
311-- D8-DF 00-BF: opcodes with a memory operand.
312-- D8
313[0]="faddFm","fmulFm","fcomFm","fcompFm","fsubFm","fsubrFm","fdivFm","fdivrFm",
314"fldFm",nil,"fstFm","fstpFm","fldenvVm","fldcwWm","fnstenvVm","fnstcwWm",
315-- DA
316"fiaddDm","fimulDm","ficomDm","ficompDm",
317"fisubDm","fisubrDm","fidivDm","fidivrDm",
318-- DB
319"fildDm","fisttpDm","fistDm","fistpDm",nil,"fld twordFmp",nil,"fstp twordFmp",
320-- DC
321"faddGm","fmulGm","fcomGm","fcompGm","fsubGm","fsubrGm","fdivGm","fdivrGm",
322-- DD
323"fldGm","fisttpQm","fstGm","fstpGm","frstorDmp",nil,"fnsaveDmp","fnstswWm",
324-- DE
325"fiaddWm","fimulWm","ficomWm","ficompWm",
326"fisubWm","fisubrWm","fidivWm","fidivrWm",
327-- DF
328"fildWm","fisttpWm","fistWm","fistpWm",
329"fbld twordFmp","fildQm","fbstp twordFmp","fistpQm",
330-- xx C0-FF: opcodes with a pseudo-register operand.
331-- D8
332"faddFf","fmulFf","fcomFf","fcompFf","fsubFf","fsubrFf","fdivFf","fdivrFf",
333-- D9
334"fldFf","fxchFf",{"fnop"},nil,
335{"fchs","fabs",nil,nil,"ftst","fxam"},
336{"fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz"},
337{"f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp"},
338{"fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos"},
339-- DA
340"fcmovbFf","fcmoveFf","fcmovbeFf","fcmovuFf",nil,{nil,"fucompp"},nil,nil,
341-- DB
342"fcmovnbFf","fcmovneFf","fcmovnbeFf","fcmovnuFf",
343{nil,nil,"fnclex","fninit"},"fucomiFf","fcomiFf",nil,
344-- DC
345"fadd toFf","fmul toFf",nil,nil,
346"fsub toFf","fsubr toFf","fdivr toFf","fdiv toFf",
347-- DD
348"ffreeFf",nil,"fstFf","fstpFf","fucomFf","fucompFf",nil,nil,
349-- DE
350"faddpFf","fmulpFf",nil,{nil,"fcompp"},
351"fsubrpFf","fsubpFf","fdivrpFf","fdivpFf",
352-- DF
353nil,nil,nil,nil,{"fnstsw ax"},"fucomipFf","fcomipFf",nil,
354}
355assert(map_opcfp[126] == "fcomipFf")
356
357-- Map for opcode groups. The subkey is sp from the ModRM byte.
358local map_opcgroup = {
359  arith = { "add", "or", "adc", "sbb", "and", "sub", "xor", "cmp" },
360  shift = { "rol", "ror", "rcl", "rcr", "shl", "shr", "sal", "sar" },
361  testb = { "testBmi", "testBmi", "not", "neg", "mul", "imul", "div", "idiv" },
362  testv = { "testVmi", "testVmi", "not", "neg", "mul", "imul", "div", "idiv" },
363  incb = { "inc", "dec" },
364  incd = { "inc", "dec", "callUmp", "$call farDmp",
365	   "jmpUmp", "$jmp farDmp", "pushUm" },
366  sldt = { "sldt", "str", "lldt", "ltr", "verr", "verw" },
367  sgdt = { "vm*$sgdt", "vm*$sidt", "$lgdt", "vm*$lidt",
368	   "smsw", nil, "lmsw", "vm*$invlpg" },
369  bt = { nil, nil, nil, nil, "bt", "bts", "btr", "btc" },
370  cmpxchg = { nil, "sz*,cmpxchg8bQmp,cmpxchg16bXmp", nil, nil,
371	      nil, nil, "vmptrld|vmxon|vmclear", "vmptrst" },
372  pshiftw = { nil, nil, "psrlw", nil, "psraw", nil, "psllw" },
373  pshiftd = { nil, nil, "psrld", nil, "psrad", nil, "pslld" },
374  pshiftq = { nil, nil, "psrlq", nil, nil, nil, "psllq" },
375  pshiftdq = { nil, nil, "psrlq", "psrldq", nil, nil, "psllq", "pslldq" },
376  fxsave = { "$fxsave", "$fxrstor", "$ldmxcsr", "$stmxcsr",
377	     nil, "lfenceDp$", "mfenceDp$", "sfenceDp$clflush" },
378  prefetch = { "prefetch", "prefetchw" },
379  prefetcht = { "prefetchnta", "prefetcht0", "prefetcht1", "prefetcht2" },
380}
381
382------------------------------------------------------------------------------
383
384-- Maps for register names.
385local map_regs = {
386  B = { "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
387	"r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" },
388  B64 = { "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
389	  "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" },
390  W = { "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
391	"r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" },
392  D = { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
393	"r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" },
394  Q = { "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
395	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" },
396  M = { "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
397	"mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7" }, -- No x64 ext!
398  X = { "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
399	"xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15" },
400  Y = { "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
401	"ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15" },
402}
403local map_segregs = { "es", "cs", "ss", "ds", "fs", "gs", "segr6", "segr7" }
404
405-- Maps for size names.
406local map_sz2n = {
407  B = 1, W = 2, D = 4, Q = 8, M = 8, X = 16, Y = 32,
408}
409local map_sz2prefix = {
410  B = "byte", W = "word", D = "dword",
411  Q = "qword",
412  M = "qword", X = "xword", Y = "yword",
413  F = "dword", G = "qword", -- No need for sizes/register names for these two.
414}
415
416------------------------------------------------------------------------------
417
418-- Output a nicely formatted line with an opcode and operands.
419local function putop(ctx, text, operands)
420  local code, pos, hex = ctx.code, ctx.pos, ""
421  local hmax = ctx.hexdump
422  if hmax > 0 then
423    for i=ctx.start,pos-1 do
424      hex = hex..format("%02X", byte(code, i, i))
425    end
426    if #hex > hmax then hex = sub(hex, 1, hmax)..". "
427    else hex = hex..rep(" ", hmax-#hex+2) end
428  end
429  if operands then text = text.." "..operands end
430  if ctx.o16 then text = "o16 "..text; ctx.o16 = false end
431  if ctx.a32 then text = "a32 "..text; ctx.a32 = false end
432  if ctx.rep then text = ctx.rep.." "..text; ctx.rep = false end
433  if ctx.rex then
434    local t = (ctx.rexw and "w" or "")..(ctx.rexr and "r" or "")..
435	      (ctx.rexx and "x" or "")..(ctx.rexb and "b" or "")..
436	      (ctx.vexl and "l" or "")
437    if ctx.vexv and ctx.vexv ~= 0 then t = t.."v"..ctx.vexv end
438    if t ~= "" then text = ctx.rex.."."..t.." "..gsub(text, "^ ", "")
439    elseif ctx.rex == "vex" then text = gsub("v"..text, "^v ", "") end
440    ctx.rexw = false; ctx.rexr = false; ctx.rexx = false; ctx.rexb = false
441    ctx.rex = false; ctx.vexl = false; ctx.vexv = false
442  end
443  if ctx.seg then
444    local text2, n = gsub(text, "%[", "["..ctx.seg..":")
445    if n == 0 then text = ctx.seg.." "..text else text = text2 end
446    ctx.seg = false
447  end
448  if ctx.lock then text = "lock "..text; ctx.lock = false end
449  local imm = ctx.imm
450  if imm then
451    local sym = ctx.symtab[imm]
452    if sym then text = text.."\t->"..sym end
453  end
454  ctx.out(format("%08x  %s%s\n", ctx.addr+ctx.start, hex, text))
455  ctx.mrm = false
456  ctx.vexv = false
457  ctx.start = pos
458  ctx.imm = nil
459end
460
461-- Clear all prefix flags.
462local function clearprefixes(ctx)
463  ctx.o16 = false; ctx.seg = false; ctx.lock = false; ctx.rep = false
464  ctx.rexw = false; ctx.rexr = false; ctx.rexx = false; ctx.rexb = false
465  ctx.rex = false; ctx.a32 = false; ctx.vexl = false
466end
467
468-- Fallback for incomplete opcodes at the end.
469local function incomplete(ctx)
470  ctx.pos = ctx.stop+1
471  clearprefixes(ctx)
472  return putop(ctx, "(incomplete)")
473end
474
475-- Fallback for unknown opcodes.
476local function unknown(ctx)
477  clearprefixes(ctx)
478  return putop(ctx, "(unknown)")
479end
480
481-- Return an immediate of the specified size.
482local function getimm(ctx, pos, n)
483  if pos+n-1 > ctx.stop then return incomplete(ctx) end
484  local code = ctx.code
485  if n == 1 then
486    local b1 = byte(code, pos, pos)
487    return b1
488  elseif n == 2 then
489    local b1, b2 = byte(code, pos, pos+1)
490    return b1+b2*256
491  else
492    local b1, b2, b3, b4 = byte(code, pos, pos+3)
493    local imm = b1+b2*256+b3*65536+b4*16777216
494    ctx.imm = imm
495    return imm
496  end
497end
498
499-- Process pattern string and generate the operands.
500local function putpat(ctx, name, pat)
501  local operands, regs, sz, mode, sp, rm, sc, rx, sdisp
502  local code, pos, stop, vexl = ctx.code, ctx.pos, ctx.stop, ctx.vexl
503
504  -- Chars used: 1DFGHIMPQRSTUVWXYabcdfgijlmoprstuvwxyz
505  for p in gmatch(pat, ".") do
506    local x = nil
507    if p == "V" or p == "U" then
508      if ctx.rexw then sz = "Q"; ctx.rexw = false
509      elseif ctx.o16 then sz = "W"; ctx.o16 = false
510      elseif p == "U" and ctx.x64 then sz = "Q"
511      else sz = "D" end
512      regs = map_regs[sz]
513    elseif p == "T" then
514      if ctx.rexw then sz = "Q"; ctx.rexw = false else sz = "D" end
515      regs = map_regs[sz]
516    elseif p == "B" then
517      sz = "B"
518      regs = ctx.rex and map_regs.B64 or map_regs.B
519    elseif match(p, "[WDQMXYFG]") then
520      sz = p
521      if sz == "X" and vexl then sz = "Y"; ctx.vexl = false end
522      regs = map_regs[sz]
523    elseif p == "P" then
524      sz = ctx.o16 and "X" or "M"; ctx.o16 = false
525      if sz == "X" and vexl then sz = "Y"; ctx.vexl = false end
526      regs = map_regs[sz]
527    elseif p == "H" then
528      name = name..(ctx.rexw and "d" or "s")
529      ctx.rexw = false
530    elseif p == "S" then
531      name = name..lower(sz)
532    elseif p == "s" then
533      local imm = getimm(ctx, pos, 1); if not imm then return end
534      x = imm <= 127 and format("+0x%02x", imm)
535		     or format("-0x%02x", 256-imm)
536      pos = pos+1
537    elseif p == "u" then
538      local imm = getimm(ctx, pos, 1); if not imm then return end
539      x = format("0x%02x", imm)
540      pos = pos+1
541    elseif p == "b" then
542      local imm = getimm(ctx, pos, 1); if not imm then return end
543      x = regs[imm/16+1]
544      pos = pos+1
545    elseif p == "w" then
546      local imm = getimm(ctx, pos, 2); if not imm then return end
547      x = format("0x%x", imm)
548      pos = pos+2
549    elseif p == "o" then -- [offset]
550      if ctx.x64 then
551	local imm1 = getimm(ctx, pos, 4); if not imm1 then return end
552	local imm2 = getimm(ctx, pos+4, 4); if not imm2 then return end
553	x = format("[0x%08x%08x]", imm2, imm1)
554	pos = pos+8
555      else
556	local imm = getimm(ctx, pos, 4); if not imm then return end
557	x = format("[0x%08x]", imm)
558	pos = pos+4
559      end
560    elseif p == "i" or p == "I" then
561      local n = map_sz2n[sz]
562      if n == 8 and ctx.x64 and p == "I" then
563	local imm1 = getimm(ctx, pos, 4); if not imm1 then return end
564	local imm2 = getimm(ctx, pos+4, 4); if not imm2 then return end
565	x = format("0x%08x%08x", imm2, imm1)
566      else
567	if n == 8 then n = 4 end
568	local imm = getimm(ctx, pos, n); if not imm then return end
569	if sz == "Q" and (imm < 0 or imm > 0x7fffffff) then
570	  imm = (0xffffffff+1)-imm
571	  x = format(imm > 65535 and "-0x%08x" or "-0x%x", imm)
572	else
573	  x = format(imm > 65535 and "0x%08x" or "0x%x", imm)
574	end
575      end
576      pos = pos+n
577    elseif p == "j" then
578      local n = map_sz2n[sz]
579      if n == 8 then n = 4 end
580      local imm = getimm(ctx, pos, n); if not imm then return end
581      if sz == "B" and imm > 127 then imm = imm-256
582      elseif imm > 2147483647 then imm = imm-4294967296 end
583      pos = pos+n
584      imm = imm + pos + ctx.addr
585      if imm > 4294967295 and not ctx.x64 then imm = imm-4294967296 end
586      ctx.imm = imm
587      if sz == "W" then
588	x = format("word 0x%04x", imm%65536)
589      elseif ctx.x64 then
590	local lo = imm % 0x1000000
591	x = format("0x%02x%06x", (imm-lo) / 0x1000000, lo)
592      else
593	x = "0x"..tohex(imm)
594      end
595    elseif p == "R" then
596      local r = byte(code, pos-1, pos-1)%8
597      if ctx.rexb then r = r + 8; ctx.rexb = false end
598      x = regs[r+1]
599    elseif p == "a" then x = regs[1]
600    elseif p == "c" then x = "cl"
601    elseif p == "d" then x = "dx"
602    elseif p == "1" then x = "1"
603    else
604      if not mode then
605	mode = ctx.mrm
606	if not mode then
607	  if pos > stop then return incomplete(ctx) end
608	  mode = byte(code, pos, pos)
609	  pos = pos+1
610	end
611	rm = mode%8; mode = (mode-rm)/8
612	sp = mode%8; mode = (mode-sp)/8
613	sdisp = ""
614	if mode < 3 then
615	  if rm == 4 then
616	    if pos > stop then return incomplete(ctx) end
617	    sc = byte(code, pos, pos)
618	    pos = pos+1
619	    rm = sc%8; sc = (sc-rm)/8
620	    rx = sc%8; sc = (sc-rx)/8
621	    if ctx.rexx then rx = rx + 8; ctx.rexx = false end
622	    if rx == 4 then rx = nil end
623	  end
624	  if mode > 0 or rm == 5 then
625	    local dsz = mode
626	    if dsz ~= 1 then dsz = 4 end
627	    local disp = getimm(ctx, pos, dsz); if not disp then return end
628	    if mode == 0 then rm = nil end
629	    if rm or rx or (not sc and ctx.x64 and not ctx.a32) then
630	      if dsz == 1 and disp > 127 then
631		sdisp = format("-0x%x", 256-disp)
632	      elseif disp >= 0 and disp <= 0x7fffffff then
633		sdisp = format("+0x%x", disp)
634	      else
635		sdisp = format("-0x%x", (0xffffffff+1)-disp)
636	      end
637	    else
638	      sdisp = format(ctx.x64 and not ctx.a32 and
639		not (disp >= 0 and disp <= 0x7fffffff)
640		and "0xffffffff%08x" or "0x%08x", disp)
641	    end
642	    pos = pos+dsz
643	  end
644	end
645	if rm and ctx.rexb then rm = rm + 8; ctx.rexb = false end
646	if ctx.rexr then sp = sp + 8; ctx.rexr = false end
647      end
648      if p == "m" then
649	if mode == 3 then x = regs[rm+1]
650	else
651	  local aregs = ctx.a32 and map_regs.D or ctx.aregs
652	  local srm, srx = "", ""
653	  if rm then srm = aregs[rm+1]
654	  elseif not sc and ctx.x64 and not ctx.a32 then srm = "rip" end
655	  ctx.a32 = false
656	  if rx then
657	    if rm then srm = srm.."+" end
658	    srx = aregs[rx+1]
659	    if sc > 0 then srx = srx.."*"..(2^sc) end
660	  end
661	  x = format("[%s%s%s]", srm, srx, sdisp)
662	end
663	if mode < 3 and
664	   (not match(pat, "[aRrgp]") or match(pat, "t")) then -- Yuck.
665	  x = map_sz2prefix[sz].." "..x
666	end
667      elseif p == "r" then x = regs[sp+1]
668      elseif p == "g" then x = map_segregs[sp+1]
669      elseif p == "p" then -- Suppress prefix.
670      elseif p == "f" then x = "st"..rm
671      elseif p == "x" then
672	if sp == 0 and ctx.lock and not ctx.x64 then
673	  x = "CR8"; ctx.lock = false
674	else
675	  x = "CR"..sp
676	end
677      elseif p == "v" then
678	if ctx.vexv then
679	  x = regs[ctx.vexv+1]; ctx.vexv = false
680	end
681      elseif p == "y" then x = "DR"..sp
682      elseif p == "z" then x = "TR"..sp
683      elseif p == "l" then vexl = false
684      elseif p == "t" then
685      else
686	error("bad pattern `"..pat.."'")
687      end
688    end
689    if x then operands = operands and operands..", "..x or x end
690  end
691  ctx.pos = pos
692  return putop(ctx, name, operands)
693end
694
695-- Forward declaration.
696local map_act
697
698-- Fetch and cache MRM byte.
699local function getmrm(ctx)
700  local mrm = ctx.mrm
701  if not mrm then
702    local pos = ctx.pos
703    if pos > ctx.stop then return nil end
704    mrm = byte(ctx.code, pos, pos)
705    ctx.pos = pos+1
706    ctx.mrm = mrm
707  end
708  return mrm
709end
710
711-- Dispatch to handler depending on pattern.
712local function dispatch(ctx, opat, patgrp)
713  if not opat then return unknown(ctx) end
714  if match(opat, "%|") then -- MMX/SSE variants depending on prefix.
715    local p
716    if ctx.rep then
717      p = ctx.rep=="rep" and "%|([^%|]*)" or "%|[^%|]*%|[^%|]*%|([^%|]*)"
718      ctx.rep = false
719    elseif ctx.o16 then p = "%|[^%|]*%|([^%|]*)"; ctx.o16 = false
720    else p = "^[^%|]*" end
721    opat = match(opat, p)
722    if not opat then return unknown(ctx) end
723--    ctx.rep = false; ctx.o16 = false
724    --XXX fails for 66 f2 0f 38 f1 06  crc32 eax,WORD PTR [esi]
725    --XXX remove in branches?
726  end
727  if match(opat, "%$") then -- reg$mem variants.
728    local mrm = getmrm(ctx); if not mrm then return incomplete(ctx) end
729    opat = match(opat, mrm >= 192 and "^[^%$]*" or "%$(.*)")
730    if opat == "" then return unknown(ctx) end
731  end
732  if opat == "" then return unknown(ctx) end
733  local name, pat = match(opat, "^([a-z0-9 ]*)(.*)")
734  if pat == "" and patgrp then pat = patgrp end
735  return map_act[sub(pat, 1, 1)](ctx, name, pat)
736end
737
738-- Get a pattern from an opcode map and dispatch to handler.
739local function dispatchmap(ctx, opcmap)
740  local pos = ctx.pos
741  local opat = opcmap[byte(ctx.code, pos, pos)]
742  pos = pos + 1
743  ctx.pos = pos
744  return dispatch(ctx, opat)
745end
746
747-- Map for action codes. The key is the first char after the name.
748map_act = {
749  -- Simple opcodes without operands.
750  [""] = function(ctx, name, pat)
751    return putop(ctx, name)
752  end,
753
754  -- Operand size chars fall right through.
755  B = putpat, W = putpat, D = putpat, Q = putpat,
756  V = putpat, U = putpat, T = putpat,
757  M = putpat, X = putpat, P = putpat,
758  F = putpat, G = putpat, Y = putpat,
759  H = putpat,
760
761  -- Collect prefixes.
762  [":"] = function(ctx, name, pat)
763    ctx[pat == ":" and name or sub(pat, 2)] = name
764    if ctx.pos - ctx.start > 5 then return unknown(ctx) end -- Limit #prefixes.
765  end,
766
767  -- Chain to special handler specified by name.
768  ["*"] = function(ctx, name, pat)
769    return map_act[name](ctx, name, sub(pat, 2))
770  end,
771
772  -- Use named subtable for opcode group.
773  ["!"] = function(ctx, name, pat)
774    local mrm = getmrm(ctx); if not mrm then return incomplete(ctx) end
775    return dispatch(ctx, map_opcgroup[name][((mrm-(mrm%8))/8)%8+1], sub(pat, 2))
776  end,
777
778  -- o16,o32[,o64] variants.
779  sz = function(ctx, name, pat)
780    if ctx.o16 then ctx.o16 = false
781    else
782      pat = match(pat, ",(.*)")
783      if ctx.rexw then
784	local p = match(pat, ",(.*)")
785	if p then pat = p; ctx.rexw = false end
786      end
787    end
788    pat = match(pat, "^[^,]*")
789    return dispatch(ctx, pat)
790  end,
791
792  -- Two-byte opcode dispatch.
793  opc2 = function(ctx, name, pat)
794    return dispatchmap(ctx, map_opc2)
795  end,
796
797  -- Three-byte opcode dispatch.
798  opc3 = function(ctx, name, pat)
799    return dispatchmap(ctx, map_opc3[pat])
800  end,
801
802  -- VMX/SVM dispatch.
803  vm = function(ctx, name, pat)
804    return dispatch(ctx, map_opcvm[ctx.mrm])
805  end,
806
807  -- Special NOP for endbr64/endbr32.
808  endbr = function(ctx, name, pat)
809    if ctx.rep then
810      local pos = ctx.pos
811      local b = byte(ctx.code, pos)
812      local text
813      if b == 0xfa then text = "endbr64"
814      elseif b == 0xfb then text = "endbr64"
815      end
816      if text then
817	ctx.pos = pos + 1
818	ctx.rep = nil
819	return putop(ctx, text)
820      end
821    end
822    return dispatch(ctx, pat)
823  end,
824
825  -- Floating point opcode dispatch.
826  fp = function(ctx, name, pat)
827    local mrm = getmrm(ctx); if not mrm then return incomplete(ctx) end
828    local rm = mrm%8
829    local idx = pat*8 + ((mrm-rm)/8)%8
830    if mrm >= 192 then idx = idx + 64 end
831    local opat = map_opcfp[idx]
832    if type(opat) == "table" then opat = opat[rm+1] end
833    return dispatch(ctx, opat)
834  end,
835
836  -- REX prefix.
837  rex = function(ctx, name, pat)
838    if ctx.rex then return unknown(ctx) end -- Only 1 REX or VEX prefix allowed.
839    for p in gmatch(pat, ".") do ctx["rex"..p] = true end
840    ctx.rex = "rex"
841  end,
842
843  -- VEX prefix.
844  vex = function(ctx, name, pat)
845    if ctx.rex then return unknown(ctx) end -- Only 1 REX or VEX prefix allowed.
846    ctx.rex = "vex"
847    local pos = ctx.pos
848    if ctx.mrm then
849      ctx.mrm = nil
850      pos = pos-1
851    end
852    local b = byte(ctx.code, pos, pos)
853    if not b then return incomplete(ctx) end
854    pos = pos+1
855    if b < 128 then ctx.rexr = true end
856    local m = 1
857    if pat == "3" then
858      m = b%32; b = (b-m)/32
859      local nb = b%2; b = (b-nb)/2
860      if nb == 0 then ctx.rexb = true end
861      local nx = b%2
862      if nx == 0 then ctx.rexx = true end
863      b = byte(ctx.code, pos, pos)
864      if not b then return incomplete(ctx) end
865      pos = pos+1
866      if b >= 128 then ctx.rexw = true end
867    end
868    ctx.pos = pos
869    local map
870    if m == 1 then map = map_opc2
871    elseif m == 2 then map = map_opc3["38"]
872    elseif m == 3 then map = map_opc3["3a"]
873    else return unknown(ctx) end
874    local p = b%4; b = (b-p)/4
875    if p == 1 then ctx.o16 = "o16"
876    elseif p == 2 then ctx.rep = "rep"
877    elseif p == 3 then ctx.rep = "repne" end
878    local l = b%2; b = (b-l)/2
879    if l ~= 0 then ctx.vexl = true end
880    ctx.vexv = (-1-b)%16
881    return dispatchmap(ctx, map)
882  end,
883
884  -- Special case for nop with REX prefix.
885  nop = function(ctx, name, pat)
886    return dispatch(ctx, ctx.rex and pat or "nop")
887  end,
888
889  -- Special case for 0F 77.
890  emms = function(ctx, name, pat)
891    if ctx.rex ~= "vex" then
892      return putop(ctx, "emms")
893    elseif ctx.vexl then
894      ctx.vexl = false
895      return putop(ctx, "zeroall")
896    else
897      return putop(ctx, "zeroupper")
898    end
899  end,
900}
901
902------------------------------------------------------------------------------
903
904-- Disassemble a block of code.
905local function disass_block(ctx, ofs, len)
906  if not ofs then ofs = 0 end
907  local stop = len and ofs+len or #ctx.code
908  ofs = ofs + 1
909  ctx.start = ofs
910  ctx.pos = ofs
911  ctx.stop = stop
912  ctx.imm = nil
913  ctx.mrm = false
914  clearprefixes(ctx)
915  while ctx.pos <= stop do dispatchmap(ctx, ctx.map1) end
916  if ctx.pos ~= ctx.start then incomplete(ctx) end
917end
918
919-- Extended API: create a disassembler context. Then call ctx:disass(ofs, len).
920local function create(code, addr, out)
921  local ctx = {}
922  ctx.code = code
923  ctx.addr = (addr or 0) - 1
924  ctx.out = out or io.write
925  ctx.symtab = {}
926  ctx.disass = disass_block
927  ctx.hexdump = 16
928  ctx.x64 = false
929  ctx.map1 = map_opc1_32
930  ctx.aregs = map_regs.D
931  return ctx
932end
933
934local function create64(code, addr, out)
935  local ctx = create(code, addr, out)
936  ctx.x64 = true
937  ctx.map1 = map_opc1_64
938  ctx.aregs = map_regs.Q
939  return ctx
940end
941
942-- Simple API: disassemble code (a string) at address and output via out.
943local function disass(code, addr, out)
944  create(code, addr, out):disass()
945end
946
947local function disass64(code, addr, out)
948  create64(code, addr, out):disass()
949end
950
951-- Return register name for RID.
952local function regname(r)
953  if r < 8 then return map_regs.D[r+1] end
954  return map_regs.X[r-7]
955end
956
957local function regname64(r)
958  if r < 16 then return map_regs.Q[r+1] end
959  return map_regs.X[r-15]
960end
961
962-- Public module functions.
963return {
964  create = create,
965  create64 = create64,
966  disass = disass,
967  disass64 = disass64,
968  regname = regname,
969  regname64 = regname64
970}
971