MIPS: Add DynASM MIPS module and encoding engine.

2 files changed, 1363 insertions, 0 deletions

diff --git a/dynasm/dasm_mips.h b/dynasm/dasm_mips.h
new file mode 100644
index 00000000..832f9f2e
--- /dev/null
+++ b/dynasm/dasm_mips.h
@@ -0,0 +1,415 @@
+/*
+** DynASM MIPS encoding engine.
+** Copyright (C) 2005-2011 Mike Pall. All rights reserved.
+** Released under the MIT license. See dynasm.lua for full copyright notice.
+*/
+
+#include <stddef.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define DASM_ARCH               "mips"
+
+#ifndef DASM_EXTERN
+#define DASM_EXTERN(a,b,c,d)    0
+#endif
+
+/* Action definitions. */
+enum {
+  DASM_STOP, DASM_SECTION, DASM_ESC, DASM_REL_EXT,
+  /* The following actions need a buffer position. */
+  DASM_ALIGN, DASM_REL_LG, DASM_LABEL_LG,
+  /* The following actions also have an argument. */
+  DASM_REL_PC, DASM_LABEL_PC, DASM_IMM,
+  DASM__MAX
+};
+
+/* Maximum number of section buffer positions for a single dasm_put() call. */
+#define DASM_MAXSECPOS          25
+
+/* DynASM encoder status codes. Action list offset or number are or'ed in. */
+#define DASM_S_OK               0x00000000
+#define DASM_S_NOMEM            0x01000000
+#define DASM_S_PHASE            0x02000000
+#define DASM_S_MATCH_SEC        0x03000000
+#define DASM_S_RANGE_I          0x11000000
+#define DASM_S_RANGE_SEC        0x12000000
+#define DASM_S_RANGE_LG         0x13000000
+#define DASM_S_RANGE_PC         0x14000000
+#define DASM_S_RANGE_REL        0x15000000
+#define DASM_S_UNDEF_LG         0x21000000
+#define DASM_S_UNDEF_PC         0x22000000
+
+/* Macros to convert positions (8 bit section + 24 bit index). */
+#define DASM_POS2IDX(pos)       ((pos)&0x00ffffff)
+#define DASM_POS2BIAS(pos)      ((pos)&0xff000000)
+#define DASM_SEC2POS(sec)       ((sec)<<24)
+#define DASM_POS2SEC(pos)       ((pos)>>24)
+#define DASM_POS2PTR(D, pos)    (D->sections[DASM_POS2SEC(pos)].rbuf + (pos))
+
+/* Action list type. */
+typedef const unsigned int *dasm_ActList;
+
+/* Per-section structure. */
+typedef struct dasm_Section {
+  int *rbuf;            /* Biased buffer pointer (negative section bias). */
+  int *buf;             /* True buffer pointer. */
+  size_t bsize;         /* Buffer size in bytes. */
+  int pos;              /* Biased buffer position. */
+  int epos;             /* End of biased buffer position - max single put. */
+  int ofs;              /* Byte offset into section. */
+} dasm_Section;
+
+/* Core structure holding the DynASM encoding state. */
+struct dasm_State {
+  size_t psize;                 /* Allocated size of this structure. */
+  dasm_ActList actionlist;      /* Current actionlist pointer. */
+  int *lglabels;                /* Local/global chain/pos ptrs. */
+  size_t lgsize;
+  int *pclabels;                /* PC label chains/pos ptrs. */
+  size_t pcsize;
+  void **globals;               /* Array of globals (bias -10). */
+  dasm_Section *section;        /* Pointer to active section. */
+  size_t codesize;              /* Total size of all code sections. */
+  int maxsection;               /* 0 <= sectionidx < maxsection. */
+  int status;                   /* Status code. */
+  dasm_Section sections[1];     /* All sections. Alloc-extended. */
+};
+
+/* The size of the core structure depends on the max. number of sections. */
+#define DASM_PSZ(ms)    (sizeof(dasm_State)+(ms-1)*sizeof(dasm_Section))
+
+
+/* Initialize DynASM state. */
+void dasm_init(Dst_DECL, int maxsection)
+{
+  dasm_State *D;
+  size_t psz = 0;
+  int i;
+  Dst_REF = NULL;
+  DASM_M_GROW(Dst, struct dasm_State, Dst_REF, psz, DASM_PSZ(maxsection));
+  D = Dst_REF;
+  D->psize = psz;
+  D->lglabels = NULL;
+  D->lgsize = 0;
+  D->pclabels = NULL;
+  D->pcsize = 0;
+  D->globals = NULL;
+  D->maxsection = maxsection;
+  for (i = 0; i < maxsection; i++) {
+    D->sections[i].buf = NULL;  /* Need this for pass3. */
+    D->sections[i].rbuf = D->sections[i].buf - DASM_SEC2POS(i);
+    D->sections[i].bsize = 0;
+    D->sections[i].epos = 0;  /* Wrong, but is recalculated after resize. */
+  }
+}
+
+/* Free DynASM state. */
+void dasm_free(Dst_DECL)
+{
+  dasm_State *D = Dst_REF;
+  int i;
+  for (i = 0; i < D->maxsection; i++)
+    if (D->sections[i].buf)
+      DASM_M_FREE(Dst, D->sections[i].buf, D->sections[i].bsize);
+  if (D->pclabels) DASM_M_FREE(Dst, D->pclabels, D->pcsize);
+  if (D->lglabels) DASM_M_FREE(Dst, D->lglabels, D->lgsize);
+  DASM_M_FREE(Dst, D, D->psize);
+}
+
+/* Setup global label array. Must be called before dasm_setup(). */
+void dasm_setupglobal(Dst_DECL, void **gl, unsigned int maxgl)
+{
+  dasm_State *D = Dst_REF;
+  D->globals = gl - 10;  /* Negative bias to compensate for locals. */
+  DASM_M_GROW(Dst, int, D->lglabels, D->lgsize, (10+maxgl)*sizeof(int));
+}
+
+/* Grow PC label array. Can be called after dasm_setup(), too. */
+void dasm_growpc(Dst_DECL, unsigned int maxpc)
+{
+  dasm_State *D = Dst_REF;
+  size_t osz = D->pcsize;
+  DASM_M_GROW(Dst, int, D->pclabels, D->pcsize, maxpc*sizeof(int));
+  memset((void *)(((unsigned char *)D->pclabels)+osz), 0, D->pcsize-osz);
+}
+
+/* Setup encoder. */
+void dasm_setup(Dst_DECL, const void *actionlist)
+{
+  dasm_State *D = Dst_REF;
+  int i;
+  D->actionlist = (dasm_ActList)actionlist;
+  D->status = DASM_S_OK;
+  D->section = &D->sections[0];
+  memset((void *)D->lglabels, 0, D->lgsize);
+  if (D->pclabels) memset((void *)D->pclabels, 0, D->pcsize);
+  for (i = 0; i < D->maxsection; i++) {
+    D->sections[i].pos = DASM_SEC2POS(i);
+    D->sections[i].ofs = 0;
+  }
+}
+
+
+#ifdef DASM_CHECKS
+#define CK(x, st) \
+  do { if (!(x)) { \
+    D->status = DASM_S_##st|(p-D->actionlist-1); return; } } while (0)
+#define CKPL(kind, st) \
+  do { if ((size_t)((char *)pl-(char *)D->kind##labels) >= D->kind##size) { \
+    D->status = DASM_S_RANGE_##st|(p-D->actionlist-1); return; } } while (0)
+#else
+#define CK(x, st)       ((void)0)
+#define CKPL(kind, st)  ((void)0)
+#endif
+
+/* Pass 1: Store actions and args, link branches/labels, estimate offsets. */
+void dasm_put(Dst_DECL, int start, ...)
+{
+  va_list ap;
+  dasm_State *D = Dst_REF;
+  dasm_ActList p = D->actionlist + start;
+  dasm_Section *sec = D->section;
+  int pos = sec->pos, ofs = sec->ofs;
+  int *b;
+
+  if (pos >= sec->epos) {
+    DASM_M_GROW(Dst, int, sec->buf, sec->bsize,
+      sec->bsize + 2*DASM_MAXSECPOS*sizeof(int));
+    sec->rbuf = sec->buf - DASM_POS2BIAS(pos);
+    sec->epos = (int)sec->bsize/sizeof(int) - DASM_MAXSECPOS+DASM_POS2BIAS(pos);
+  }
+
+  b = sec->rbuf;
+  b[pos++] = start;
+
+  va_start(ap, start);
+  while (1) {
+    unsigned int ins = *p++;
+    unsigned int action = (ins >> 16) - 0xff00;
+    if (action >= DASM__MAX) {
+      ofs += 4;
+    } else {
+      int *pl, n = action >= DASM_REL_PC ? va_arg(ap, int) : 0;
+      switch (action) {
+      case DASM_STOP: goto stop;
+      case DASM_SECTION:
+        n = (ins & 255); CK(n < D->maxsection, RANGE_SEC);
+        D->section = &D->sections[n]; goto stop;
+      case DASM_ESC: p++; ofs += 4; break;
+      case DASM_REL_EXT: break;
+      case DASM_ALIGN: ofs += (ins & 255); b[pos++] = ofs; break;
+      case DASM_REL_LG:
+        n = (ins & 2047) - 10; pl = D->lglabels + n;
+        if (n >= 0) { CKPL(lg, LG); goto putrel; }  /* Bkwd rel or global. */
+        pl += 10; n = *pl;
+        if (n < 0) n = 0;  /* Start new chain for fwd rel if label exists. */
+        goto linkrel;
+      case DASM_REL_PC:
+        pl = D->pclabels + n; CKPL(pc, PC);
+      putrel:
+        n = *pl;
+        if (n < 0) {  /* Label exists. Get label pos and store it. */
+          b[pos] = -n;
+        } else {
+      linkrel:
+          b[pos] = n;  /* Else link to rel chain, anchored at label. */
+          *pl = pos;
+        }
+        pos++;
+        break;
+      case DASM_LABEL_LG:
+        pl = D->lglabels + (ins & 2047) - 10; CKPL(lg, LG); goto putlabel;
+      case DASM_LABEL_PC:
+        pl = D->pclabels + n; CKPL(pc, PC);
+      putlabel:
+        n = *pl;  /* n > 0: Collapse rel chain and replace with label pos. */
+        while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = pos;
+        }
+        *pl = -pos;  /* Label exists now. */
+        b[pos++] = ofs;  /* Store pass1 offset estimate. */
+        break;
+      case DASM_IMM:
+#ifdef DASM_CHECKS
+        CK((n & ((1<<((ins>>10)&31))-1)) == 0, RANGE_I);
+#endif
+        n >>= ((ins>>10)&31);
+#ifdef DASM_CHECKS
+        if (ins & 0x8000)
+          CK(((n + (1<<(((ins>>5)&31)-1)))>>((ins>>5)&31)) == 0, RANGE_I);
+        else
+          CK((n>>((ins>>5)&31)) == 0, RANGE_I);
+#endif
+        b[pos++] = n;
+        break;
+      }
+    }
+  }
+stop:
+  va_end(ap);
+  sec->pos = pos;
+  sec->ofs = ofs;
+}
+#undef CK
+
+/* Pass 2: Link sections, shrink aligns, fix label offsets. */
+int dasm_link(Dst_DECL, size_t *szp)
+{
+  dasm_State *D = Dst_REF;
+  int secnum;
+  int ofs = 0;
+
+#ifdef DASM_CHECKS
+  *szp = 0;
+  if (D->status != DASM_S_OK) return D->status;
+  {
+    int pc;
+    for (pc = 0; pc*sizeof(int) < D->pcsize; pc++)
+      if (D->pclabels[pc] > 0) return DASM_S_UNDEF_PC|pc;
+  }
+#endif
+
+  { /* Handle globals not defined in this translation unit. */
+    int idx;
+    for (idx = 20; idx*sizeof(int) < D->lgsize; idx++) {
+      int n = D->lglabels[idx];
+      /* Undefined label: Collapse rel chain and replace with marker (< 0). */
+      while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = -idx; }
+    }
+  }
+
+  /* Combine all code sections. No support for data sections (yet). */
+  for (secnum = 0; secnum < D->maxsection; secnum++) {
+    dasm_Section *sec = D->sections + secnum;
+    int *b = sec->rbuf;
+    int pos = DASM_SEC2POS(secnum);
+    int lastpos = sec->pos;
+
+    while (pos != lastpos) {
+      dasm_ActList p = D->actionlist + b[pos++];
+      while (1) {
+        unsigned int ins = *p++;
+        unsigned int action = (ins >> 16) - 0xff00;
+        switch (action) {
+        case DASM_STOP: case DASM_SECTION: goto stop;
+        case DASM_ESC: p++; break;
+        case DASM_REL_EXT: break;
+        case DASM_ALIGN: ofs -= (b[pos++] + ofs) & (ins & 255); break;
+        case DASM_REL_LG: case DASM_REL_PC: pos++; break;
+        case DASM_LABEL_LG: case DASM_LABEL_PC: b[pos++] += ofs; break;
+        case DASM_IMM: pos++; break;
+        }
+      }
+      stop: (void)0;
+    }
+    ofs += sec->ofs;  /* Next section starts right after current section. */
+  }
+
+  D->codesize = ofs;  /* Total size of all code sections */
+  *szp = ofs;
+  return DASM_S_OK;
+}
+
+#ifdef DASM_CHECKS
+#define CK(x, st) \
+  do { if (!(x)) return DASM_S_##st|(p-D->actionlist-1); } while (0)
+#else
+#define CK(x, st)       ((void)0)
+#endif
+
+/* Pass 3: Encode sections. */
+int dasm_encode(Dst_DECL, void *buffer)
+{
+  dasm_State *D = Dst_REF;
+  char *base = (char *)buffer;
+  unsigned int *cp = (unsigned int *)buffer;
+  int secnum;
+
+  /* Encode all code sections. No support for data sections (yet). */
+  for (secnum = 0; secnum < D->maxsection; secnum++) {
+    dasm_Section *sec = D->sections + secnum;
+    int *b = sec->buf;
+    int *endb = sec->rbuf + sec->pos;
+
+    while (b != endb) {
+      dasm_ActList p = D->actionlist + *b++;
+      while (1) {
+        unsigned int ins = *p++;
+        unsigned int action = (ins >> 16) - 0xff00;
+        int n = (action >= DASM_ALIGN && action < DASM__MAX) ? *b++ : 0;
+        switch (action) {
+        case DASM_STOP: case DASM_SECTION: goto stop;
+        case DASM_ESC: *cp++ = *p++; break;
+        case DASM_REL_EXT:
+          n = DASM_EXTERN(Dst, (unsigned char *)cp, (ins & 2047), 1);
+          goto patchrel;
+        case DASM_ALIGN:
+          ins &= 255; while ((((char *)cp - base) & ins)) *cp++ = 0x60000000;
+          break;
+        case DASM_REL_LG:
+          CK(n >= 0, UNDEF_LG);
+        case DASM_REL_PC:
+          CK(n >= 0, UNDEF_PC);
+          n = *DASM_POS2PTR(D, n);
+          if (ins & 2048)
+            n = n - (int)((char *)cp - base);
+          else
+            n = (n + (int)base) & 0x0fffffff;
+        patchrel:
+          CK((n & 3) == 0 &&
+             ((n + ((ins & 2048) ? 0x00020000 : 0)) >>
+               ((ins & 2048) ? 18 : 28)) == 0, RANGE_REL);
+          cp[-1] |= ((n>>2) & ((ins & 2048) ? 0x0000ffff: 0x03ffffff));
+          break;
+        case DASM_LABEL_LG:
+          ins &= 2047; if (ins >= 20) D->globals[ins-10] = (void *)(base + n);
+          break;
+        case DASM_LABEL_PC: break;
+        case DASM_IMM:
+          cp[-1] |= (n & ((1<<((ins>>5)&31))-1)) << (ins&31);
+          break;
+        default: *cp++ = ins; break;
+        }
+      }
+      stop: (void)0;
+    }
+  }
+
+  if (base + D->codesize != (char *)cp)  /* Check for phase errors. */
+    return DASM_S_PHASE;
+  return DASM_S_OK;
+}
+#undef CK
+
+/* Get PC label offset. */
+int dasm_getpclabel(Dst_DECL, unsigned int pc)
+{
+  dasm_State *D = Dst_REF;
+  if (pc*sizeof(int) < D->pcsize) {
+    int pos = D->pclabels[pc];
+    if (pos < 0) return *DASM_POS2PTR(D, -pos);
+    if (pos > 0) return -1;  /* Undefined. */
+  }
+  return -2;  /* Unused or out of range. */
+}
+
+#ifdef DASM_CHECKS
+/* Optional sanity checker to call between isolated encoding steps. */
+int dasm_checkstep(Dst_DECL, int secmatch)
+{
+  dasm_State *D = Dst_REF;
+  if (D->status == DASM_S_OK) {
+    int i;
+    for (i = 1; i <= 9; i++) {
+      if (D->lglabels[i] > 0) { D->status = DASM_S_UNDEF_LG|i; break; }
+      D->lglabels[i] = 0;
+    }
+  }
+  if (D->status == DASM_S_OK && secmatch >= 0 &&
+      D->section != &D->sections[secmatch])
+    D->status = DASM_S_MATCH_SEC|(D->section-D->sections);
+  return D->status;
+}
+#endif
+
diff --git a/dynasm/dasm_mips.lua b/dynasm/dasm_mips.lua
new file mode 100644
index 00000000..5cbae8ba
--- /dev/null
+++ b/dynasm/dasm_mips.lua
@@ -0,0 +1,948 @@
+------------------------------------------------------------------------------
+-- DynASM MIPS module.
+--
+-- Copyright (C) 2005-2011 Mike Pall. All rights reserved.
+-- See dynasm.lua for full copyright notice.
+------------------------------------------------------------------------------
+
+-- Module information:
+local _info = {
+  arch =        "mips",
+  description = "DynASM MIPS module",
+  version =     "1.3.0",
+  vernum =       10300,
+  release =     "2011-12-16",
+  author =      "Mike Pall",
+  license =     "MIT",
+}
+
+-- Exported glue functions for the arch-specific module.
+local _M = { _info = _info }
+
+-- Cache library functions.
+local type, tonumber, pairs, ipairs = type, tonumber, pairs, ipairs
+local assert, setmetatable = assert, setmetatable
+local _s = string
+local sub, format, byte, char = _s.sub, _s.format, _s.byte, _s.char
+local match, gmatch = _s.match, _s.gmatch
+local concat, sort = table.concat, table.sort
+
+-- Inherited tables and callbacks.
+local g_opt, g_arch
+local wline, werror, wfatal, wwarn
+
+-- Action name list.
+-- CHECK: Keep this in sync with the C code!
+local action_names = {
+  "STOP", "SECTION", "ESC", "REL_EXT",
+  "ALIGN", "REL_LG", "LABEL_LG",
+  "REL_PC", "LABEL_PC", "IMM",
+}
+
+-- Maximum number of section buffer positions for dasm_put().
+-- CHECK: Keep this in sync with the C code!
+local maxsecpos = 25 -- Keep this low, to avoid excessively long C lines.
+
+-- Action name -> action number.
+local map_action = {}
+for n,name in ipairs(action_names) do
+  map_action[name] = n-1
+end
+
+-- Action list buffer.
+local actlist = {}
+
+-- Argument list for next dasm_put(). Start with offset 0 into action list.
+local actargs = { 0 }
+
+-- Current number of section buffer positions for dasm_put().
+local secpos = 1
+
+------------------------------------------------------------------------------
+
+-- Return 8 digit hex number.
+local function tohex(x)
+  return sub(format("%08x", x), -8) -- Avoid 64 bit portability problem in Lua.
+end
+
+-- Dump action names and numbers.
+local function dumpactions(out)
+  out:write("DynASM encoding engine action codes:\n")
+  for n,name in ipairs(action_names) do
+    local num = map_action[name]
+    out:write(format("  %-10s %02X  %d\n", name, num, num))
+  end
+  out:write("\n")
+end
+
+-- Write action list buffer as a huge static C array.
+local function writeactions(out, name)
+  local nn = #actlist
+  if nn == 0 then nn = 1; actlist[0] = map_action.STOP end
+  out:write("static const unsigned int ", name, "[", nn, "] = {\n")
+  for i = 1,nn-1 do
+    assert(out:write("0x", tohex(actlist[i]), ",\n"))
+  end
+  assert(out:write("0x", tohex(actlist[nn]), "\n};\n\n"))
+end
+
+------------------------------------------------------------------------------
+
+-- Add word to action list.
+local function wputxw(n)
+  assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range")
+  actlist[#actlist+1] = n
+end
+
+-- Add action to list with optional arg. Advance buffer pos, too.
+local function waction(action, val, a, num)
+  local w = assert(map_action[action], "bad action name `"..action.."'")
+  wputxw(0xff000000 + w * 0x10000 + (val or 0))
+  if a then actargs[#actargs+1] = a end
+  if a or num then secpos = secpos + (num or 1) end
+end
+
+-- Flush action list (intervening C code or buffer pos overflow).
+local function wflush(term)
+  if #actlist == actargs[1] then return end -- Nothing to flush.
+  if not term then waction("STOP") end -- Terminate action list.
+  wline(format("dasm_put(Dst, %s);", concat(actargs, ", ")), true)
+  actargs = { #actlist } -- Actionlist offset is 1st arg to next dasm_put().
+  secpos = 1 -- The actionlist offset occupies a buffer position, too.
+end
+
+-- Put escaped word.
+local function wputw(n)
+  if n >= 0xff000000 then waction("ESC") end
+  wputxw(n)
+end
+
+-- Reserve position for word.
+local function wpos()
+  local pos = #actlist+1
+  actlist[pos] = ""
+  return pos
+end
+
+-- Store word to reserved position.
+local function wputpos(pos, n)
+  assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range")
+  actlist[pos] = n
+end
+
+------------------------------------------------------------------------------
+
+-- Global label name -> global label number. With auto assignment on 1st use.
+local next_global = 20
+local map_global = setmetatable({}, { __index = function(t, name)
+  if not match(name, "^[%a_][%w_]*$") then werror("bad global label") end
+  local n = next_global
+  if n > 2047 then werror("too many global labels") end
+  next_global = n + 1
+  t[name] = n
+  return n
+end})
+
+-- Dump global labels.
+local function dumpglobals(out, lvl)
+  local t = {}
+  for name, n in pairs(map_global) do t[n] = name end
+  out:write("Global labels:\n")
+  for i=20,next_global-1 do
+    out:write(format("  %s\n", t[i]))
+  end
+  out:write("\n")
+end
+
+-- Write global label enum.
+local function writeglobals(out, prefix)
+  local t = {}
+  for name, n in pairs(map_global) do t[n] = name end
+  out:write("enum {\n")
+  for i=20,next_global-1 do
+    out:write("  ", prefix, t[i], ",\n")
+  end
+  out:write("  ", prefix, "_MAX\n};\n")
+end
+
+-- Write global label names.
+local function writeglobalnames(out, name)
+  local t = {}
+  for name, n in pairs(map_global) do t[n] = name end
+  out:write("static const char *const ", name, "[] = {\n")
+  for i=20,next_global-1 do
+    out:write("  \"", t[i], "\",\n")
+  end
+  out:write("  (const char *)0\n};\n")
+end
+
+------------------------------------------------------------------------------
+
+-- Extern label name -> extern label number. With auto assignment on 1st use.
+local next_extern = 0
+local map_extern_ = {}
+local map_extern = setmetatable({}, { __index = function(t, name)
+  -- No restrictions on the name for now.
+  local n = next_extern
+  if n > 2047 then werror("too many extern labels") end
+  next_extern = n + 1
+  t[name] = n
+  map_extern_[n] = name
+  return n
+end})
+
+-- Dump extern labels.
+local function dumpexterns(out, lvl)
+  out:write("Extern labels:\n")
+  for i=0,next_extern-1 do
+    out:write(format("  %s\n", map_extern_[i]))
+  end
+  out:write("\n")
+end
+
+-- Write extern label names.
+local function writeexternnames(out, name)
+  out:write("static const char *const ", name, "[] = {\n")
+  for i=0,next_extern-1 do
+    out:write("  \"", map_extern_[i], "\",\n")
+  end
+  out:write("  (const char *)0\n};\n")
+end
+
+------------------------------------------------------------------------------
+
+-- Arch-specific maps.
+local map_archdef = { sp="r29", ra="r31" } -- Ext. register name -> int. name.
+
+local map_type = {}             -- Type name -> { ctype, reg }
+local ctypenum = 0              -- Type number (for Dt... macros).
+
+-- Reverse defines for registers.
+function _M.revdef(s)
+  if s == "r29" then return "sp"
+  elseif s == "r31" then return "ra" end
+  return s
+end
+
+------------------------------------------------------------------------------
+
+-- Template strings for MIPS instructions.
+local map_op = {
+  -- First-level opcodes.
+  j_1 =         "08000000J",
+  jal_1 =       "0c000000J",
+  b_1 =         "10000000B",
+  beqz_2 =      "10000000SB",
+  beq_3 =       "10000000STB",
+  bnez_2 =      "14000000SB",
+  bne_3 =       "14000000STB",
+  blez_2 =      "18000000SB",
+  bgtz_2 =      "1c000000SB",
+  addi_3 =      "20000000TSI",
+  li_2 =        "24000000TI",
+  addiu_3 =     "24000000TSI",
+  slti_3 =      "28000000TSI",
+  sltiu_3 =     "2c000000TSI",
+  andi_3 =      "30000000TSU",
+  lu_2 =        "34000000TU",
+  ori_3 =       "34000000TSU",
+  xori_3 =      "38000000TSU",
+  lui_2 =       "3c000000TU",
+  beqzl_2 =     "50000000SB",
+  beql_3 =      "50000000STB",
+  bnezl_2 =     "54000000SB",
+  bnel_3 =      "54000000STB",
+  blezl_2 =     "58000000SB",
+  bgtzl_2 =     "5c000000SB",
+  lb_2 =        "80000000TO",
+  lh_2 =        "84000000TO",
+  lwl_2 =       "88000000TO",
+  lw_2 =        "8c000000TO",
+  lbu_2 =       "90000000TO",
+  lhu_2 =       "94000000TO",
+  lwr_2 =       "98000000TO",
+  sb_2 =        "a0000000TO",
+  sh_2 =        "a4000000TO",
+  swl_2 =       "a8000000TO",
+  sw_2 =        "ac000000TO",
+  swr_2 =       "b8000000TO",
+  cache_2 =     "bc000000NO",
+  ll_2 =        "c0000000TO",
+  lwc1_2 =      "c4000000HO",
+  pref_2 =      "cc000000NO",
+  ldc1_2 =      "d4000000HO",
+  sc_2 =        "e0000000TO",
+  swc1_2 =      "e4000000HO",
+  sdc1_2 =      "f4000000HO",
+
+  -- Opcode SPECIAL.
+  nop_0 =       "00000000",
+  sll_3 =       "00000000DTA",
+  movf_3 =      "00000001DSC",
+  movt_3 =      "00010001DSC",
+  srl_3 =       "00000002DTA",
+  rotr_3 =      "00200002DTA",
+  sra_3 =       "00000003DTA",
+  sllv_3 =      "00000004DTS",
+  srlv_3 =      "00000006DTS",
+  rotrv_3 =     "00000046DTS",
+  srav_3 =      "00000007DTS",
+  jr_1 =        "00000008S",
+  jalr_1 =      "0000f809S",
+  jalr_2 =      "00000009DS",
+  movz_3 =      "0000000aDST",
+  movn_3 =      "0000000bDST",
+  syscall_0 =   "0000000c",
+  syscall_1 =   "0000000cY",
+  break_0 =     "0000000d",
+  break_1 =     "0000000dY",
+  sync_0 =      "0000000f",
+  mfhi_1 =      "00000010D",
+  mthi_1 =      "00000011S",
+  mflo_1 =      "00000012D",
+  mtlo_1 =      "00000013S",
+  mult_2 =      "00000018ST",
+  multu_2 =     "00000019ST",
+  div_2 =       "0000001aST",
+  divu_2 =      "0000001bST",
+  add_3 =       "00000020DST",
+  move_2 =      "00000021DS",
+  addu_3 =      "00000021DST",
+  sub_3 =       "00000022DST",
+  subu_3 =      "00000023DST",
+  and_3 =       "00000024DST",
+  or_3 =        "00000025DST",
+  xor_3 =       "00000026DST",
+  nor_3 =       "00000027DST",
+  slt_3 =       "0000002aDST",
+  sltu_3 =      "0000002bDST",
+  tge_2 =       "00000030ST",
+  tge_3 =       "00000030STZ",
+  tgeu_2 =      "00000031ST",
+  tgeu_3 =      "00000031STZ",
+  tlt_2 =       "00000032ST",
+  tlt_3 =       "00000032STZ",
+  tltu_2 =      "00000033ST",
+  tltu_3 =      "00000033STZ",
+  teq_2 =       "00000034ST",
+  teq_3 =       "00000034STZ",
+  tne_2 =       "00000036ST",
+  tne_3 =       "00000036STZ",
+
+  -- Opcode REGIMM.
+  bltz_2 =      "04000000SB",
+  bgez_2 =      "04010000SB",
+  bltzl_2 =     "04020000SB",
+  bgezl_2 =     "04030000SB",
+  tgei_2 =      "04080000SI",
+  tgeiu_2 =     "04090000SI",
+  tlti_2 =      "040a0000SI",
+  tltiu_2 =     "040b0000SI",
+  teqi_2 =      "040c0000SI",
+  tnei_2 =      "040e0000SI",
+  bltzal_2 =    "04100000SB",
+  bgezal_2 =    "04110000SB",
+  bltzall_2 =   "04120000SB",
+  bgezall_2 =   "04130000SB",
+  synci_1 =     "041f0000O",
+
+  -- Opcode SPECIAL2.
+  madd_2 =      "70000000ST",
+  maddu_2 =     "70000001ST",
+  mul_3 =       "70000002DST",
+  msub_2 =      "70000004ST",
+  msubu_2 =     "70000005ST",
+  clz_2 =       "70000020DS=",
+  clo_2 =       "70000021DS=",
+  sdbbp_0 =     "7000003f",
+  sdbbp_1 =     "7000003fY",
+
+  -- Opcode SPECIAL3.
+  ext_4 =       "7c000000TSAM", -- Note: last arg is msbd = size-1
+  ins_4 =       "7c000004TSAM", -- Note: last arg is msb = pos+size-1
+  wsbh_2 =      "7c0000a0DT",
+  seb_2 =       "7c000420DT",
+  seh_2 =       "7c000620DT",
+  rdhwr_2 =     "7c00003bTD",
+
+  -- Opcode COP0.
+  mfc0_2 =      "40000000TD",
+  mfc0_3 =      "40000000TDW",
+  mtc0_2 =      "40800000TD",
+  mtc0_3 =      "40800000TDW",
+  rdpgpr_2 =    "41400000DT",
+  di_0 =        "41606000",
+  di_1 =        "41606000T",
+  ei_0 =        "41606020",
+  ei_1 =        "41606020T",
+  wrpgpr_2 =    "41c00000DT",
+  tlbr_0 =      "42000001",
+  tlbwi_0 =     "42000002",
+  tlbwr_0 =     "42000006",
+  tlbp_0 =      "42000008",
+  eret_0 =      "42000018",
+  deret_0 =     "4200001f",
+  wait_0 =      "42000020",
+
+  -- Opcode COP1.
+  mfc1_2 =      "44000000TG",
+  cfc1_2 =      "44400000TG",
+  mfhc1_2 =     "44600000TG",
+  mtc1_2 =      "44800000TG",
+  ctc1_2 =      "44c00000TG",
+  mthc1_2 =     "44e00000TG",
+
+  bc1f_1 =      "45000000B",
+  bc1f_2 =      "45000000CB",
+  bc1t_1 =      "45010000B",
+  bc1t_2 =      "45010000CB",
+  bc1fl_1 =     "45020000B",
+  bc1fl_2 =     "45020000CB",
+  bc1tl_1 =     "45030000B",
+  bc1tl_2 =     "45030000CB",
+
+  ["add.s_3"] =         "46000000FGH",
+  ["sub.s_3"] =         "46000001FGH",
+  ["mul.s_3"] =         "46000002FGH",
+  ["div.s_3"] =         "46000003FGH",
+  ["sqrt.s_2"] =        "46000004FG",
+  ["abs.s_2"] =         "46000005FG",
+  ["mov.s_2"] =         "46000006FG",
+  ["neg.s_2"] =         "46000007FG",
+  ["round.l.s_2"] =     "46000008FG",
+  ["trunc.l.s_2"] =     "46000009FG",
+  ["ceil.l.s_2"] =      "4600000aFG",
+  ["floor.l.s_2"] =     "4600000bFG",
+  ["round.w.s_2"] =     "4600000cFG",
+  ["trunc.w.s_2"] =     "4600000dFG",
+  ["ceil.w.s_2"] =      "4600000eFG",
+  ["floor.w.s_2"] =     "4600000fFG",
+  ["movf.s_2"] =        "46000011FG",
+  ["movf.s_3"] =        "46000011FGC",
+  ["movt.s_2"] =        "46010011FG",
+  ["movt.s_3"] =        "46010011FGC",
+  ["movz.s_3"] =        "46000012FGT",
+  ["movn.s_3"] =        "46000013FGT",
+  ["recip.s_2"] =       "46000015FG",
+  ["rsqrt.s_2"] =       "46000016FG",
+  ["cvt.d.s_2"] =       "46000021FG",
+  ["cvt.w.s_2"] =       "46000024FG",
+  ["cvt.l.s_2"] =       "46000025FG",
+  ["cvt.ps.s_3"] =      "46000026FGH",
+  ["c.f.s_2"] =         "46000030GH",
+  ["c.f.s_3"] =         "46000030VGH",
+  ["c.un.s_2"] =        "46000031GH",
+  ["c.un.s_3"] =        "46000031VGH",
+  ["c.eq.s_2"] =        "46000032GH",
+  ["c.eq.s_3"] =        "46000032VGH",
+  ["c.ueq.s_2"] =       "46000033GH",
+  ["c.ueq.s_3"] =       "46000033VGH",
+  ["c.olt.s_2"] =       "46000034GH",
+  ["c.olt.s_3"] =       "46000034VGH",
+  ["c.ult.s_2"] =       "46000035GH",
+  ["c.ult.s_3"] =       "46000035VGH",
+  ["c.ole.s_2"] =       "46000036GH",
+  ["c.ole.s_3"] =       "46000036VGH",
+  ["c.ule.s_2"] =       "46000037GH",
+  ["c.ule.s_3"] =       "46000037VGH",
+  ["c.sf.s_2"] =        "46000038GH",
+  ["c.sf.s_3"] =        "46000038VGH",
+  ["c.ngle.s_2"] =      "46000039GH",
+  ["c.ngle.s_3"] =      "46000039VGH",
+  ["c.seq.s_2"] =       "4600003aGH",
+  ["c.seq.s_3"] =       "4600003aVGH",
+  ["c.ngl.s_2"] =       "4600003bGH",
+  ["c.ngl.s_3"] =       "4600003bVGH",
+  ["c.lt.s_2"] =        "4600003cGH",
+  ["c.lt.s_3"] =        "4600003cVGH",
+  ["c.nge.s_2"] =       "4600003dGH",
+  ["c.nge.s_3"] =       "4600003dVGH",
+  ["c.le.s_2"] =        "4600003eGH",
+  ["c.le.s_3"] =        "4600003eVGH",
+  ["c.ngt.s_2"] =       "4600003fGH",
+  ["c.ngt.s_3"] =       "4600003fVGH",
+
+  ["add.d_3"] =         "46200000FGH",
+  ["sub.d_3"] =         "46200001FGH",
+  ["mul.d_3"] =         "46200002FGH",
+  ["div.d_3"] =         "46200003FGH",
+  ["sqrt.d_2"] =        "46200004FG",
+  ["abs.d_2"] =         "46200005FG",
+  ["mov.d_2"] =         "46200006FG",
+  ["neg.d_2"] =         "46200007FG",
+  ["round.l.d_2"] =     "46200008FG",
+  ["trunc.l.d_2"] =     "46200009FG",
+  ["ceil.l.d_2"] =      "4620000aFG",
+  ["floor.l.d_2"] =     "4620000bFG",
+  ["round.w.d_2"] =     "4620000cFG",
+  ["trunc.w.d_2"] =     "4620000dFG",
+  ["ceil.w.d_2"] =      "4620000eFG",
+  ["floor.w.d_2"] =     "4620000fFG",
+  ["movf.d_2"] =        "46200011FG",
+  ["movf.d_3"] =        "46200011FGC",
+  ["movt.d_2"] =        "46210011FG",
+  ["movt.d_3"] =        "46210011FGC",
+  ["movz.d_3"] =        "46200012FGT",
+  ["movn.d_3"] =        "46200013FGT",
+  ["recip.d_2"] =       "46200015FG",
+  ["rsqrt.d_2"] =       "46200016FG",
+  ["cvt.s.d_2"] =       "46200020FG",
+  ["cvt.w.d_2"] =       "46200024FG",
+  ["cvt.l.d_2"] =       "46200025FG",
+  ["c.f.d_2"] =         "46200030GH",
+  ["c.f.d_3"] =         "46200030VGH",
+  ["c.un.d_2"] =        "46200031GH",
+  ["c.un.d_3"] =        "46200031VGH",
+  ["c.eq.d_2"] =        "46200032GH",
+  ["c.eq.d_3"] =        "46200032VGH",
+  ["c.ueq.d_2"] =       "46200033GH",
+  ["c.ueq.d_3"] =       "46200033VGH",
+  ["c.olt.d_2"] =       "46200034GH",
+  ["c.olt.d_3"] =       "46200034VGH",
+  ["c.ult.d_2"] =       "46200035GH",
+  ["c.ult.d_3"] =       "46200035VGH",
+  ["c.ole.d_2"] =       "46200036GH",
+  ["c.ole.d_3"] =       "46200036VGH",
+  ["c.ule.d_2"] =       "46200037GH",
+  ["c.ule.d_3"] =       "46200037VGH",
+  ["c.sf.d_2"] =        "46200038GH",
+  ["c.sf.d_3"] =        "46200038VGH",
+  ["c.ngle.d_2"] =      "46200039GH",
+  ["c.ngle.d_3"] =      "46200039VGH",
+  ["c.seq.d_2"] =       "4620003aGH",
+  ["c.seq.d_3"] =       "4620003aVGH",
+  ["c.ngl.d_2"] =       "4620003bGH",
+  ["c.ngl.d_3"] =       "4620003bVGH",
+  ["c.lt.d_2"] =        "4620003cGH",
+  ["c.lt.d_3"] =        "4620003cVGH",
+  ["c.nge.d_2"] =       "4620003dGH",
+  ["c.nge.d_3"] =       "4620003dVGH",
+  ["c.le.d_2"] =        "4620003eGH",
+  ["c.le.d_3"] =        "4620003eVGH",
+  ["c.ngt.d_2"] =       "4620003fGH",
+  ["c.ngt.d_3"] =       "4620003fVGH",
+
+  ["add.ps_3"] =        "46c00000FGH",
+  ["sub.ps_3"] =        "46c00001FGH",
+  ["mul.ps_3"] =        "46c00002FGH",
+  ["abs.ps_2"] =        "46c00005FG",
+  ["mov.ps_2"] =        "46c00006FG",
+  ["neg.ps_2"] =        "46c00007FG",
+  ["movf.ps_2"] =       "46c00011FG",
+  ["movf.ps_3"] =       "46c00011FGC",
+  ["movt.ps_2"] =       "46c10011FG",
+  ["movt.ps_3"] =       "46c10011FGC",
+  ["movz.ps_3"] =       "46c00012FGT",
+  ["movn.ps_3"] =       "46c00013FGT",
+  ["cvt.s.pu_2"] =      "46c00020FG",
+  ["cvt.s.pl_2"] =      "46c00028FG",
+  ["pll.ps_3"] =        "46c0002cFGH",
+  ["plu.ps_3"] =        "46c0002dFGH",
+  ["pul.ps_3"] =        "46c0002eFGH",
+  ["puu.ps_3"] =        "46c0002fFGH",
+  ["c.f.ps_2"] =        "46c00030GH",
+  ["c.f.ps_3"] =        "46c00030VGH",
+  ["c.un.ps_2"] =       "46c00031GH",
+  ["c.un.ps_3"] =       "46c00031VGH",
+  ["c.eq.ps_2"] =       "46c00032GH",
+  ["c.eq.ps_3"] =       "46c00032VGH",
+  ["c.ueq.ps_2"] =      "46c00033GH",
+  ["c.ueq.ps_3"] =      "46c00033VGH",
+  ["c.olt.ps_2"] =      "46c00034GH",
+  ["c.olt.ps_3"] =      "46c00034VGH",
+  ["c.ult.ps_2"] =      "46c00035GH",
+  ["c.ult.ps_3"] =      "46c00035VGH",
+  ["c.ole.ps_2"] =      "46c00036GH",
+  ["c.ole.ps_3"] =      "46c00036VGH",
+  ["c.ule.ps_2"] =      "46c00037GH",
+  ["c.ule.ps_3"] =      "46c00037VGH",
+  ["c.sf.ps_2"] =       "46c00038GH",
+  ["c.sf.ps_3"] =       "46c00038VGH",
+  ["c.ngle.ps_2"] =     "46c00039GH",
+  ["c.ngle.ps_3"] =     "46c00039VGH",
+  ["c.seq.ps_2"] =      "46c0003aGH",
+  ["c.seq.ps_3"] =      "46c0003aVGH",
+  ["c.ngl.ps_2"] =      "46c0003bGH",
+  ["c.ngl.ps_3"] =      "46c0003bVGH",
+  ["c.lt.ps_2"] =       "46c0003cGH",
+  ["c.lt.ps_3"] =       "46c0003cVGH",
+  ["c.nge.ps_2"] =      "46c0003dGH",
+  ["c.nge.ps_3"] =      "46c0003dVGH",
+  ["c.le.ps_2"] =       "46c0003eGH",
+  ["c.le.ps_3"] =       "46c0003eVGH",
+  ["c.ngt.ps_2"] =      "46c0003fGH",
+  ["c.ngt.ps_3"] =      "46c0003fVGH",
+
+  ["cvt.s.w_2"] =       "46800020FG",
+  ["cvt.d.w_2"] =       "46800021FG",
+
+  ["cvt.s.l_2"] =       "46a00020FG",
+  ["cvt.d.l_2"] =       "46a00021FG",
+
+  -- Opcode COP1X.
+  lwxc1_2 =             "4c000000FX",
+  ldxc1_2 =             "4c000001FX",
+  luxc1_2 =             "4c000005FX",
+  swxc1_2 =             "4c000008FX",
+  sdxc1_2 =             "4c000009FX",
+  suxc1_2 =             "4c00000dFX",
+  prefx_2 =             "4c00000fMX",
+  ["alnv.ps_4"] =       "4c00001eFGHS",
+  ["madd.s_4"] =        "4c000020FRGH",
+  ["madd.d_4"] =        "4c000021FRGH",
+  ["madd.ps_4"] =       "4c000026FRGH",
+  ["msub.s_4"] =        "4c000028FRGH",
+  ["msub.d_4"] =        "4c000029FRGH",
+  ["msub.ps_4"] =       "4c00002eFRGH",
+  ["nmadd.s_4"] =       "4c000030FRGH",
+  ["nmadd.d_4"] =       "4c000031FRGH",
+  ["nmadd.ps_4"] =      "4c000036FRGH",
+  ["nmsub.s_4"] =       "4c000038FRGH",
+  ["nmsub.d_4"] =       "4c000039FRGH",
+  ["nmsub.ps_4"] =      "4c00003eFRGH",
+}
+
+------------------------------------------------------------------------------
+
+local function parse_gpr(expr)
+  local tname, ovreg = match(expr, "^([%w_]+):(r[1-3]?[0-9])$")
+  local tp = map_type[tname or expr]
+  if tp then
+    local reg = ovreg or tp.reg
+    if not reg then
+      werror("type `"..(tname or expr).."' needs a register override")
+    end
+    expr = reg
+  end
+  local r = match(expr, "^r([1-3]?[0-9])$")
+  if r then
+    r = tonumber(r)
+    if r <= 31 then return r, tp end
+  end
+  werror("bad register name `"..expr.."'")
+end
+
+local function parse_fpr(expr)
+  local r = match(expr, "^f([1-3]?[0-9])$")
+  if r then
+    r = tonumber(r)
+    if r <= 31 then return r end
+  end
+  werror("bad register name `"..expr.."'")
+end
+
+local function parse_imm(imm, bits, shift, scale, signed)
+  local n = tonumber(imm)
+  if n then
+    if n % 2^scale == 0 then
+      n = n / 2^scale
+      if signed then
+        if n >= 0 then
+          if n < 2^(bits-1) then return n*2^shift end
+        else
+          if n >= -(2^(bits-1))-1 then return (n+2^bits)*2^shift end
+        end
+      else
+        if n >= 0 and n <= 2^bits-1 then return n*2^shift end
+      end
+    end
+    werror("out of range immediate `"..imm.."'")
+  elseif match(imm, "^[rf]([1-3]?[0-9])$") or
+         match(imm, "^([%w_]+):([rf][1-3]?[0-9])$") then
+    werror("expected immediate operand, got register")
+  else
+    waction("IMM", (signed and 32768 or 0)+scale*1024+bits*32+shift, imm)
+    return 0
+  end
+end
+
+local function parse_disp(disp)
+  local imm, reg = match(disp, "^(.*)%(([%w_:]+)%)$")
+  if imm then
+    local r = parse_gpr(reg)
+    return r*2^21 + parse_imm(imm, 16, 0, 0, true)
+  end
+  local reg, tailr = match(disp, "^([%w_:]+)%s*(.*)$")
+  if reg and tailr ~= "" then
+    local r, tp = parse_gpr(reg)
+    if tp then
+      waction("IMM", 32768+16*32, format(tp.ctypefmt, tailr))
+      return r*2^21
+    end
+  end
+  werror("bad displacement `"..disp.."'")
+end
+
+local function parse_index(idx)
+  local rt, rs = match(idx, "^(.*)%(([%w_:]+)%)$")
+  if rt then
+    rt = parse_gpr(rt)
+    rs = parse_gpr(rs)
+    return rt*2^16 + rs*2^21
+  end
+  werror("bad index `"..idx.."'")
+end
+
+local function parse_label(label, def)
+  local prefix = sub(label, 1, 2)
+  -- =>label (pc label reference)
+  if prefix == "=>" then
+    return "PC", 0, sub(label, 3)
+  end
+  -- ->name (global label reference)
+  if prefix == "->" then
+    return "LG", map_global[sub(label, 3)]
+  end
+  if def then
+    -- [1-9] (local label definition)
+    if match(label, "^[1-9]$") then
+      return "LG", 10+tonumber(label)
+    end
+  else
+    -- [<>][1-9] (local label reference)
+    local dir, lnum = match(label, "^([<>])([1-9])$")
+    if dir then -- Fwd: 1-9, Bkwd: 11-19.
+      return "LG", lnum + (dir == ">" and 0 or 10)
+    end
+    -- extern label (extern label reference)
+    local extname = match(label, "^extern%s+(%S+)$")
+    if extname then
+      return "EXT", map_extern[extname]
+    end
+  end
+  werror("bad label `"..label.."'")
+end
+
+------------------------------------------------------------------------------
+
+-- Handle opcodes defined with template strings.
+map_op[".template__"] = function(params, template, nparams)
+  if not params then return sub(template, 9) end
+  local op = tonumber(sub(template, 1, 8), 16)
+  local n = 1
+
+  -- Limit number of section buffer positions used by a single dasm_put().
+  -- A single opcode needs a maximum of 2 positions (ins/ext).
+  if secpos+2 > maxsecpos then wflush() end
+  local pos = wpos()
+
+  -- Process each character.
+  for p in gmatch(sub(template, 9), ".") do
+    if p == "D" then
+      op = op + parse_gpr(params[n]) * 2^11; n = n + 1
+    elseif p == "T" then
+      op = op + parse_gpr(params[n]) * 2^16; n = n + 1
+    elseif p == "S" then
+      op = op + parse_gpr(params[n]) * 2^21; n = n + 1
+    elseif p == "F" then
+      op = op + parse_fpr(params[n]) * 2^6; n = n + 1
+    elseif p == "G" then
+      op = op + parse_fpr(params[n]) * 2^11; n = n + 1
+    elseif p == "H" then
+      op = op + parse_fpr(params[n]) * 2^16; n = n + 1
+    elseif p == "R" then
+      op = op + parse_fpr(params[n]) * 2^21; n = n + 1
+    elseif p == "I" then
+      op = op + parse_imm(params[n], 16, 0, 0, true); n = n + 1
+    elseif p == "U" then
+      op = op + parse_imm(params[n], 16, 0, 0, false); n = n + 1
+    elseif p == "O" then
+      op = op + parse_disp(params[n]); n = n + 1
+    elseif p == "X" then
+      op = op + parse_index(params[n]); n = n + 1
+    elseif p == "B" or p == "J" then
+      local mode, n, s = parse_label(params[n], false)
+      if p == "B" then n = n + 2048 end
+      waction("REL_"..mode, n, s, 1)
+      n = n + 1
+    elseif p == "A" then
+      op = op + parse_imm(params[n], 5, 6, 0, false); n = n + 1
+    elseif p == "M" then
+      op = op + parse_imm(params[n], 5, 11, 0, false); n = n + 1
+    elseif p == "N" then
+      op = op + parse_imm(params[n], 5, 16, 0, false); n = n + 1
+    elseif p == "C" then
+      op = op + parse_imm(params[n], 3, 18, 0, false); n = n + 1
+    elseif p == "V" then
+      op = op + parse_imm(params[n], 3, 8, 0, false); n = n + 1
+    elseif p == "W" then
+      op = op + parse_imm(params[n], 3, 0, 0, false); n = n + 1
+    elseif p == "Y" then
+      op = op + parse_imm(params[n], 20, 6, 0, false); n = n + 1
+    elseif p == "Z" then
+      op = op + parse_imm(params[n], 10, 6, 0, false); n = n + 1
+    elseif p == "=" then
+      local d = ((op - op % 2^11) / 2^11) % 32
+      op = op + d * 2^16 -- Copy D to T for clz, clo.
+    else
+      assert(false)
+    end
+  end
+  wputpos(pos, op)
+end
+
+------------------------------------------------------------------------------
+
+-- Pseudo-opcode to mark the position where the action list is to be emitted.
+map_op[".actionlist_1"] = function(params)
+  if not params then return "cvar" end
+  local name = params[1] -- No syntax check. You get to keep the pieces.
+  wline(function(out) writeactions(out, name) end)
+end
+
+-- Pseudo-opcode to mark the position where the global enum is to be emitted.
+map_op[".globals_1"] = function(params)
+  if not params then return "prefix" end
+  local prefix = params[1] -- No syntax check. You get to keep the pieces.
+  wline(function(out) writeglobals(out, prefix) end)
+end
+
+-- Pseudo-opcode to mark the position where the global names are to be emitted.
+map_op[".globalnames_1"] = function(params)
+  if not params then return "cvar" end
+  local name = params[1] -- No syntax check. You get to keep the pieces.
+  wline(function(out) writeglobalnames(out, name) end)
+end
+
+-- Pseudo-opcode to mark the position where the extern names are to be emitted.
+map_op[".externnames_1"] = function(params)
+  if not params then return "cvar" end
+  local name = params[1] -- No syntax check. You get to keep the pieces.
+  wline(function(out) writeexternnames(out, name) end)
+end
+
+------------------------------------------------------------------------------
+
+-- Label pseudo-opcode (converted from trailing colon form).
+map_op[".label_1"] = function(params)
+  if not params then return "[1-9] | ->global | =>pcexpr" end
+  if secpos+1 > maxsecpos then wflush() end
+  local mode, n, s = parse_label(params[1], true)
+  if mode == "EXT" then werror("bad label definition") end
+  waction("LABEL_"..mode, n, s, 1)
+end
+
+------------------------------------------------------------------------------
+
+-- Pseudo-opcodes for data storage.
+map_op[".long_*"] = function(params)
+  if not params then return "imm..." end
+  for _,p in ipairs(params) do
+    local n = tonumber(p)
+    if not n then werror("bad immediate `"..p.."'") end
+    if n < 0 then n = n + 2^32 end
+    wputw(n)
+    if secpos+2 > maxsecpos then wflush() end
+  end
+end
+
+-- Alignment pseudo-opcode.
+map_op[".align_1"] = function(params)
+  if not params then return "numpow2" end
+  if secpos+1 > maxsecpos then wflush() end
+  local align = tonumber(params[1])
+  if align then
+    local x = align
+    -- Must be a power of 2 in the range (2 ... 256).
+    for i=1,8 do
+      x = x / 2
+      if x == 1 then
+        waction("ALIGN", align-1, nil, 1) -- Action byte is 2**n-1.
+        return
+      end
+    end
+  end
+  werror("bad alignment")
+end
+
+------------------------------------------------------------------------------
+
+-- Pseudo-opcode for (primitive) type definitions (map to C types).
+map_op[".type_3"] = function(params, nparams)
+  if not params then
+    return nparams == 2 and "name, ctype" or "name, ctype, reg"
+  end
+  local name, ctype, reg = params[1], params[2], params[3]
+  if not match(name, "^[%a_][%w_]*$") then
+    werror("bad type name `"..name.."'")
+  end
+  local tp = map_type[name]
+  if tp then
+    werror("duplicate type `"..name.."'")
+  end
+  -- Add #type to defines. A bit unclean to put it in map_archdef.
+  map_archdef["#"..name] = "sizeof("..ctype..")"
+  -- Add new type and emit shortcut define.
+  local num = ctypenum + 1
+  map_type[name] = {
+    ctype = ctype,
+    ctypefmt = format("Dt%X(%%s)", num),
+    reg = reg,
+  }
+  wline(format("#define Dt%X(_V) (int)(ptrdiff_t)&(((%s *)0)_V)", num, ctype))
+  ctypenum = num
+end
+map_op[".type_2"] = map_op[".type_3"]
+
+-- Dump type definitions.
+local function dumptypes(out, lvl)
+  local t = {}
+  for name in pairs(map_type) do t[#t+1] = name end
+  sort(t)
+  out:write("Type definitions:\n")
+  for _,name in ipairs(t) do
+    local tp = map_type[name]
+    local reg = tp.reg or ""
+    out:write(format("  %-20s %-20s %s\n", name, tp.ctype, reg))
+  end
+  out:write("\n")
+end
+
+------------------------------------------------------------------------------
+
+-- Set the current section.
+function _M.section(num)
+  waction("SECTION", num)
+  wflush(true) -- SECTION is a terminal action.
+end
+
+------------------------------------------------------------------------------
+
+-- Dump architecture description.
+function _M.dumparch(out)
+  out:write(format("DynASM %s version %s, released %s\n\n",
+    _info.arch, _info.version, _info.release))
+  dumpactions(out)
+end
+
+-- Dump all user defined elements.
+function _M.dumpdef(out, lvl)
+  dumptypes(out, lvl)
+  dumpglobals(out, lvl)
+  dumpexterns(out, lvl)
+end
+
+------------------------------------------------------------------------------
+
+-- Pass callbacks from/to the DynASM core.
+function _M.passcb(wl, we, wf, ww)
+  wline, werror, wfatal, wwarn = wl, we, wf, ww
+  return wflush
+end
+
+-- Setup the arch-specific module.
+function _M.setup(arch, opt)
+  g_arch, g_opt = arch, opt
+end
+
+-- Merge the core maps and the arch-specific maps.
+function _M.mergemaps(map_coreop, map_def)
+  setmetatable(map_op, { __index = map_coreop })
+  setmetatable(map_def, { __index = map_archdef })
+  return map_op, map_def
+end
+
+return _M
+
+------------------------------------------------------------------------------
+