dis_x86.lua

采用C语言写的Lua的解释器的代码！Lua不用介绍了吧

  if #hex > 16 then hex = sub(hex, 1, 16).."." end
  if operands then text = text.." "..operands end
  if ctx.o16 then text = "o16 "..text; ctx.o16 = false end
  if ctx.rep then text = ctx.rep.." "..text; ctx.rep = false end
  if ctx.seg then
    local text2, n = gsub(text, "%[", "["..ctx.seg..":")
    if n == 0 then text = ctx.seg.." "..text else text = text2 end
    ctx.seg = false
  end
  if ctx.lock then text = "lock "..text; ctx.lock = false end
  local imm = ctx.imm
  if imm then
    local sym = ctx.symtab[imm]
    if sym then text = text.."\t->"..sym end
  end
  ctx.out(format("%08x  %-18s%s\n", ctx.addr+ctx.start, hex, text))
  ctx.mrm = false
  ctx.start = pos
  ctx.imm = nil
end

-- Fallback for incomplete opcodes at the end.
local function incomplete(ctx)
  ctx.pos = ctx.stop+1
  ctx.o16 = false; ctx.seg = false; ctx.lock = false; ctx.rep = false
  return putop(ctx, "(incomplete)")
end

-- Fallback for unknown opcodes.
local function unknown(ctx)
  ctx.o16 = false; ctx.seg = false; ctx.lock = false; ctx.rep = false
  return putop(ctx, "(unknown)")
end

-- Return an immediate of the specified size.
local function getimm(ctx, pos, n)
  if pos+n-1 > ctx.stop then return incomplete(ctx) end
  local code = ctx.code
  if n == 1 then
    local b1 = byte(code, pos, pos)
    return b1
  elseif n == 2 then
    local b1, b2 = byte(code, pos, pos+1)
    return b1+b2*256
  else
    local b1, b2, b3, b4 = byte(code, pos, pos+3)
    local imm = b1+b2*256+b3*65536+b4*16777216
    ctx.imm = imm
    return imm
  end
end

-- Process pattern string and generate the operands.
local function putpat(ctx, name, pat)
  local operands, regs, sz, mode, sp, rm, sc, rx, disp, sdisp
  local code, pos, stop = ctx.code, ctx.pos, ctx.stop

  -- Chars used: 1DFGMPQRVWXacdfgijmoprsuwxyz
  for p in gmatch(pat, ".") do
    local x = nil
    if p == "V" then
      sz = ctx.o16 and "W" or "D"; ctx.o16 = false
      regs = map_regs[sz]
    elseif match(p, "[BWDQFGMX]") then
      sz = p
      regs = map_regs[sz]
    elseif p == "P" then
      sz = ctx.o16 and "X" or "M"; ctx.o16 = false
      regs = map_regs[sz]
    elseif p == "s" then
      local imm = getimm(ctx, pos, 1); if not imm then return end
      x = imm <= 127 and format("byte +0x%02x", imm)
		     or format("byte -0x%02x", 256-imm)
      pos = pos+1
    elseif p == "u" then
      local imm = getimm(ctx, pos, 1); if not imm then return end
      x = format("0x%02x", imm)
      pos = pos+1
    elseif p == "w" then
      local imm = getimm(ctx, pos, 2); if not imm then return end
      x = format("0x%x", imm)
      pos = pos+2
    elseif p == "o" then -- [offset]
      local imm = getimm(ctx, pos, 4); if not imm then return end
      x = format("[0x%08x]", imm)
      pos = pos+4
    elseif p == "i" then
      local n = map_sz2n[sz]
      local imm = getimm(ctx, pos, n); if not imm then return end
      x = format(imm > 65535 and "0x%08x" or "0x%x", imm)
      pos = pos+n
    elseif p == "j" then
      local n = map_sz2n[sz]
      local imm = getimm(ctx, pos, n); if not imm then return end
      if sz == "B" and imm > 127 then imm = imm-256
      elseif imm > 2147483647 then imm = imm-4294967296 end
      pos = pos+n
      imm = imm + pos + ctx.addr
      ctx.imm = imm
      x = sz == "W" and format("word 0x%04x", imm%65536)
		    or format("0x%08x", imm)
    elseif p == "R" then x = regs[byte(code, pos-1, pos-1)%8+1]
    elseif p == "a" then x = regs[1]
    elseif p == "c" then x = "cl"
    elseif p == "d" then x = "dx"
    elseif p == "1" then x = "1"
    else
      if not mode then
	mode = ctx.mrm
	if not mode then
	  if pos > stop then return incomplete(ctx) end
	  mode = byte(code, pos, pos)
	  pos = pos+1
	end
	rm = mode%8; mode = (mode-rm)/8
	sp = mode%8; mode = (mode-sp)/8
	sdisp = ""
	if mode < 3 then
	  if rm == 4 then
	    if pos > stop then return incomplete(ctx) end
	    sc = byte(code, pos, pos)
	    pos = pos+1
	    rm = sc%8; sc = (sc-rm)/8
	    rx = sc%8; sc = (sc-rx)/8
	    if rx == 4 then rx = nil end
	  end
	  if mode > 0 or rm == 5 then
	    local dsz = mode
	    if dsz ~= 1 then dsz = 4 end
	    disp = getimm(ctx, pos, dsz); if not disp then return end
	    sdisp = (dsz == 4 or disp <= 127) and
		    format(disp > 65535 and "+0x%08x" or "+0x%x", disp) or
		    format("-0x%x", 256-disp)
	    pos = pos+dsz
	  end
	end
      end
      if p == "m" then
	if mode == 3 then x = regs[rm+1]
	else
	  local srm, srx = map_aregs[rm+1], ""
	  if rx then
	    srm = srm.."+"
	    srx = map_aregs[rx+1]
	    if sc > 0 then srx = srx.."*"..(2^sc) end
	  end
	  if mode == 0 and rm == 5 then
	    srm = ""
	    sdisp = format("%s0x%08x", rx and "+" or "", disp)
	  end
	  x = format("[%s%s%s]", srm, srx, sdisp)
	end
	if mode < 3 and
	   (not match(pat, "[aRrgp]") or
	    name == "movzx" or name == "movsx") then -- Yuck.
	  x = map_sz2prefix[sz].." "..x
	end
      elseif p == "r" then x = regs[sp+1]
      elseif p == "g" then x = map_segregs[sp+1]
      elseif p == "p" then -- Suppress prefix.
      elseif p == "f" then x = "st"..rm
      elseif p == "x" then x = "CR"..sp
      elseif p == "y" then x = "DR"..sp
      elseif p == "z" then x = "TR"..sp
      else
	error("bad pattern `"..pat.."'")
      end
    end
    if x then operands = operands and operands..","..x or x end
  end
  ctx.pos = pos
  return putop(ctx, name, operands)
end

-- Forward declaration.
local map_act

-- Get a pattern from an opcode map and dispatch to handler.
local function opcdispatch(ctx, opcmap)
  local pos = ctx.pos
  local opat = opcmap[byte(ctx.code, pos, pos)]
  if not opat then return unknown(ctx) end
  if match(opat, "%|") then -- MMX/SSE variants depending on prefix.
    local p
    if ctx.rep then p = ctx.rep=="rep" and "%|([^%|]*)" or "%|.-%|.-%|([^%|]*)"
    elseif ctx.o16 then p = "%|.-%|([^%|]*)"
    else p = "^[^%|]*" end
    opat = match(opat, p)
    if not opat or opat == "" then return unknown(ctx) end
    ctx.rep = false; ctx.o16 = false
  end
  local name, pat, act = match(opat, "^([a-z0-9 ]*)((.?).*)")
  ctx.pos = pos + 1
  return map_act[act](ctx, name, pat)
end

-- Map for action codes. The key is the first char after the name.
map_act = {
  -- Simple opcodes without operands.
  [""] = function(ctx, name, pat)
    return putop(ctx, name)
  end,

  -- Operand size chars fall right through.
  B = putpat, W = putpat, D = putpat, V = putpat,
  F = putpat, G = putpat,
  M = putpat, X = putpat, P = putpat,

  -- Collect prefixes.
  [":"] = function(ctx, name, pat)
    ctx[pat == ":" and name or sub(pat, 2)] = name
  end,

  -- Select alternate opcode name when prefixed with o16.
  ["/"] = function(ctx, name, pat)
    local wname, rpat = match(pat, "^/([a-z0-9 ]+)(.*)")
    if ctx.o16 then name = wname; ctx.o16 = false end
    return putpat(ctx, name, rpat)
  end,

  -- Chain to special handler specified by name.
  ["*"] = function(ctx, name, pat)
    return map_act[name](ctx, name, sub(pat, 2))
  end,

  -- Use named subtable for opcode group.
  ["!"] = function(ctx, name, pat)

    local pos = ctx.pos
    if pos > ctx.stop then return incomplete(ctx) end
    local mrm = byte(ctx.code, pos, pos)
    ctx.pos = pos+1
    ctx.mrm = mrm

    local opat = map_opcgroup[name][((mrm-(mrm%8))/8)%8+1]
    if not opat then return unknown(ctx) end
    local name, pat2 = match(opat, "^([a-z0-9 ]*)(.*)")
    return putpat(ctx, name, pat2 ~= "" and pat2 or sub(pat, 2))
  end,

  -- Two-byte opcode dispatch.
  opc2 = function(ctx, name, pat)
    return opcdispatch(ctx, map_opc2)
  end,

  -- SSSE3 dispatch.
  ssse3 = function(ctx, name, pat)
    return opcdispatch(ctx, map_ssse3[pat])
  end,

  -- Floating point opcode dispatch.
  fp = function(ctx, name, pat)

    local pos = ctx.pos
    if pos > ctx.stop then return incomplete(ctx) end
    local mrm = byte(ctx.code, pos, pos)
    ctx.pos = pos+1
    ctx.mrm = mrm

    local rm = mrm%8
    local idx = pat*8 + ((mrm-rm)/8)%8
    if mrm >= 192 then idx = idx + 64 end
    local opat = map_opcfp[idx]
    if type(opat) == "table" then opat = opat[rm+1] end
    if not opat then return unknown(ctx) end
    local name, pat2 = match(opat, "^([a-z0-9 ]*)(.*)")
    return putpat(ctx, name, pat2)
  end,
}

------------------------------------------------------------------------------

-- Disassemble a block of code.
local function disass_block(ctx, ofs, len)
  if not ofs then ofs = 0 end
  local stop = len and ofs+len or #ctx.code
  ofs = ofs + 1
  ctx.start = ofs
  ctx.pos = ofs
  ctx.stop = stop
  ctx.imm = nil
  ctx.mrm = false
  ctx.o16 = false; ctx.seg = false; ctx.lock = false; ctx.rep = false
  while ctx.pos <= stop do opcdispatch(ctx, map_opc1) end
  if ctx.pos ~= ctx.start then incomplete(ctx) end
end

-- Extended API: create a disassembler context. Then call ctx:disass(ofs, len).
local function create_(code, addr, out)
  local ctx = {}
  ctx.code = code
  ctx.addr = (addr or 0) - 1
  ctx.out = out or io.write
  ctx.symtab = {}
  ctx.disass = disass_block
  return ctx
end

-- Simple API: disassemble code (a string) at address and output via out.
local function disass_(code, addr, out)
  create_(code, addr, out):disass()
end


-- Public module functions.
module(...)

create = create_
disass = disass_