xref: /PHP-8.3/ext/opcache/jit/dynasm/dasm_arm.lua (revision 16d59a59)
1------------------------------------------------------------------------------
2-- DynASM ARM module.
3--
4-- Copyright (C) 2005-2021 Mike Pall. All rights reserved.
5-- See dynasm.lua for full copyright notice.
6------------------------------------------------------------------------------
7
8-- Module information:
9local _info = {
10  arch =	"arm",
11  description =	"DynASM ARM module",
12  version =	"1.5.0",
13  vernum =	 10500,
14  release =	"2021-05-02",
15  author =	"Mike Pall",
16  license =	"MIT",
17}
18
19-- Exported glue functions for the arch-specific module.
20local _M = { _info = _info }
21
22-- Cache library functions.
23local type, tonumber, pairs, ipairs = type, tonumber, pairs, ipairs
24local assert, setmetatable, rawget = assert, setmetatable, rawget
25local _s = string
26local sub, format, byte, char = _s.sub, _s.format, _s.byte, _s.char
27local match, gmatch, gsub = _s.match, _s.gmatch, _s.gsub
28local concat, sort, insert = table.concat, table.sort, table.insert
29local bit = bit or require("bit")
30local band, shl, shr, sar = bit.band, bit.lshift, bit.rshift, bit.arshift
31local ror, tohex = bit.ror, bit.tohex
32
33-- Inherited tables and callbacks.
34local g_opt, g_arch
35local wline, werror, wfatal, wwarn
36
37-- Action name list.
38-- CHECK: Keep this in sync with the C code!
39local action_names = {
40  "STOP", "SECTION", "ESC", "REL_EXT",
41  "ALIGN", "REL_LG", "LABEL_LG",
42  "REL_PC", "LABEL_PC", "IMM", "IMM12", "IMM16", "IMML8", "IMML12", "IMMV8",
43}
44
45-- Maximum number of section buffer positions for dasm_put().
46-- CHECK: Keep this in sync with the C code!
47local maxsecpos = 25 -- Keep this low, to avoid excessively long C lines.
48
49-- Action name -> action number.
50local map_action = {}
51for n,name in ipairs(action_names) do
52  map_action[name] = n-1
53end
54
55-- Action list buffer.
56local actlist = {}
57
58-- Argument list for next dasm_put(). Start with offset 0 into action list.
59local actargs = { 0 }
60
61-- Current number of section buffer positions for dasm_put().
62local secpos = 1
63
64------------------------------------------------------------------------------
65
66-- Dump action names and numbers.
67local function dumpactions(out)
68  out:write("DynASM encoding engine action codes:\n")
69  for n,name in ipairs(action_names) do
70    local num = map_action[name]
71    out:write(format("  %-10s %02X  %d\n", name, num, num))
72  end
73  out:write("\n")
74end
75
76-- Write action list buffer as a huge static C array.
77local function writeactions(out, name)
78  local nn = #actlist
79  if nn == 0 then nn = 1; actlist[0] = map_action.STOP end
80  out:write("static const unsigned int ", name, "[", nn, "] = {\n")
81  for i = 1,nn-1 do
82    assert(out:write("0x", tohex(actlist[i]), ",\n"))
83  end
84  assert(out:write("0x", tohex(actlist[nn]), "\n};\n\n"))
85end
86
87------------------------------------------------------------------------------
88
89-- Add word to action list.
90local function wputxw(n)
91  assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range")
92  actlist[#actlist+1] = n
93end
94
95-- Add action to list with optional arg. Advance buffer pos, too.
96local function waction(action, val, a, num)
97  local w = assert(map_action[action], "bad action name `"..action.."'")
98  wputxw(w * 0x10000 + (val or 0))
99  if a then actargs[#actargs+1] = a end
100  if a or num then secpos = secpos + (num or 1) end
101end
102
103-- Flush action list (intervening C code or buffer pos overflow).
104local function wflush(term)
105  if #actlist == actargs[1] then return end -- Nothing to flush.
106  if not term then waction("STOP") end -- Terminate action list.
107  wline(format("dasm_put(Dst, %s);", concat(actargs, ", ")), true)
108  actargs = { #actlist } -- Actionlist offset is 1st arg to next dasm_put().
109  secpos = 1 -- The actionlist offset occupies a buffer position, too.
110end
111
112-- Put escaped word.
113local function wputw(n)
114  if n <= 0x000fffff then waction("ESC") end
115  wputxw(n)
116end
117
118-- Reserve position for word.
119local function wpos()
120  local pos = #actlist+1
121  actlist[pos] = ""
122  return pos
123end
124
125-- Store word to reserved position.
126local function wputpos(pos, n)
127  assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range")
128  if n <= 0x000fffff then
129    insert(actlist, pos+1, n)
130    n = map_action.ESC * 0x10000
131  end
132  actlist[pos] = n
133end
134
135------------------------------------------------------------------------------
136
137-- Global label name -> global label number. With auto assignment on 1st use.
138local next_global = 20
139local map_global = setmetatable({}, { __index = function(t, name)
140  if not match(name, "^[%a_][%w_]*$") then werror("bad global label") end
141  local n = next_global
142  if n > 2047 then werror("too many global labels") end
143  next_global = n + 1
144  t[name] = n
145  return n
146end})
147
148-- Dump global labels.
149local function dumpglobals(out, lvl)
150  local t = {}
151  for name, n in pairs(map_global) do t[n] = name end
152  out:write("Global labels:\n")
153  for i=20,next_global-1 do
154    out:write(format("  %s\n", t[i]))
155  end
156  out:write("\n")
157end
158
159-- Write global label enum.
160local function writeglobals(out, prefix)
161  local t = {}
162  for name, n in pairs(map_global) do t[n] = name end
163  out:write("enum {\n")
164  for i=20,next_global-1 do
165    out:write("  ", prefix, t[i], ",\n")
166  end
167  out:write("  ", prefix, "_MAX\n};\n")
168end
169
170-- Write global label names.
171local function writeglobalnames(out, name)
172  local t = {}
173  for name, n in pairs(map_global) do t[n] = name end
174  out:write("static const char *const ", name, "[] = {\n")
175  for i=20,next_global-1 do
176    out:write("  \"", t[i], "\",\n")
177  end
178  out:write("  (const char *)0\n};\n")
179end
180
181------------------------------------------------------------------------------
182
183-- Extern label name -> extern label number. With auto assignment on 1st use.
184local next_extern = 0
185local map_extern_ = {}
186local map_extern = setmetatable({}, { __index = function(t, name)
187  -- No restrictions on the name for now.
188  local n = next_extern
189  if n > 2047 then werror("too many extern labels") end
190  next_extern = n + 1
191  t[name] = n
192  map_extern_[n] = name
193  return n
194end})
195
196-- Dump extern labels.
197local function dumpexterns(out, lvl)
198  out:write("Extern labels:\n")
199  for i=0,next_extern-1 do
200    out:write(format("  %s\n", map_extern_[i]))
201  end
202  out:write("\n")
203end
204
205-- Write extern label names.
206local function writeexternnames(out, name)
207  out:write("static const char *const ", name, "[] = {\n")
208  for i=0,next_extern-1 do
209    out:write("  \"", map_extern_[i], "\",\n")
210  end
211  out:write("  (const char *)0\n};\n")
212end
213
214------------------------------------------------------------------------------
215
216-- Arch-specific maps.
217
218-- Ext. register name -> int. name.
219local map_archdef = { sp = "r13", lr = "r14", pc = "r15", }
220
221-- Int. register name -> ext. name.
222local map_reg_rev = { r13 = "sp", r14 = "lr", r15 = "pc", }
223
224local map_type = {}		-- Type name -> { ctype, reg }
225local ctypenum = 0		-- Type number (for Dt... macros).
226
227-- Reverse defines for registers.
228function _M.revdef(s)
229  return map_reg_rev[s] or s
230end
231
232local map_shift = { lsl = 0, lsr = 1, asr = 2, ror = 3, }
233
234local map_cond = {
235  eq = 0, ne = 1, cs = 2, cc = 3, mi = 4, pl = 5, vs = 6, vc = 7,
236  hi = 8, ls = 9, ge = 10, lt = 11, gt = 12, le = 13, al = 14,
237  hs = 2, lo = 3,
238}
239
240------------------------------------------------------------------------------
241
242-- Template strings for ARM instructions.
243local map_op = {
244  -- Basic data processing instructions.
245  and_3 = "e0000000DNPs",
246  eor_3 = "e0200000DNPs",
247  sub_3 = "e0400000DNPs",
248  rsb_3 = "e0600000DNPs",
249  add_3 = "e0800000DNPs",
250  adc_3 = "e0a00000DNPs",
251  sbc_3 = "e0c00000DNPs",
252  rsc_3 = "e0e00000DNPs",
253  tst_2 = "e1100000NP",
254  teq_2 = "e1300000NP",
255  cmp_2 = "e1500000NP",
256  cmn_2 = "e1700000NP",
257  orr_3 = "e1800000DNPs",
258  mov_2 = "e1a00000DPs",
259  bic_3 = "e1c00000DNPs",
260  mvn_2 = "e1e00000DPs",
261
262  and_4 = "e0000000DNMps",
263  eor_4 = "e0200000DNMps",
264  sub_4 = "e0400000DNMps",
265  rsb_4 = "e0600000DNMps",
266  add_4 = "e0800000DNMps",
267  adc_4 = "e0a00000DNMps",
268  sbc_4 = "e0c00000DNMps",
269  rsc_4 = "e0e00000DNMps",
270  tst_3 = "e1100000NMp",
271  teq_3 = "e1300000NMp",
272  cmp_3 = "e1500000NMp",
273  cmn_3 = "e1700000NMp",
274  orr_4 = "e1800000DNMps",
275  mov_3 = "e1a00000DMps",
276  bic_4 = "e1c00000DNMps",
277  mvn_3 = "e1e00000DMps",
278
279  lsl_3 = "e1a00000DMws",
280  lsr_3 = "e1a00020DMws",
281  asr_3 = "e1a00040DMws",
282  ror_3 = "e1a00060DMws",
283  rrx_2 = "e1a00060DMs",
284
285  -- Multiply and multiply-accumulate.
286  mul_3 = "e0000090NMSs",
287  mla_4 = "e0200090NMSDs",
288  umaal_4 = "e0400090DNMSs",	-- v6
289  mls_4 = "e0600090DNMSs",	-- v6T2
290  umull_4 = "e0800090DNMSs",
291  umlal_4 = "e0a00090DNMSs",
292  smull_4 = "e0c00090DNMSs",
293  smlal_4 = "e0e00090DNMSs",
294
295  -- Halfword multiply and multiply-accumulate.
296  smlabb_4 = "e1000080NMSD",	-- v5TE
297  smlatb_4 = "e10000a0NMSD",	-- v5TE
298  smlabt_4 = "e10000c0NMSD",	-- v5TE
299  smlatt_4 = "e10000e0NMSD",	-- v5TE
300  smlawb_4 = "e1200080NMSD",	-- v5TE
301  smulwb_3 = "e12000a0NMS",	-- v5TE
302  smlawt_4 = "e12000c0NMSD",	-- v5TE
303  smulwt_3 = "e12000e0NMS",	-- v5TE
304  smlalbb_4 = "e1400080NMSD",	-- v5TE
305  smlaltb_4 = "e14000a0NMSD",	-- v5TE
306  smlalbt_4 = "e14000c0NMSD",	-- v5TE
307  smlaltt_4 = "e14000e0NMSD",	-- v5TE
308  smulbb_3 = "e1600080NMS",	-- v5TE
309  smultb_3 = "e16000a0NMS",	-- v5TE
310  smulbt_3 = "e16000c0NMS",	-- v5TE
311  smultt_3 = "e16000e0NMS",	-- v5TE
312
313  -- Miscellaneous data processing instructions.
314  clz_2 = "e16f0f10DM", -- v5T
315  rev_2 = "e6bf0f30DM", -- v6
316  rev16_2 = "e6bf0fb0DM", -- v6
317  revsh_2 = "e6ff0fb0DM", -- v6
318  sel_3 = "e6800fb0DNM", -- v6
319  usad8_3 = "e780f010NMS", -- v6
320  usada8_4 = "e7800010NMSD", -- v6
321  rbit_2 = "e6ff0f30DM", -- v6T2
322  movw_2 = "e3000000DW", -- v6T2
323  movt_2 = "e3400000DW", -- v6T2
324  -- Note: the X encodes width-1, not width.
325  sbfx_4 = "e7a00050DMvX", -- v6T2
326  ubfx_4 = "e7e00050DMvX", -- v6T2
327  -- Note: the X encodes the msb field, not the width.
328  bfc_3 = "e7c0001fDvX", -- v6T2
329  bfi_4 = "e7c00010DMvX", -- v6T2
330
331  -- Packing and unpacking instructions.
332  pkhbt_3 = "e6800010DNM", pkhbt_4 = "e6800010DNMv", -- v6
333  pkhtb_3 = "e6800050DNM", pkhtb_4 = "e6800050DNMv", -- v6
334  sxtab_3 = "e6a00070DNM", sxtab_4 = "e6a00070DNMv", -- v6
335  sxtab16_3 = "e6800070DNM", sxtab16_4 = "e6800070DNMv", -- v6
336  sxtah_3 = "e6b00070DNM", sxtah_4 = "e6b00070DNMv", -- v6
337  sxtb_2 = "e6af0070DM", sxtb_3 = "e6af0070DMv", -- v6
338  sxtb16_2 = "e68f0070DM", sxtb16_3 = "e68f0070DMv", -- v6
339  sxth_2 = "e6bf0070DM", sxth_3 = "e6bf0070DMv", -- v6
340  uxtab_3 = "e6e00070DNM", uxtab_4 = "e6e00070DNMv", -- v6
341  uxtab16_3 = "e6c00070DNM", uxtab16_4 = "e6c00070DNMv", -- v6
342  uxtah_3 = "e6f00070DNM", uxtah_4 = "e6f00070DNMv", -- v6
343  uxtb_2 = "e6ef0070DM", uxtb_3 = "e6ef0070DMv", -- v6
344  uxtb16_2 = "e6cf0070DM", uxtb16_3 = "e6cf0070DMv", -- v6
345  uxth_2 = "e6ff0070DM", uxth_3 = "e6ff0070DMv", -- v6
346
347  -- Saturating instructions.
348  qadd_3 = "e1000050DMN",	-- v5TE
349  qsub_3 = "e1200050DMN",	-- v5TE
350  qdadd_3 = "e1400050DMN",	-- v5TE
351  qdsub_3 = "e1600050DMN",	-- v5TE
352  -- Note: the X for ssat* encodes sat_imm-1, not sat_imm.
353  ssat_3 = "e6a00010DXM", ssat_4 = "e6a00010DXMp", -- v6
354  usat_3 = "e6e00010DXM", usat_4 = "e6e00010DXMp", -- v6
355  ssat16_3 = "e6a00f30DXM", -- v6
356  usat16_3 = "e6e00f30DXM", -- v6
357
358  -- Parallel addition and subtraction.
359  sadd16_3 = "e6100f10DNM", -- v6
360  sasx_3 = "e6100f30DNM", -- v6
361  ssax_3 = "e6100f50DNM", -- v6
362  ssub16_3 = "e6100f70DNM", -- v6
363  sadd8_3 = "e6100f90DNM", -- v6
364  ssub8_3 = "e6100ff0DNM", -- v6
365  qadd16_3 = "e6200f10DNM", -- v6
366  qasx_3 = "e6200f30DNM", -- v6
367  qsax_3 = "e6200f50DNM", -- v6
368  qsub16_3 = "e6200f70DNM", -- v6
369  qadd8_3 = "e6200f90DNM", -- v6
370  qsub8_3 = "e6200ff0DNM", -- v6
371  shadd16_3 = "e6300f10DNM", -- v6
372  shasx_3 = "e6300f30DNM", -- v6
373  shsax_3 = "e6300f50DNM", -- v6
374  shsub16_3 = "e6300f70DNM", -- v6
375  shadd8_3 = "e6300f90DNM", -- v6
376  shsub8_3 = "e6300ff0DNM", -- v6
377  uadd16_3 = "e6500f10DNM", -- v6
378  uasx_3 = "e6500f30DNM", -- v6
379  usax_3 = "e6500f50DNM", -- v6
380  usub16_3 = "e6500f70DNM", -- v6
381  uadd8_3 = "e6500f90DNM", -- v6
382  usub8_3 = "e6500ff0DNM", -- v6
383  uqadd16_3 = "e6600f10DNM", -- v6
384  uqasx_3 = "e6600f30DNM", -- v6
385  uqsax_3 = "e6600f50DNM", -- v6
386  uqsub16_3 = "e6600f70DNM", -- v6
387  uqadd8_3 = "e6600f90DNM", -- v6
388  uqsub8_3 = "e6600ff0DNM", -- v6
389  uhadd16_3 = "e6700f10DNM", -- v6
390  uhasx_3 = "e6700f30DNM", -- v6
391  uhsax_3 = "e6700f50DNM", -- v6
392  uhsub16_3 = "e6700f70DNM", -- v6
393  uhadd8_3 = "e6700f90DNM", -- v6
394  uhsub8_3 = "e6700ff0DNM", -- v6
395
396  -- Load/store instructions.
397  str_2 = "e4000000DL", str_3 = "e4000000DL", str_4 = "e4000000DL",
398  strb_2 = "e4400000DL", strb_3 = "e4400000DL", strb_4 = "e4400000DL",
399  ldr_2 = "e4100000DL", ldr_3 = "e4100000DL", ldr_4 = "e4100000DL",
400  ldrb_2 = "e4500000DL", ldrb_3 = "e4500000DL", ldrb_4 = "e4500000DL",
401  strh_2 = "e00000b0DL", strh_3 = "e00000b0DL",
402  ldrh_2 = "e01000b0DL", ldrh_3 = "e01000b0DL",
403  ldrd_2 = "e00000d0DL", ldrd_3 = "e00000d0DL", -- v5TE
404  ldrsb_2 = "e01000d0DL", ldrsb_3 = "e01000d0DL",
405  strd_2 = "e00000f0DL", strd_3 = "e00000f0DL", -- v5TE
406  ldrsh_2 = "e01000f0DL", ldrsh_3 = "e01000f0DL",
407
408  ldm_2 = "e8900000oR", ldmia_2 = "e8900000oR", ldmfd_2 = "e8900000oR",
409  ldmda_2 = "e8100000oR", ldmfa_2 = "e8100000oR",
410  ldmdb_2 = "e9100000oR", ldmea_2 = "e9100000oR",
411  ldmib_2 = "e9900000oR", ldmed_2 = "e9900000oR",
412  stm_2 = "e8800000oR", stmia_2 = "e8800000oR", stmfd_2 = "e8800000oR",
413  stmda_2 = "e8000000oR", stmfa_2 = "e8000000oR",
414  stmdb_2 = "e9000000oR", stmea_2 = "e9000000oR",
415  stmib_2 = "e9800000oR", stmed_2 = "e9800000oR",
416  pop_1 = "e8bd0000R", push_1 = "e92d0000R",
417
418  -- Branch instructions.
419  b_1 = "ea000000B",
420  bl_1 = "eb000000B",
421  blx_1 = "e12fff30C",
422  bx_1 = "e12fff10M",
423
424  -- Miscellaneous instructions.
425  nop_0 = "e1a00000",
426  mrs_1 = "e10f0000D",
427  bkpt_1 = "e1200070K", -- v5T
428  svc_1 = "ef000000T", swi_1 = "ef000000T",
429  ud_0 = "e7f001f0",
430
431  -- VFP instructions.
432  ["vadd.f32_3"] = "ee300a00dnm",
433  ["vadd.f64_3"] = "ee300b00Gdnm",
434  ["vsub.f32_3"] = "ee300a40dnm",
435  ["vsub.f64_3"] = "ee300b40Gdnm",
436  ["vmul.f32_3"] = "ee200a00dnm",
437  ["vmul.f64_3"] = "ee200b00Gdnm",
438  ["vnmul.f32_3"] = "ee200a40dnm",
439  ["vnmul.f64_3"] = "ee200b40Gdnm",
440  ["vmla.f32_3"] = "ee000a00dnm",
441  ["vmla.f64_3"] = "ee000b00Gdnm",
442  ["vmls.f32_3"] = "ee000a40dnm",
443  ["vmls.f64_3"] = "ee000b40Gdnm",
444  ["vnmla.f32_3"] = "ee100a40dnm",
445  ["vnmla.f64_3"] = "ee100b40Gdnm",
446  ["vnmls.f32_3"] = "ee100a00dnm",
447  ["vnmls.f64_3"] = "ee100b00Gdnm",
448  ["vdiv.f32_3"] = "ee800a00dnm",
449  ["vdiv.f64_3"] = "ee800b00Gdnm",
450
451  ["vabs.f32_2"] = "eeb00ac0dm",
452  ["vabs.f64_2"] = "eeb00bc0Gdm",
453  ["vneg.f32_2"] = "eeb10a40dm",
454  ["vneg.f64_2"] = "eeb10b40Gdm",
455  ["vsqrt.f32_2"] = "eeb10ac0dm",
456  ["vsqrt.f64_2"] = "eeb10bc0Gdm",
457  ["vcmp.f32_2"] = "eeb40a40dm",
458  ["vcmp.f64_2"] = "eeb40b40Gdm",
459  ["vcmpe.f32_2"] = "eeb40ac0dm",
460  ["vcmpe.f64_2"] = "eeb40bc0Gdm",
461  ["vcmpz.f32_1"] = "eeb50a40d",
462  ["vcmpz.f64_1"] = "eeb50b40Gd",
463  ["vcmpze.f32_1"] = "eeb50ac0d",
464  ["vcmpze.f64_1"] = "eeb50bc0Gd",
465
466  vldr_2 = "ed100a00dl|ed100b00Gdl",
467  vstr_2 = "ed000a00dl|ed000b00Gdl",
468  vldm_2 = "ec900a00or",
469  vldmia_2 = "ec900a00or",
470  vldmdb_2 = "ed100a00or",
471  vpop_1 = "ecbd0a00r",
472  vstm_2 = "ec800a00or",
473  vstmia_2 = "ec800a00or",
474  vstmdb_2 = "ed000a00or",
475  vpush_1 = "ed2d0a00r",
476
477  ["vmov.f32_2"] = "eeb00a40dm|eeb00a00dY",	-- #imm is VFPv3 only
478  ["vmov.f64_2"] = "eeb00b40Gdm|eeb00b00GdY",	-- #imm is VFPv3 only
479  vmov_2 = "ee100a10Dn|ee000a10nD",
480  vmov_3 = "ec500a10DNm|ec400a10mDN|ec500b10GDNm|ec400b10GmDN",
481
482  vmrs_0 = "eef1fa10",
483  vmrs_1 = "eef10a10D",
484  vmsr_1 = "eee10a10D",
485
486  ["vcvt.s32.f32_2"] = "eebd0ac0dm",
487  ["vcvt.s32.f64_2"] = "eebd0bc0dGm",
488  ["vcvt.u32.f32_2"] = "eebc0ac0dm",
489  ["vcvt.u32.f64_2"] = "eebc0bc0dGm",
490  ["vcvtr.s32.f32_2"] = "eebd0a40dm",
491  ["vcvtr.s32.f64_2"] = "eebd0b40dGm",
492  ["vcvtr.u32.f32_2"] = "eebc0a40dm",
493  ["vcvtr.u32.f64_2"] = "eebc0b40dGm",
494  ["vcvt.f32.s32_2"] = "eeb80ac0dm",
495  ["vcvt.f64.s32_2"] = "eeb80bc0GdFm",
496  ["vcvt.f32.u32_2"] = "eeb80a40dm",
497  ["vcvt.f64.u32_2"] = "eeb80b40GdFm",
498  ["vcvt.f32.f64_2"] = "eeb70bc0dGm",
499  ["vcvt.f64.f32_2"] = "eeb70ac0GdFm",
500
501  -- VFPv4 only:
502  ["vfma.f32_3"] = "eea00a00dnm",
503  ["vfma.f64_3"] = "eea00b00Gdnm",
504  ["vfms.f32_3"] = "eea00a40dnm",
505  ["vfms.f64_3"] = "eea00b40Gdnm",
506  ["vfnma.f32_3"] = "ee900a40dnm",
507  ["vfnma.f64_3"] = "ee900b40Gdnm",
508  ["vfnms.f32_3"] = "ee900a00dnm",
509  ["vfnms.f64_3"] = "ee900b00Gdnm",
510
511  -- NYI: Advanced SIMD instructions.
512
513  -- NYI: I have no need for these instructions right now:
514  -- swp, swpb, strex, ldrex, strexd, ldrexd, strexb, ldrexb, strexh, ldrexh
515  -- msr, nopv6, yield, wfe, wfi, sev, dbg, bxj, smc, srs, rfe
516  -- cps, setend, pli, pld, pldw, clrex, dsb, dmb, isb
517  -- stc, ldc, mcr, mcr2, mrc, mrc2, mcrr, mcrr2, mrrc, mrrc2, cdp, cdp2
518}
519
520-- Add mnemonics for "s" variants.
521do
522  local t = {}
523  for k,v in pairs(map_op) do
524    if sub(v, -1) == "s" then
525      local v2 = sub(v, 1, 2)..char(byte(v, 3)+1)..sub(v, 4, -2)
526      t[sub(k, 1, -3).."s"..sub(k, -2)] = v2
527    end
528  end
529  for k,v in pairs(t) do
530    map_op[k] = v
531  end
532end
533
534------------------------------------------------------------------------------
535
536local function parse_gpr(expr)
537  local tname, ovreg = match(expr, "^([%w_]+):(r1?[0-9])$")
538  local tp = map_type[tname or expr]
539  if tp then
540    local reg = ovreg or tp.reg
541    if not reg then
542      werror("type `"..(tname or expr).."' needs a register override")
543    end
544    expr = reg
545  end
546  local r = match(expr, "^r(1?[0-9])$")
547  if r then
548    r = tonumber(r)
549    if r <= 15 then return r, tp end
550  end
551  werror("bad register name `"..expr.."'")
552end
553
554local function parse_gpr_pm(expr)
555  local pm, expr2 = match(expr, "^([+-]?)(.*)$")
556  return parse_gpr(expr2), (pm == "-")
557end
558
559local function parse_vr(expr, tp)
560  local t, r = match(expr, "^([sd])([0-9]+)$")
561  if t == tp then
562    r = tonumber(r)
563    if r <= 31 then
564      if t == "s" then return shr(r, 1), band(r, 1) end
565      return band(r, 15), shr(r, 4)
566    end
567  end
568  werror("bad register name `"..expr.."'")
569end
570
571local function parse_reglist(reglist)
572  reglist = match(reglist, "^{%s*([^}]*)}$")
573  if not reglist then werror("register list expected") end
574  local rr = 0
575  for p in gmatch(reglist..",", "%s*([^,]*),") do
576    local rbit = shl(1, parse_gpr(gsub(p, "%s+$", "")))
577    if band(rr, rbit) ~= 0 then
578      werror("duplicate register `"..p.."'")
579    end
580    rr = rr + rbit
581  end
582  return rr
583end
584
585local function parse_vrlist(reglist)
586  local ta, ra, tb, rb = match(reglist,
587			   "^{%s*([sd])([0-9]+)%s*%-%s*([sd])([0-9]+)%s*}$")
588  ra, rb = tonumber(ra), tonumber(rb)
589  if ta and ta == tb and ra and rb and ra <= 31 and rb <= 31 and ra <= rb then
590    local nr = rb+1 - ra
591    if ta == "s" then
592      return shl(shr(ra,1),12)+shl(band(ra,1),22) + nr
593    else
594      return shl(band(ra,15),12)+shl(shr(ra,4),22) + nr*2 + 0x100
595    end
596  end
597  werror("register list expected")
598end
599
600local function parse_imm(imm, bits, shift, scale, signed)
601  imm = match(imm, "^#(.*)$")
602  if not imm then werror("expected immediate operand") end
603  local n = tonumber(imm)
604  if n then
605    local m = sar(n, scale)
606    if shl(m, scale) == n then
607      if signed then
608	local s = sar(m, bits-1)
609	if s == 0 then return shl(m, shift)
610	elseif s == -1 then return shl(m + shl(1, bits), shift) end
611      else
612	if sar(m, bits) == 0 then return shl(m, shift) end
613      end
614    end
615    werror("out of range immediate `"..imm.."'")
616  else
617    waction("IMM", (signed and 32768 or 0)+scale*1024+bits*32+shift, imm)
618    return 0
619  end
620end
621
622local function parse_imm12(imm)
623  local n = tonumber(imm)
624  if n then
625    local m = band(n)
626    for i=0,-15,-1 do
627      if shr(m, 8) == 0 then return m + shl(band(i, 15), 8) end
628      m = ror(m, 2)
629    end
630    werror("out of range immediate `"..imm.."'")
631  else
632    waction("IMM12", 0, imm)
633    return 0
634  end
635end
636
637local function parse_imm16(imm)
638  imm = match(imm, "^#(.*)$")
639  if not imm then werror("expected immediate operand") end
640  local n = tonumber(imm)
641  if n then
642    if shr(n, 16) == 0 then return band(n, 0x0fff) + shl(band(n, 0xf000), 4) end
643    werror("out of range immediate `"..imm.."'")
644  else
645    waction("IMM16", 32*16, imm)
646    return 0
647  end
648end
649
650local function parse_imm_load(imm, ext)
651  local n = tonumber(imm)
652  if n then
653    if ext then
654      if n >= -255 and n <= 255 then
655	local up = 0x00800000
656	if n < 0 then n = -n; up = 0 end
657	return shl(band(n, 0xf0), 4) + band(n, 0x0f) + up
658      end
659    else
660      if n >= -4095 and n <= 4095 then
661	if n >= 0 then return n+0x00800000 end
662	return -n
663      end
664    end
665    werror("out of range immediate `"..imm.."'")
666  else
667    waction(ext and "IMML8" or "IMML12", 32768 + shl(ext and 8 or 12, 5), imm)
668    return 0
669  end
670end
671
672local function parse_shift(shift, gprok)
673  if shift == "rrx" then
674    return 3 * 32
675  else
676    local s, s2 = match(shift, "^(%S+)%s*(.*)$")
677    s = map_shift[s]
678    if not s then werror("expected shift operand") end
679    if sub(s2, 1, 1) == "#" then
680      return parse_imm(s2, 5, 7, 0, false) + shl(s, 5)
681    else
682      if not gprok then werror("expected immediate shift operand") end
683      return shl(parse_gpr(s2), 8) + shl(s, 5) + 16
684    end
685  end
686end
687
688local function parse_label(label, def)
689  local prefix = sub(label, 1, 2)
690  -- =>label (pc label reference)
691  if prefix == "=>" then
692    return "PC", 0, sub(label, 3)
693  end
694  -- ->name (global label reference)
695  if prefix == "->" then
696    return "LG", map_global[sub(label, 3)]
697  end
698  if def then
699    -- [1-9] (local label definition)
700    if match(label, "^[1-9]$") then
701      return "LG", 10+tonumber(label)
702    end
703  else
704    -- [<>][1-9] (local label reference)
705    local dir, lnum = match(label, "^([<>])([1-9])$")
706    if dir then -- Fwd: 1-9, Bkwd: 11-19.
707      return "LG", lnum + (dir == ">" and 0 or 10)
708    end
709    -- extern label (extern label reference)
710    local extname = match(label, "^extern%s+(%S+)$")
711    if extname then
712      return "EXT", map_extern[extname]
713    end
714  end
715  werror("bad label `"..label.."'")
716end
717
718local function parse_load(params, nparams, n, op)
719  local oplo = band(op, 255)
720  local ext, ldrd = (oplo ~= 0), (oplo == 208)
721  local d
722  if (ldrd or oplo == 240) then
723    d = band(shr(op, 12), 15)
724    if band(d, 1) ~= 0 then werror("odd destination register") end
725  end
726  local pn = params[n]
727  local p1, wb = match(pn, "^%[%s*(.-)%s*%](!?)$")
728  local p2 = params[n+1]
729  if not p1 then
730    if not p2 then
731      if match(pn, "^[<>=%-]") or match(pn, "^extern%s+") then
732	local mode, n, s = parse_label(pn, false)
733	waction("REL_"..mode, n + (ext and 0x1800 or 0x0800), s, 1)
734	return op + 15 * 65536 + 0x01000000 + (ext and 0x00400000 or 0)
735      end
736      local reg, tailr = match(pn, "^([%w_:]+)%s*(.*)$")
737      if reg and tailr ~= "" then
738	local d, tp = parse_gpr(reg)
739	if tp then
740	  waction(ext and "IMML8" or "IMML12", 32768 + 32*(ext and 8 or 12),
741		  format(tp.ctypefmt, tailr))
742	  return op + shl(d, 16) + 0x01000000 + (ext and 0x00400000 or 0)
743	end
744      end
745    end
746    werror("expected address operand")
747  end
748  if wb == "!" then op = op + 0x00200000 end
749  if p2 then
750    if wb == "!" then werror("bad use of '!'") end
751    local p3 = params[n+2]
752    op = op + shl(parse_gpr(p1), 16)
753    local imm = match(p2, "^#(.*)$")
754    if imm then
755      local m = parse_imm_load(imm, ext)
756      if p3 then werror("too many parameters") end
757      op = op + m + (ext and 0x00400000 or 0)
758    else
759      local m, neg = parse_gpr_pm(p2)
760      if ldrd and (m == d or m-1 == d) then werror("register conflict") end
761      op = op + m + (neg and 0 or 0x00800000) + (ext and 0 or 0x02000000)
762      if p3 then op = op + parse_shift(p3) end
763    end
764  else
765    local p1a, p2 = match(p1, "^([^,%s]*)%s*(.*)$")
766    op = op + shl(parse_gpr(p1a), 16) + 0x01000000
767    if p2 ~= "" then
768      local imm = match(p2, "^,%s*#(.*)$")
769      if imm then
770	local m = parse_imm_load(imm, ext)
771	op = op + m + (ext and 0x00400000 or 0)
772      else
773	local p2a, p3 = match(p2, "^,%s*([^,%s]*)%s*,?%s*(.*)$")
774	local m, neg = parse_gpr_pm(p2a)
775	if ldrd and (m == d or m-1 == d) then werror("register conflict") end
776	op = op + m + (neg and 0 or 0x00800000) + (ext and 0 or 0x02000000)
777	if p3 ~= "" then
778	  if ext then werror("too many parameters") end
779	  op = op + parse_shift(p3)
780	end
781      end
782    else
783      if wb == "!" then werror("bad use of '!'") end
784      op = op + (ext and 0x00c00000 or 0x00800000)
785    end
786  end
787  return op
788end
789
790local function parse_vload(q)
791  local reg, imm = match(q, "^%[%s*([^,%s]*)%s*(.*)%]$")
792  if reg then
793    local d = shl(parse_gpr(reg), 16)
794    if imm == "" then return d end
795    imm = match(imm, "^,%s*#(.*)$")
796    if imm then
797      local n = tonumber(imm)
798      if n then
799	if n >= -1020 and n <= 1020 and n%4 == 0 then
800	  return d + (n >= 0 and n/4+0x00800000 or -n/4)
801	end
802	werror("out of range immediate `"..imm.."'")
803      else
804	waction("IMMV8", 32768 + 32*8, imm)
805	return d
806      end
807    end
808  else
809    if match(q, "^[<>=%-]") or match(q, "^extern%s+") then
810      local mode, n, s = parse_label(q, false)
811      waction("REL_"..mode, n + 0x2800, s, 1)
812      return 15 * 65536
813    end
814    local reg, tailr = match(q, "^([%w_:]+)%s*(.*)$")
815    if reg and tailr ~= "" then
816      local d, tp = parse_gpr(reg)
817      if tp then
818	waction("IMMV8", 32768 + 32*8, format(tp.ctypefmt, tailr))
819	return shl(d, 16)
820      end
821    end
822  end
823  werror("expected address operand")
824end
825
826------------------------------------------------------------------------------
827
828-- Handle opcodes defined with template strings.
829local function parse_template(params, template, nparams, pos)
830  local op = tonumber(sub(template, 1, 8), 16)
831  local n = 1
832  local vr = "s"
833
834  -- Process each character.
835  for p in gmatch(sub(template, 9), ".") do
836    local q = params[n]
837    if p == "D" then
838      op = op + shl(parse_gpr(q), 12); n = n + 1
839    elseif p == "N" then
840      op = op + shl(parse_gpr(q), 16); n = n + 1
841    elseif p == "S" then
842      op = op + shl(parse_gpr(q), 8); n = n + 1
843    elseif p == "M" then
844      op = op + parse_gpr(q); n = n + 1
845    elseif p == "d" then
846      local r,h = parse_vr(q, vr); op = op+shl(r,12)+shl(h,22); n = n + 1
847    elseif p == "n" then
848      local r,h = parse_vr(q, vr); op = op+shl(r,16)+shl(h,7); n = n + 1
849    elseif p == "m" then
850      local r,h = parse_vr(q, vr); op = op+r+shl(h,5); n = n + 1
851    elseif p == "P" then
852      local imm = match(q, "^#(.*)$")
853      if imm then
854	op = op + parse_imm12(imm) + 0x02000000
855      else
856	op = op + parse_gpr(q)
857      end
858      n = n + 1
859    elseif p == "p" then
860      op = op + parse_shift(q, true); n = n + 1
861    elseif p == "L" then
862      op = parse_load(params, nparams, n, op)
863    elseif p == "l" then
864      op = op + parse_vload(q)
865    elseif p == "B" then
866      local mode, n, s = parse_label(q, false)
867      waction("REL_"..mode, n, s, 1)
868    elseif p == "C" then -- blx gpr vs. blx label.
869      if match(q, "^([%w_]+):(r1?[0-9])$") or match(q, "^r(1?[0-9])$") then
870	op = op + parse_gpr(q)
871      else
872	if op < 0xe0000000 then werror("unconditional instruction") end
873	local mode, n, s = parse_label(q, false)
874	waction("REL_"..mode, n, s, 1)
875	op = 0xfa000000
876      end
877    elseif p == "F" then
878      vr = "s"
879    elseif p == "G" then
880      vr = "d"
881    elseif p == "o" then
882      local r, wb = match(q, "^([^!]*)(!?)$")
883      op = op + shl(parse_gpr(r), 16) + (wb == "!" and 0x00200000 or 0)
884      n = n + 1
885    elseif p == "R" then
886      op = op + parse_reglist(q); n = n + 1
887    elseif p == "r" then
888      op = op + parse_vrlist(q); n = n + 1
889    elseif p == "W" then
890      op = op + parse_imm16(q); n = n + 1
891    elseif p == "v" then
892      op = op + parse_imm(q, 5, 7, 0, false); n = n + 1
893    elseif p == "w" then
894      local imm = match(q, "^#(.*)$")
895      if imm then
896	op = op + parse_imm(q, 5, 7, 0, false); n = n + 1
897      else
898	op = op + shl(parse_gpr(q), 8) + 16
899      end
900    elseif p == "X" then
901      op = op + parse_imm(q, 5, 16, 0, false); n = n + 1
902    elseif p == "Y" then
903      local imm = tonumber(match(q, "^#(.*)$")); n = n + 1
904      if not imm or shr(imm, 8) ~= 0 then
905	werror("bad immediate operand")
906      end
907      op = op + shl(band(imm, 0xf0), 12) + band(imm, 0x0f)
908    elseif p == "K" then
909      local imm = tonumber(match(q, "^#(.*)$")); n = n + 1
910      if not imm or shr(imm, 16) ~= 0 then
911	werror("bad immediate operand")
912      end
913      op = op + shl(band(imm, 0xfff0), 4) + band(imm, 0x000f)
914    elseif p == "T" then
915      op = op + parse_imm(q, 24, 0, 0, false); n = n + 1
916    elseif p == "s" then
917      -- Ignored.
918    else
919      assert(false)
920    end
921  end
922  wputpos(pos, op)
923end
924
925map_op[".template__"] = function(params, template, nparams)
926  if not params then return template:gsub("%x%x%x%x%x%x%x%x", "") end
927
928  -- Limit number of section buffer positions used by a single dasm_put().
929  -- A single opcode needs a maximum of 3 positions.
930  if secpos+3 > maxsecpos then wflush() end
931  local pos = wpos()
932  local lpos, apos, spos = #actlist, #actargs, secpos
933
934  local ok, err
935  for t in gmatch(template, "[^|]+") do
936    ok, err = pcall(parse_template, params, t, nparams, pos)
937    if ok then return end
938    secpos = spos
939    actlist[lpos+1] = nil
940    actlist[lpos+2] = nil
941    actlist[lpos+3] = nil
942    actargs[apos+1] = nil
943    actargs[apos+2] = nil
944    actargs[apos+3] = nil
945  end
946  error(err, 0)
947end
948
949------------------------------------------------------------------------------
950
951-- Pseudo-opcode to mark the position where the action list is to be emitted.
952map_op[".actionlist_1"] = function(params)
953  if not params then return "cvar" end
954  local name = params[1] -- No syntax check. You get to keep the pieces.
955  wline(function(out) writeactions(out, name) end)
956end
957
958-- Pseudo-opcode to mark the position where the global enum is to be emitted.
959map_op[".globals_1"] = function(params)
960  if not params then return "prefix" end
961  local prefix = params[1] -- No syntax check. You get to keep the pieces.
962  wline(function(out) writeglobals(out, prefix) end)
963end
964
965-- Pseudo-opcode to mark the position where the global names are to be emitted.
966map_op[".globalnames_1"] = function(params)
967  if not params then return "cvar" end
968  local name = params[1] -- No syntax check. You get to keep the pieces.
969  wline(function(out) writeglobalnames(out, name) end)
970end
971
972-- Pseudo-opcode to mark the position where the extern names are to be emitted.
973map_op[".externnames_1"] = function(params)
974  if not params then return "cvar" end
975  local name = params[1] -- No syntax check. You get to keep the pieces.
976  wline(function(out) writeexternnames(out, name) end)
977end
978
979------------------------------------------------------------------------------
980
981-- Label pseudo-opcode (converted from trailing colon form).
982map_op[".label_1"] = function(params)
983  if not params then return "[1-9] | ->global | =>pcexpr" end
984  if secpos+1 > maxsecpos then wflush() end
985  local mode, n, s = parse_label(params[1], true)
986  if mode == "EXT" then werror("bad label definition") end
987  waction("LABEL_"..mode, n, s, 1)
988end
989
990------------------------------------------------------------------------------
991
992-- Pseudo-opcodes for data storage.
993map_op[".long_*"] = function(params)
994  if not params then return "imm..." end
995  for _,p in ipairs(params) do
996    local n = tonumber(p)
997    if not n then werror("bad immediate `"..p.."'") end
998    if n < 0 then n = n + 2^32 end
999    wputw(n)
1000    if secpos+2 > maxsecpos then wflush() end
1001  end
1002end
1003
1004-- Alignment pseudo-opcode.
1005map_op[".align_1"] = function(params)
1006  if not params then return "numpow2" end
1007  if secpos+1 > maxsecpos then wflush() end
1008  local align = tonumber(params[1])
1009  if align then
1010    local x = align
1011    -- Must be a power of 2 in the range (2 ... 256).
1012    for i=1,8 do
1013      x = x / 2
1014      if x == 1 then
1015	waction("ALIGN", align-1, nil, 1) -- Action byte is 2**n-1.
1016	return
1017      end
1018    end
1019  end
1020  werror("bad alignment")
1021end
1022
1023------------------------------------------------------------------------------
1024
1025-- Pseudo-opcode for (primitive) type definitions (map to C types).
1026map_op[".type_3"] = function(params, nparams)
1027  if not params then
1028    return nparams == 2 and "name, ctype" or "name, ctype, reg"
1029  end
1030  local name, ctype, reg = params[1], params[2], params[3]
1031  if not match(name, "^[%a_][%w_]*$") then
1032    werror("bad type name `"..name.."'")
1033  end
1034  local tp = map_type[name]
1035  if tp then
1036    werror("duplicate type `"..name.."'")
1037  end
1038  -- Add #type to defines. A bit unclean to put it in map_archdef.
1039  map_archdef["#"..name] = "sizeof("..ctype..")"
1040  -- Add new type and emit shortcut define.
1041  local num = ctypenum + 1
1042  map_type[name] = {
1043    ctype = ctype,
1044    ctypefmt = format("Dt%X(%%s)", num),
1045    reg = reg,
1046  }
1047  wline(format("#define Dt%X(_V) (int)(ptrdiff_t)&(((%s *)0)_V)", num, ctype))
1048  ctypenum = num
1049end
1050map_op[".type_2"] = map_op[".type_3"]
1051
1052-- Dump type definitions.
1053local function dumptypes(out, lvl)
1054  local t = {}
1055  for name in pairs(map_type) do t[#t+1] = name end
1056  sort(t)
1057  out:write("Type definitions:\n")
1058  for _,name in ipairs(t) do
1059    local tp = map_type[name]
1060    local reg = tp.reg or ""
1061    out:write(format("  %-20s %-20s %s\n", name, tp.ctype, reg))
1062  end
1063  out:write("\n")
1064end
1065
1066------------------------------------------------------------------------------
1067
1068-- Set the current section.
1069function _M.section(num)
1070  waction("SECTION", num)
1071  wflush(true) -- SECTION is a terminal action.
1072end
1073
1074------------------------------------------------------------------------------
1075
1076-- Dump architecture description.
1077function _M.dumparch(out)
1078  out:write(format("DynASM %s version %s, released %s\n\n",
1079    _info.arch, _info.version, _info.release))
1080  dumpactions(out)
1081end
1082
1083-- Dump all user defined elements.
1084function _M.dumpdef(out, lvl)
1085  dumptypes(out, lvl)
1086  dumpglobals(out, lvl)
1087  dumpexterns(out, lvl)
1088end
1089
1090------------------------------------------------------------------------------
1091
1092-- Pass callbacks from/to the DynASM core.
1093function _M.passcb(wl, we, wf, ww)
1094  wline, werror, wfatal, wwarn = wl, we, wf, ww
1095  return wflush
1096end
1097
1098-- Setup the arch-specific module.
1099function _M.setup(arch, opt)
1100  g_arch, g_opt = arch, opt
1101end
1102
1103-- Merge the core maps and the arch-specific maps.
1104function _M.mergemaps(map_coreop, map_def)
1105  setmetatable(map_op, { __index = function(t, k)
1106    local v = map_coreop[k]
1107    if v then return v end
1108    local k1, cc, k2 = match(k, "^(.-)(..)([._].*)$")
1109    local cv = map_cond[cc]
1110    if cv then
1111      local v = rawget(t, k1..k2)
1112      if type(v) == "string" then
1113	local scv = format("%x", cv)
1114	return gsub(scv..sub(v, 2), "|e", "|"..scv)
1115      end
1116    end
1117  end })
1118  setmetatable(map_def, { __index = map_archdef })
1119  return map_op, map_def
1120end
1121
1122return _M
1123
1124------------------------------------------------------------------------------
1125
1126