src/jit/dis_arm64.lua

   1 ----------------------------------------------------------------------------
   2 -- LuaJIT ARM64 disassembler module.
   3 --
   4 -- Copyright (C) 2005-2023 Mike Pall. All rights reserved.
   5 -- Released under the MIT license. See Copyright Notice in luajit.h
   6 --
   7 -- Contributed by Djordje Kovacevic and Stefan Pejic from RT-RK.com.
   8 -- Sponsored by Cisco Systems, Inc.
   9 ----------------------------------------------------------------------------
  10 -- This is a helper module used by the LuaJIT machine code dumper module.
  11 --
  12 -- It disassembles most user-mode AArch64 instructions.
  13 -- NYI: Advanced SIMD and VFP instructions.
  14 ------------------------------------------------------------------------------
  15
  16 local type = type
  17 local sub, byte, format = string.sub, string.byte, string.format
  18 local match, gmatch, gsub = string.match, string.gmatch, string.gsub
  19 local concat = table.concat
  20 local bit = require("bit")
  21 local band, bor, bxor, tohex = bit.band, bit.bor, bit.bxor, bit.tohex
  22 local lshift, rshift, arshift = bit.lshift, bit.rshift, bit.arshift
  23 local ror = bit.ror
  24
  25 ------------------------------------------------------------------------------
  26 -- Opcode maps
  27 ------------------------------------------------------------------------------
  28
  29 local map_adr = { -- PC-relative addressing.
  30   shift = 31, mask = 1,
  31   [0] = "adrDBx", "adrpDBx"
  32 }
  33
  34 local map_addsubi = { -- Add/subtract immediate.
  35   shift = 29, mask = 3,
  36   [0] = "add|movDNIg", "adds|cmnD0NIg", "subDNIg", "subs|cmpD0NIg",
  37 }
  38
  39 local map_logi = { -- Logical immediate.
  40   shift = 31, mask = 1,
  41   [0] = {
  42     shift = 22, mask = 1,
  43     [0] = {
  44       shift = 29, mask = 3,
  45       [0] = "andDNig", "orr|movDN0ig", "eorDNig", "ands|tstD0Nig"
  46     },
  47     false -- unallocated
  48   },
  49   {
  50     shift = 29, mask = 3,
  51     [0] = "andDNig", "orr|movDN0ig", "eorDNig", "ands|tstD0Nig"
  52   }
  53 }
  54
  55 local map_movwi = { -- Move wide immediate.
  56   shift = 31, mask = 1,
  57   [0] = {
  58     shift = 22, mask = 1,
  59     [0] = {
  60       shift = 29, mask = 3,
  61       [0] = "movnDWRg", false, "movz|movDYRg", "movkDWRg"
  62     }, false -- unallocated
  63   },
  64   {
  65     shift = 29, mask = 3,
  66     [0] = "movnDWRg", false, "movz|movDYRg", "movkDWRg"
  67   },
  68 }
  69
  70 local map_bitf = { -- Bitfield.
  71   shift = 31, mask = 1,
  72   [0] = {
  73     shift = 22, mask = 1,
  74     [0] = {
  75       shift = 29, mask = 3,
  76       [0] = "sbfm|sbfiz|sbfx|asr|sxtw|sxth|sxtbDN12w",
  77       "bfm|bfi|bfxilDN13w",
  78       "ubfm|ubfiz|ubfx|lsr|lsl|uxth|uxtbDN12w"
  79     }
  80   },
  81   {
  82     shift = 22, mask = 1,
  83     {
  84       shift = 29, mask = 3,
  85       [0] = "sbfm|sbfiz|sbfx|asr|sxtw|sxth|sxtbDN12x",
  86       "bfm|bfi|bfxilDN13x",
  87       "ubfm|ubfiz|ubfx|lsr|lsl|uxth|uxtbDN12x"
  88     }
  89   }
  90 }
  91
  92 local map_datai = { -- Data processing - immediate.
  93   shift = 23, mask = 7,
  94   [0] = map_adr, map_adr, map_addsubi, false,
  95   map_logi, map_movwi, map_bitf,
  96   {
  97     shift = 15, mask = 0x1c0c1,
  98     [0] = "extr|rorDNM4w", [0x10080] = "extr|rorDNM4x",
  99     [0x10081] = "extr|rorDNM4x"
 100   }
 101 }
 102
 103 local map_logsr = { -- Logical, shifted register.
 104   shift = 31, mask = 1,
 105   [0] = {
 106     shift = 15, mask = 1,
 107     [0] = {
 108       shift = 29, mask = 3,
 109       [0] = {
 110         shift = 21, mask = 1,
 111         [0] = "andDNMSg", "bicDNMSg"
 112       },
 113       {
 114         shift = 21, mask = 1,
 115         [0] = "orr|movDN0MSg", "orn|mvnDN0MSg"
 116       },
 117       {
 118         shift = 21, mask = 1,
 119         [0] = "eorDNMSg", "eonDNMSg"
 120       },
 121       {
 122         shift = 21, mask = 1,
 123         [0] = "ands|tstD0NMSg", "bicsDNMSg"
 124       }
 125     },
 126     false -- unallocated
 127   },
 128   {
 129     shift = 29, mask = 3,
 130     [0] = {
 131       shift = 21, mask = 1,
 132       [0] = "andDNMSg", "bicDNMSg"
 133     },
 134     {
 135       shift = 21, mask = 1,
 136       [0] = "orr|movDN0MSg", "orn|mvnDN0MSg"
 137     },
 138     {
 139       shift = 21, mask = 1,
 140       [0] = "eorDNMSg", "eonDNMSg"
 141     },
 142     {
 143       shift = 21, mask = 1,
 144       [0] = "ands|tstD0NMSg", "bicsDNMSg"
 145     }
 146   }
 147 }
 148
 149 local map_assh = {
 150   shift = 31, mask = 1,
 151   [0] = {
 152     shift = 15, mask = 1,
 153     [0] = {
 154       shift = 29, mask = 3,
 155       [0] = {
 156         shift = 22, mask = 3,
 157         [0] = "addDNMSg", "addDNMSg", "addDNMSg", "addDNMg"
 158       },
 159       {
 160         shift = 22, mask = 3,
 161         [0] = "adds|cmnD0NMSg", "adds|cmnD0NMSg",
 162               "adds|cmnD0NMSg", "adds|cmnD0NMg"
 163       },
 164       {
 165         shift = 22, mask = 3,
 166         [0] = "sub|negDN0MSg", "sub|negDN0MSg", "sub|negDN0MSg", "sub|negDN0Mg"
 167       },
 168       {
 169         shift = 22, mask = 3,
 170         [0] = "subs|cmp|negsD0N0MzSg", "subs|cmp|negsD0N0MzSg",
 171               "subs|cmp|negsD0N0MzSg", "subs|cmp|negsD0N0Mzg"
 172       },
 173     },
 174     false -- unallocated
 175   },
 176   {
 177     shift = 29, mask = 3,
 178     [0] = {
 179       shift = 22, mask = 3,
 180       [0] = "addDNMSg", "addDNMSg", "addDNMSg", "addDNMg"
 181     },
 182     {
 183       shift = 22, mask = 3,
 184       [0] = "adds|cmnD0NMSg", "adds|cmnD0NMSg", "adds|cmnD0NMSg",
 185             "adds|cmnD0NMg"
 186     },
 187     {
 188       shift = 22, mask = 3,
 189       [0] = "sub|negDN0MSg", "sub|negDN0MSg", "sub|negDN0MSg", "sub|negDN0Mg"
 190     },
 191     {
 192       shift = 22, mask = 3,
 193       [0] = "subs|cmp|negsD0N0MzSg", "subs|cmp|negsD0N0MzSg",
 194             "subs|cmp|negsD0N0MzSg", "subs|cmp|negsD0N0Mzg"
 195     }
 196   }
 197 }
 198
 199 local map_addsubsh = { -- Add/subtract, shifted register.
 200   shift = 22, mask = 3,
 201   [0] = map_assh, map_assh, map_assh
 202 }
 203
 204 local map_addsubex = { -- Add/subtract, extended register.
 205   shift = 22, mask = 3,
 206   [0] = {
 207     shift = 29, mask = 3,
 208     [0] = "addDNMXg", "adds|cmnD0NMXg", "subDNMXg", "subs|cmpD0NMzXg",
 209   }
 210 }
 211
 212 local map_addsubc = { -- Add/subtract, with carry.
 213   shift = 10, mask = 63,
 214   [0] = {
 215     shift = 29, mask = 3,
 216     [0] = "adcDNMg", "adcsDNMg", "sbc|ngcDN0Mg", "sbcs|ngcsDN0Mg",
 217   }
 218 }
 219
 220 local map_ccomp = {
 221   shift = 4, mask = 1,
 222   [0] = {
 223     shift = 10, mask = 3,
 224     [0] = { -- Conditional compare register.
 225       shift = 29, mask = 3,
 226       "ccmnNMVCg", false, "ccmpNMVCg",
 227     },
 228     [2] = {  -- Conditional compare immediate.
 229       shift = 29, mask = 3,
 230       "ccmnN5VCg", false, "ccmpN5VCg",
 231     }
 232   }
 233 }
 234
 235 local map_csel = { -- Conditional select.
 236   shift = 11, mask = 1,
 237   [0] = {
 238     shift = 10, mask = 1,
 239     [0] = {
 240       shift = 29, mask = 3,
 241       [0] = "cselDNMzCg", false, "csinv|cinv|csetmDNMcg", false,
 242     },
 243     {
 244       shift = 29, mask = 3,
 245       [0] = "csinc|cinc|csetDNMcg", false, "csneg|cnegDNMcg", false,
 246     }
 247   }
 248 }
 249
 250 local map_data1s = { -- Data processing, 1 source.
 251   shift = 29, mask = 1,
 252   [0] = {
 253     shift = 31, mask = 1,
 254     [0] = {
 255       shift = 10, mask = 0x7ff,
 256       [0] = "rbitDNg", "rev16DNg", "revDNw", false, "clzDNg", "clsDNg"
 257     },
 258     {
 259       shift = 10, mask = 0x7ff,
 260       [0] = "rbitDNg", "rev16DNg", "rev32DNx", "revDNx", "clzDNg", "clsDNg"
 261     }
 262   }
 263 }
 264
 265 local map_data2s = { -- Data processing, 2 sources.
 266   shift = 29, mask = 1,
 267   [0] = {
 268     shift = 10, mask = 63,
 269     false, "udivDNMg", "sdivDNMg", false, false, false, false, "lslDNMg",
 270     "lsrDNMg", "asrDNMg", "rorDNMg"
 271   }
 272 }
 273
 274 local map_data3s = { -- Data processing, 3 sources.
 275   shift = 29, mask = 7,
 276   [0] = {
 277     shift = 21, mask = 7,
 278     [0] = {
 279       shift = 15, mask = 1,
 280       [0] = "madd|mulDNMA0g", "msub|mnegDNMA0g"
 281     }
 282   }, false, false, false,
 283   {
 284     shift = 15, mask = 1,
 285     [0] = {
 286       shift = 21, mask = 7,
 287       [0] = "madd|mulDNMA0g", "smaddl|smullDxNMwA0x", "smulhDNMx", false,
 288       false, "umaddl|umullDxNMwA0x", "umulhDNMx"
 289     },
 290     {
 291       shift = 21, mask = 7,
 292       [0] = "msub|mnegDNMA0g", "smsubl|smneglDxNMwA0x", false, false,
 293       false, "umsubl|umneglDxNMwA0x"
 294     }
 295   }
 296 }
 297
 298 local map_datar = { -- Data processing, register.
 299   shift = 28, mask = 1,
 300   [0] = {
 301     shift = 24, mask = 1,
 302     [0] = map_logsr,
 303     {
 304       shift = 21, mask = 1,
 305       [0] = map_addsubsh, map_addsubex
 306     }
 307   },
 308   {
 309     shift = 21, mask = 15,
 310     [0] = map_addsubc, false, map_ccomp, false, map_csel, false,
 311     {
 312       shift = 30, mask = 1,
 313       [0] = map_data2s, map_data1s
 314     },
 315     false, map_data3s, map_data3s, map_data3s, map_data3s, map_data3s,
 316     map_data3s, map_data3s, map_data3s
 317   }
 318 }
 319
 320 local map_lrl = { -- Load register, literal.
 321   shift = 26, mask = 1,
 322   [0] = {
 323     shift = 30, mask = 3,
 324     [0] = "ldrDwB", "ldrDxB", "ldrswDxB"
 325   },
 326   {
 327     shift = 30, mask = 3,
 328     [0] = "ldrDsB", "ldrDdB"
 329   }
 330 }
 331
 332 local map_lsriind = { -- Load/store register, immediate pre/post-indexed.
 333   shift = 30, mask = 3,
 334   [0] = {
 335     shift = 26, mask = 1,
 336     [0] = {
 337       shift = 22, mask = 3,
 338       [0] = "strbDwzL", "ldrbDwzL", "ldrsbDxzL", "ldrsbDwzL"
 339     }
 340   },
 341   {
 342     shift = 26, mask = 1,
 343     [0] = {
 344       shift = 22, mask = 3,
 345       [0] = "strhDwzL", "ldrhDwzL", "ldrshDxzL", "ldrshDwzL"
 346     }
 347   },
 348   {
 349     shift = 26, mask = 1,
 350     [0] = {
 351       shift = 22, mask = 3,
 352       [0] = "strDwzL", "ldrDwzL", "ldrswDxzL"
 353     },
 354     {
 355       shift = 22, mask = 3,
 356       [0] = "strDszL", "ldrDszL"
 357     }
 358   },
 359   {
 360     shift = 26, mask = 1,
 361     [0] = {
 362       shift = 22, mask = 3,
 363       [0] = "strDxzL", "ldrDxzL"
 364     },
 365     {
 366       shift = 22, mask = 3,
 367       [0] = "strDdzL", "ldrDdzL"
 368     }
 369   }
 370 }
 371
 372 local map_lsriro = {
 373   shift = 21, mask = 1,
 374   [0] = {  -- Load/store register immediate.
 375     shift = 10, mask = 3,
 376     [0] = { -- Unscaled immediate.
 377       shift = 26, mask = 1,
 378       [0] = {
 379         shift = 30, mask = 3,
 380         [0] = {
 381           shift = 22, mask = 3,
 382           [0] = "sturbDwK", "ldurbDwK"
 383         },
 384         {
 385           shift = 22, mask = 3,
 386           [0] = "sturhDwK", "ldurhDwK"
 387         },
 388         {
 389           shift = 22, mask = 3,
 390           [0] = "sturDwK", "ldurDwK"
 391         },
 392         {
 393           shift = 22, mask = 3,
 394           [0] = "sturDxK", "ldurDxK"
 395         }
 396       }
 397     }, map_lsriind, false, map_lsriind
 398   },
 399   {  -- Load/store register, register offset.
 400     shift = 10, mask = 3,
 401     [2] = {
 402       shift = 26, mask = 1,
 403       [0] = {
 404         shift = 30, mask = 3,
 405         [0] = {
 406           shift = 22, mask = 3,
 407           [0] = "strbDwO", "ldrbDwO", "ldrsbDxO", "ldrsbDwO"
 408         },
 409         {
 410           shift = 22, mask = 3,
 411           [0] = "strhDwO", "ldrhDwO", "ldrshDxO", "ldrshDwO"
 412         },
 413         {
 414           shift = 22, mask = 3,
 415           [0] = "strDwO", "ldrDwO", "ldrswDxO"
 416         },
 417         {
 418           shift = 22, mask = 3,
 419           [0] = "strDxO", "ldrDxO"
 420         }
 421       },
 422       {
 423         shift = 30, mask = 3,
 424         [2] = {
 425           shift = 22, mask = 3,
 426           [0] = "strDsO", "ldrDsO"
 427         },
 428         [3] = {
 429           shift = 22, mask = 3,
 430           [0] = "strDdO", "ldrDdO"
 431         }
 432       }
 433     }
 434   }
 435 }
 436
 437 local map_lsp = { -- Load/store register pair, offset.
 438   shift = 22, mask = 1,
 439   [0] = {
 440     shift = 30, mask = 3,
 441     [0] = {
 442       shift = 26, mask = 1,
 443       [0] = "stpDzAzwP", "stpDzAzsP",
 444     },
 445     {
 446       shift = 26, mask = 1,
 447       "stpDzAzdP"
 448     },
 449     {
 450       shift = 26, mask = 1,
 451       [0] = "stpDzAzxP"
 452     }
 453   },
 454   {
 455     shift = 30, mask = 3,
 456     [0] = {
 457       shift = 26, mask = 1,
 458       [0] = "ldpDzAzwP", "ldpDzAzsP",
 459     },
 460     {
 461       shift = 26, mask = 1,
 462       [0] = "ldpswDAxP", "ldpDzAzdP"
 463     },
 464     {
 465       shift = 26, mask = 1,
 466       [0] = "ldpDzAzxP"
 467     }
 468   }
 469 }
 470
 471 local map_ls = { -- Loads and stores.
 472   shift = 24, mask = 0x31,
 473   [0x10] = map_lrl, [0x30] = map_lsriro,
 474   [0x20] = {
 475     shift = 23, mask = 3,
 476     map_lsp, map_lsp, map_lsp
 477   },
 478   [0x21] = {
 479     shift = 23, mask = 3,
 480     map_lsp, map_lsp, map_lsp
 481   },
 482   [0x31] = {
 483     shift = 26, mask = 1,
 484     [0] = {
 485       shift = 30, mask = 3,
 486       [0] = {
 487         shift = 22, mask = 3,
 488         [0] = "strbDwzU", "ldrbDwzU"
 489       },
 490       {
 491         shift = 22, mask = 3,
 492         [0] = "strhDwzU", "ldrhDwzU"
 493       },
 494       {
 495         shift = 22, mask = 3,
 496         [0] = "strDwzU", "ldrDwzU"
 497       },
 498       {
 499         shift = 22, mask = 3,
 500         [0] = "strDxzU", "ldrDxzU"
 501       }
 502     },
 503     {
 504       shift = 30, mask = 3,
 505       [2] = {
 506         shift = 22, mask = 3,
 507         [0] = "strDszU", "ldrDszU"
 508       },
 509       [3] = {
 510         shift = 22, mask = 3,
 511         [0] = "strDdzU", "ldrDdzU"
 512       }
 513     }
 514   },
 515 }
 516
 517 local map_datafp = { -- Data processing, SIMD and FP.
 518   shift = 28, mask = 7,
 519   { -- 001
 520     shift = 24, mask = 1,
 521     [0] = {
 522       shift = 21, mask = 1,
 523       {
 524         shift = 10, mask = 3,
 525         [0] = {
 526           shift = 12, mask = 1,
 527           [0] = {
 528             shift = 13, mask = 1,
 529             [0] = {
 530               shift = 14, mask = 1,
 531               [0] = {
 532                 shift = 15, mask = 1,
 533                 [0] = { -- FP/int conversion.
 534                   shift = 31, mask = 1,
 535                   [0] = {
 536                     shift = 16, mask = 0xff,
 537                     [0x20] = "fcvtnsDwNs", [0x21] = "fcvtnuDwNs",
 538                     [0x22] = "scvtfDsNw", [0x23] = "ucvtfDsNw",
 539                     [0x24] = "fcvtasDwNs", [0x25] = "fcvtauDwNs",
 540                     [0x26] = "fmovDwNs", [0x27] = "fmovDsNw",
 541                     [0x28] = "fcvtpsDwNs", [0x29] = "fcvtpuDwNs",
 542                     [0x30] = "fcvtmsDwNs", [0x31] = "fcvtmuDwNs",
 543                     [0x38] = "fcvtzsDwNs", [0x39] = "fcvtzuDwNs",
 544                     [0x60] = "fcvtnsDwNd", [0x61] = "fcvtnuDwNd",
 545                     [0x62] = "scvtfDdNw", [0x63] = "ucvtfDdNw",
 546                     [0x64] = "fcvtasDwNd", [0x65] = "fcvtauDwNd",
 547                     [0x68] = "fcvtpsDwNd", [0x69] = "fcvtpuDwNd",
 548                     [0x70] = "fcvtmsDwNd", [0x71] = "fcvtmuDwNd",
 549                     [0x78] = "fcvtzsDwNd", [0x79] = "fcvtzuDwNd"
 550                   },
 551                   {
 552                     shift = 16, mask = 0xff,
 553                     [0x20] = "fcvtnsDxNs", [0x21] = "fcvtnuDxNs",
 554                     [0x22] = "scvtfDsNx", [0x23] = "ucvtfDsNx",
 555                     [0x24] = "fcvtasDxNs", [0x25] = "fcvtauDxNs",
 556                     [0x28] = "fcvtpsDxNs", [0x29] = "fcvtpuDxNs",
 557                     [0x30] = "fcvtmsDxNs", [0x31] = "fcvtmuDxNs",
 558                     [0x38] = "fcvtzsDxNs", [0x39] = "fcvtzuDxNs",
 559                     [0x60] = "fcvtnsDxNd", [0x61] = "fcvtnuDxNd",
 560                     [0x62] = "scvtfDdNx", [0x63] = "ucvtfDdNx",
 561                     [0x64] = "fcvtasDxNd", [0x65] = "fcvtauDxNd",
 562                     [0x66] = "fmovDxNd", [0x67] = "fmovDdNx",
 563                     [0x68] = "fcvtpsDxNd", [0x69] = "fcvtpuDxNd",
 564                     [0x70] = "fcvtmsDxNd", [0x71] = "fcvtmuDxNd",
 565                     [0x78] = "fcvtzsDxNd", [0x79] = "fcvtzuDxNd"
 566                   }
 567                 }
 568               },
 569               { -- FP data-processing, 1 source.
 570                 shift = 31, mask = 1,
 571                 [0] = {
 572                   shift = 22, mask = 3,
 573                   [0] = {
 574                     shift = 15, mask = 63,
 575                     [0] = "fmovDNf", "fabsDNf", "fnegDNf",
 576                     "fsqrtDNf", false, "fcvtDdNs", false, false,
 577                     "frintnDNf", "frintpDNf", "frintmDNf", "frintzDNf",
 578                     "frintaDNf", false, "frintxDNf", "frintiDNf",
 579                   },
 580                   {
 581                     shift = 15, mask = 63,
 582                     [0] = "fmovDNf", "fabsDNf", "fnegDNf",
 583                     "fsqrtDNf", "fcvtDsNd", false, false, false,
 584                     "frintnDNf", "frintpDNf", "frintmDNf", "frintzDNf",
 585                     "frintaDNf", false, "frintxDNf", "frintiDNf",
 586                   }
 587                 }
 588               }
 589             },
 590             { -- FP compare.
 591               shift = 31, mask = 1,
 592               [0] = {
 593                 shift = 14, mask = 3,
 594                 [0] = {
 595                   shift = 23, mask = 1,
 596                   [0] = {
 597                     shift = 0, mask = 31,
 598                     [0] = "fcmpNMf", [8] = "fcmpNZf",
 599                     [16] = "fcmpeNMf", [24] = "fcmpeNZf",
 600                   }
 601                 }
 602               }
 603             }
 604           },
 605           { -- FP immediate.
 606             shift = 31, mask = 1,
 607             [0] = {
 608               shift = 5, mask = 31,
 609               [0] = {
 610                 shift = 23, mask = 1,
 611                 [0] = "fmovDFf"
 612               }
 613             }
 614           }
 615         },
 616         { -- FP conditional compare.
 617           shift = 31, mask = 1,
 618           [0] = {
 619             shift = 23, mask = 1,
 620             [0] = {
 621               shift = 4, mask = 1,
 622               [0] = "fccmpNMVCf", "fccmpeNMVCf"
 623             }
 624           }
 625         },
 626         { -- FP data-processing, 2 sources.
 627           shift = 31, mask = 1,
 628           [0] = {
 629             shift = 23, mask = 1,
 630             [0] = {
 631               shift = 12, mask = 15,
 632               [0] = "fmulDNMf", "fdivDNMf", "faddDNMf", "fsubDNMf",
 633               "fmaxDNMf", "fminDNMf", "fmaxnmDNMf", "fminnmDNMf",
 634               "fnmulDNMf"
 635             }
 636           }
 637         },
 638         { -- FP conditional select.
 639           shift = 31, mask = 1,
 640           [0] = {
 641             shift = 23, mask = 1,
 642             [0] = "fcselDNMCf"
 643           }
 644         }
 645       }
 646     },
 647     { -- FP data-processing, 3 sources.
 648       shift = 31, mask = 1,
 649       [0] = {
 650         shift = 15, mask = 1,
 651         [0] = {
 652           shift = 21, mask = 5,
 653           [0] = "fmaddDNMAf", "fnmaddDNMAf"
 654         },
 655         {
 656           shift = 21, mask = 5,
 657           [0] = "fmsubDNMAf", "fnmsubDNMAf"
 658         }
 659       }
 660     }
 661   }
 662 }
 663
 664 local map_br = { -- Branches, exception generating and system instructions.
 665   shift = 29, mask = 7,
 666   [0] = "bB",
 667   { -- Compare & branch, immediate.
 668     shift = 24, mask = 3,
 669     [0] = "cbzDBg", "cbnzDBg", "tbzDTBw", "tbnzDTBw"
 670   },
 671   { -- Conditional branch, immediate.
 672     shift = 24, mask = 3,
 673     [0] = {
 674       shift = 4, mask = 1,
 675       [0] = {
 676         shift = 0, mask = 15,
 677         [0] = "beqB", "bneB", "bhsB", "bloB", "bmiB", "bplB", "bvsB", "bvcB",
 678         "bhiB", "blsB", "bgeB", "bltB", "bgtB", "bleB", "balB"
 679       }
 680     }
 681   }, false, "blB",
 682   { -- Compare & branch, immediate.
 683     shift = 24, mask = 3,
 684     [0] = "cbzDBg", "cbnzDBg", "tbzDTBx", "tbnzDTBx"
 685   },
 686   {
 687     shift = 24, mask = 3,
 688     [0] = { -- Exception generation.
 689       shift = 0, mask = 0xe0001f,
 690       [0x200000] = "brkW"
 691     },
 692     { -- System instructions.
 693       shift = 0, mask = 0x3fffff,
 694       [0x03201f] = "nop"
 695     },
 696     { -- Unconditional branch, register.
 697       shift = 0, mask = 0xfffc1f,
 698       [0x1f0000] = "brNx", [0x3f0000] = "blrNx",
 699       [0x5f0000] = "retNx"
 700     },
 701   }
 702 }
 703
 704 local map_init = {
 705   shift = 25, mask = 15,
 706   [0] = false, false, false, false, map_ls, map_datar, map_ls, map_datafp,
 707   map_datai, map_datai, map_br, map_br, map_ls, map_datar, map_ls, map_datafp
 708 }
 709
 710 ------------------------------------------------------------------------------
 711
 712 local map_regs = { x = {}, w = {}, d = {}, s = {} }
 713
 714 for i=0,30 do
 715   map_regs.x[i] = "x"..i
 716   map_regs.w[i] = "w"..i
 717   map_regs.d[i] = "d"..i
 718   map_regs.s[i] = "s"..i
 719 end
 720 map_regs.x[31] = "sp"
 721 map_regs.w[31] = "wsp"
 722 map_regs.d[31] = "d31"
 723 map_regs.s[31] = "s31"
 724
 725 local map_cond = {
 726   [0] = "eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
 727   "hi", "ls", "ge", "lt", "gt", "le", "al",
 728 }
 729
 730 local map_shift = { [0] = "lsl", "lsr", "asr", "ror"}
 731
 732 local map_extend = {
 733   [0] = "uxtb", "uxth", "uxtw", "uxtx", "sxtb", "sxth", "sxtw", "sxtx",
 734 }
 735
 736 ------------------------------------------------------------------------------
 737
 738 -- Output a nicely formatted line with an opcode and operands.
 739 local function putop(ctx, text, operands)
 740   local pos = ctx.pos
 741   local extra = ""
 742   if ctx.rel then
 743     local sym = ctx.symtab[ctx.rel]
 744     if sym then
 745       extra = "\t->"..sym
 746     end
 747   end
 748   if ctx.hexdump > 0 then
 749     ctx.out(format("%08x  %s  %-5s %s%s\n",
 750       ctx.addr+pos, tohex(ctx.op), text, concat(operands, ", "), extra))
 751   else
 752     ctx.out(format("%08x  %-5s %s%s\n",
 753       ctx.addr+pos, text, concat(operands, ", "), extra))
 754   end
 755   ctx.pos = pos + 4
 756 end
 757
 758 -- Fallback for unknown opcodes.
 759 local function unknown(ctx)
 760   return putop(ctx, ".long", { "0x"..tohex(ctx.op) })
 761 end
 762
 763 local function match_reg(p, pat, regnum)
 764   return map_regs[match(pat, p.."%w-([xwds])")][regnum]
 765 end
 766
 767 local function fmt_hex32(x)
 768   if x < 0 then
 769     return tohex(x)
 770   else
 771     return format("%x", x)
 772   end
 773 end
 774
 775 local imm13_rep = { 0x55555555, 0x11111111, 0x01010101, 0x00010001, 0x00000001 }
 776
 777 local function decode_imm13(op)
 778   local imms = band(rshift(op, 10), 63)
 779   local immr = band(rshift(op, 16), 63)
 780   if band(op, 0x00400000) == 0 then
 781     local len = 5
 782     if imms >= 56 then
 783       if imms >= 60 then len = 1 else len = 2 end
 784     elseif imms >= 48 then len = 3 elseif imms >= 32 then len = 4 end
 785     local l = lshift(1, len)-1
 786     local s = band(imms, l)
 787     local r = band(immr, l)
 788     local imm = ror(rshift(-1, 31-s), r)
 789     if len ~= 5 then imm = band(imm, lshift(1, l)-1) + rshift(imm, 31-l) end
 790     imm = imm * imm13_rep[len]
 791     local ix = fmt_hex32(imm)
 792     if rshift(op, 31) ~= 0 then
 793       return ix..tohex(imm)
 794     else
 795       return ix
 796     end
 797   else
 798     local lo, hi = -1, 0
 799     if imms < 32 then lo = rshift(-1, 31-imms) else hi = rshift(-1, 63-imms) end
 800     if immr ~= 0 then
 801       lo, hi = ror(lo, immr), ror(hi, immr)
 802       local x = immr == 32 and 0 or band(bxor(lo, hi), lshift(-1, 32-immr))
 803       lo, hi = bxor(lo, x), bxor(hi, x)
 804       if immr >= 32 then lo, hi = hi, lo end
 805     end
 806     if hi ~= 0 then
 807       return fmt_hex32(hi)..tohex(lo)
 808     else
 809       return fmt_hex32(lo)
 810     end
 811   end
 812 end
 813
 814 local function parse_immpc(op, name)
 815   if name == "b" or name == "bl" then
 816     return arshift(lshift(op, 6), 4)
 817   elseif name == "adr" or name == "adrp" then
 818     local immlo = band(rshift(op, 29), 3)
 819     local immhi = lshift(arshift(lshift(op, 8), 13), 2)
 820     return bor(immhi, immlo)
 821   elseif name == "tbz" or name == "tbnz" then
 822     return lshift(arshift(lshift(op, 13), 18), 2)
 823   else
 824     return lshift(arshift(lshift(op, 8), 13), 2)
 825   end
 826 end
 827
 828 local function parse_fpimm8(op)
 829   local sign = band(op, 0x100000) == 0 and 1 or -1
 830   local exp = bxor(rshift(arshift(lshift(op, 12), 5), 24), 0x80) - 131
 831   local frac = 16+band(rshift(op, 13), 15)
 832   return sign * frac * 2^exp
 833 end
 834
 835 local function prefer_bfx(sf, uns, imms, immr)
 836   if imms < immr or imms == 31 or imms == 63 then
 837     return false
 838   end
 839   if immr == 0 then
 840     if sf == 0 and (imms == 7 or imms == 15) then
 841       return false
 842     end
 843     if sf ~= 0 and uns == 0 and (imms == 7 or imms == 15 or imms == 31) then
 844       return false
 845     end
 846   end
 847   return true
 848 end
 849
 850 -- Disassemble a single instruction.
 851 local function disass_ins(ctx)
 852   local pos = ctx.pos
 853   local b0, b1, b2, b3 = byte(ctx.code, pos+1, pos+4)
 854   local op = bor(lshift(b3, 24), lshift(b2, 16), lshift(b1, 8), b0)
 855   local operands = {}
 856   local suffix = ""
 857   local last, name, pat
 858   local map_reg
 859   ctx.op = op
 860   ctx.rel = nil
 861   last = nil
 862   local opat
 863   opat = map_init[band(rshift(op, 25), 15)]
 864   while type(opat) ~= "string" do
 865     if not opat then return unknown(ctx) end
 866     opat = opat[band(rshift(op, opat.shift), opat.mask)] or opat._
 867   end
 868   name, pat = match(opat, "^([a-z0-9]*)(.*)")
 869   local altname, pat2 = match(pat, "|([a-z0-9_.|]*)(.*)")
 870   if altname then pat = pat2 end
 871   if sub(pat, 1, 1) == "." then
 872     local s2, p2 = match(pat, "^([a-z0-9.]*)(.*)")
 873     suffix = suffix..s2
 874     pat = p2
 875   end
 876
 877   local rt = match(pat, "[gf]")
 878   if rt then
 879     if rt == "g" then
 880       map_reg = band(op, 0x80000000) ~= 0 and map_regs.x or map_regs.w
 881     else
 882       map_reg = band(op, 0x400000) ~= 0 and map_regs.d or map_regs.s
 883     end
 884   end
 885
 886   local second0, immr
 887
 888   for p in gmatch(pat, ".") do
 889     local x = nil
 890     if p == "D" then
 891       local regnum = band(op, 31)
 892       x = rt and map_reg[regnum] or match_reg(p, pat, regnum)
 893     elseif p == "N" then
 894       local regnum = band(rshift(op, 5), 31)
 895       x = rt and map_reg[regnum] or match_reg(p, pat, regnum)
 896     elseif p == "M" then
 897       local regnum = band(rshift(op, 16), 31)
 898       x = rt and map_reg[regnum] or match_reg(p, pat, regnum)
 899     elseif p == "A" then
 900       local regnum = band(rshift(op, 10), 31)
 901       x = rt and map_reg[regnum] or match_reg(p, pat, regnum)
 902     elseif p == "B" then
 903       local addr = ctx.addr + pos + parse_immpc(op, name)
 904       ctx.rel = addr
 905       x = "0x"..tohex(addr)
 906     elseif p == "T" then
 907       x = bor(band(rshift(op, 26), 32), band(rshift(op, 19), 31))
 908     elseif p == "V" then
 909       x = band(op, 15)
 910     elseif p == "C" then
 911       x = map_cond[band(rshift(op, 12), 15)]
 912     elseif p == "c" then
 913       local rn = band(rshift(op, 5), 31)
 914       local rm = band(rshift(op, 16), 31)
 915       local cond = band(rshift(op, 12), 15)
 916       local invc = bxor(cond, 1)
 917       x = map_cond[cond]
 918       if altname and cond ~= 14 and cond ~= 15 then
 919         local a1, a2 = match(altname, "([^|]*)|(.*)")
 920         if rn == rm then
 921           local n = #operands
 922           operands[n] = nil
 923           x = map_cond[invc]
 924           if rn ~= 31 then
 925             if a1 then name = a1 else name = altname end
 926           else
 927             operands[n-1] = nil
 928             name = a2
 929           end
 930         end
 931       end
 932     elseif p == "W" then
 933       x = band(rshift(op, 5), 0xffff)
 934     elseif p == "Y" then
 935       x = band(rshift(op, 5), 0xffff)
 936       local hw = band(rshift(op, 21), 3)
 937       if altname and (hw == 0 or x ~= 0) then
 938         name = altname
 939       end
 940     elseif p == "L" then
 941       local rn = map_regs.x[band(rshift(op, 5), 31)]
 942       local imm9 = arshift(lshift(op, 11), 23)
 943       if band(op, 0x800) ~= 0 then
 944         x = "["..rn..", #"..imm9.."]!"
 945       else
 946         x = "["..rn.."], #"..imm9
 947       end
 948     elseif p == "U" then
 949       local rn = map_regs.x[band(rshift(op, 5), 31)]
 950       local sz = band(rshift(op, 30), 3)
 951       local imm12 = lshift(rshift(lshift(op, 10), 20), sz)
 952       if imm12 ~= 0 then
 953         x = "["..rn..", #"..imm12.."]"
 954       else
 955         x = "["..rn.."]"
 956       end
 957     elseif p == "K" then
 958       local rn = map_regs.x[band(rshift(op, 5), 31)]
 959       local imm9 = arshift(lshift(op, 11), 23)
 960       if imm9 ~= 0 then
 961         x = "["..rn..", #"..imm9.."]"
 962       else
 963         x = "["..rn.."]"
 964       end
 965     elseif p == "O" then
 966       local rn, rm = map_regs.x[band(rshift(op, 5), 31)]
 967       local m = band(rshift(op, 13), 1)
 968       if m == 0 then
 969         rm = map_regs.w[band(rshift(op, 16), 31)]
 970       else
 971         rm = map_regs.x[band(rshift(op, 16), 31)]
 972       end
 973       x = "["..rn..", "..rm
 974       local opt = band(rshift(op, 13), 7)
 975       local s = band(rshift(op, 12), 1)
 976       local sz = band(rshift(op, 30), 3)
 977       -- extension to be applied
 978       if opt == 3 then
 979        if s == 0 then x = x.."]"
 980        else x = x..", lsl #"..sz.."]" end
 981       elseif opt == 2 or opt == 6 or opt == 7 then
 982         if s == 0 then x = x..", "..map_extend[opt].."]"
 983         else x = x..", "..map_extend[opt].." #"..sz.."]" end
 984       else
 985         x = x.."]"
 986       end
 987     elseif p == "P" then
 988       local sh = 2 + rshift(op, 31 - band(rshift(op, 26), 1))
 989       local imm7 = lshift(arshift(lshift(op, 10), 25), sh)
 990       local rn = map_regs.x[band(rshift(op, 5), 31)]
 991       local ind = band(rshift(op, 23), 3)
 992       if ind == 1 then
 993         x = "["..rn.."], #"..imm7
 994       elseif ind == 2 then
 995         if imm7 == 0 then
 996           x = "["..rn.."]"
 997         else
 998           x = "["..rn..", #"..imm7.."]"
 999         end
1000       elseif ind == 3 then
1001         x = "["..rn..", #"..imm7.."]!"
1002       end
1003     elseif p == "I" then
1004       local shf = band(rshift(op, 22), 3)
1005       local imm12 = band(rshift(op, 10), 0x0fff)
1006       local rn, rd = band(rshift(op, 5), 31), band(op, 31)
1007       if altname == "mov" and shf == 0 and imm12 == 0 and (rn == 31 or rd == 31) then
1008         name = altname
1009         x = nil
1010       elseif shf == 0 then
1011         x = imm12
1012       elseif shf == 1 then
1013         x = imm12..", lsl #12"
1014       end
1015     elseif p == "i" then
1016       x = "#0x"..decode_imm13(op)
1017     elseif p == "1" then
1018       immr = band(rshift(op, 16), 63)
1019       x = immr
1020     elseif p == "2" then
1021       x = band(rshift(op, 10), 63)
1022       if altname then
1023         local a1, a2, a3, a4, a5, a6 =
1024           match(altname, "([^|]*)|([^|]*)|([^|]*)|([^|]*)|([^|]*)|(.*)")
1025         local sf = band(rshift(op, 26), 32)
1026         local uns = band(rshift(op, 30), 1)
1027         if prefer_bfx(sf, uns, x, immr) then
1028           name = a2
1029           x = x - immr + 1
1030         elseif immr == 0 and x == 7 then
1031           local n = #operands
1032           operands[n] = nil
1033           if sf ~= 0 then
1034             operands[n-1] = gsub(operands[n-1], "x", "w")
1035           end
1036           last = operands[n-1]
1037           name = a6
1038           x = nil
1039         elseif immr == 0 and x == 15 then
1040           local n = #operands
1041           operands[n] = nil
1042           if sf ~= 0 then
1043             operands[n-1] = gsub(operands[n-1], "x", "w")
1044           end
1045           last = operands[n-1]
1046           name = a5
1047           x = nil
1048         elseif x == 31 or x == 63 then
1049           if x == 31 and immr == 0 and name == "sbfm" then
1050             name = a4
1051             local n = #operands
1052             operands[n] = nil
1053             if sf ~= 0 then
1054               operands[n-1] = gsub(operands[n-1], "x", "w")
1055             end
1056             last = operands[n-1]
1057           else
1058             name = a3
1059           end
1060           x = nil
1061         elseif band(x, 31) ~= 31 and immr == x+1 and name == "ubfm" then
1062           name = a4
1063           last = "#"..(sf+32 - immr)
1064           operands[#operands] = last
1065           x = nil
1066         elseif x < immr then
1067           name = a1
1068           last = "#"..(sf+32 - immr)
1069           operands[#operands] = last
1070           x = x + 1
1071         end
1072       end
1073     elseif p == "3" then
1074       x = band(rshift(op, 10), 63)
1075       if altname then
1076         local a1, a2 = match(altname, "([^|]*)|(.*)")
1077         if x < immr then
1078           name = a1
1079           local sf = band(rshift(op, 26), 32)
1080           last = "#"..(sf+32 - immr)
1081           operands[#operands] = last
1082           x = x + 1
1083         else
1084           name = a2
1085           x = x - immr + 1
1086         end
1087       end
1088     elseif p == "4" then
1089       x = band(rshift(op, 10), 63)
1090       local rn = band(rshift(op, 5), 31)
1091       local rm = band(rshift(op, 16), 31)
1092       if altname and rn == rm then
1093         local n = #operands
1094         operands[n] = nil
1095         last = operands[n-1]
1096         name = altname
1097       end
1098     elseif p == "5" then
1099       x = band(rshift(op, 16), 31)
1100     elseif p == "S" then
1101       x = band(rshift(op, 10), 63)
1102       if x == 0 then x = nil
1103       else x = map_shift[band(rshift(op, 22), 3)].." #"..x end
1104     elseif p == "X" then
1105       local opt = band(rshift(op, 13), 7)
1106       -- Width specifier <R>.
1107       if opt ~= 3 and opt ~= 7 then
1108         last = map_regs.w[band(rshift(op, 16), 31)]
1109         operands[#operands] = last
1110       end
1111       x = band(rshift(op, 10), 7)
1112       -- Extension.
1113       if opt == 2 + band(rshift(op, 31), 1) and
1114          band(rshift(op, second0 and 5 or 0), 31) == 31 then
1115         if x == 0 then x = nil
1116         else x = "lsl #"..x end
1117       else
1118         if x == 0 then x = map_extend[band(rshift(op, 13), 7)]
1119         else x = map_extend[band(rshift(op, 13), 7)].." #"..x end
1120       end
1121     elseif p == "R" then
1122       x = band(rshift(op,21), 3)
1123       if x == 0 then x = nil
1124       else x = "lsl #"..x*16 end
1125     elseif p == "z" then
1126       local n = #operands
1127       if operands[n] == "sp" then operands[n] = "xzr"
1128       elseif operands[n] == "wsp" then operands[n] = "wzr"
1129       end
1130     elseif p == "Z" then
1131       x = 0
1132     elseif p == "F" then
1133       x = parse_fpimm8(op)
1134     elseif p == "g" or p == "f" or p == "x" or p == "w" or
1135            p == "d" or p == "s" then
1136       -- These are handled in D/N/M/A.
1137     elseif p == "0" then
1138       if last == "sp" or last == "wsp" then
1139         local n = #operands
1140         operands[n] = nil
1141         last = operands[n-1]
1142         if altname then
1143           local a1, a2 = match(altname, "([^|]*)|(.*)")
1144           if not a1 then
1145             name = altname
1146           elseif second0 then
1147             name, altname = a2, a1
1148           else
1149             name, altname = a1, a2
1150           end
1151         end
1152       end
1153       second0 = true
1154     else
1155       assert(false)
1156     end
1157     if x then
1158       last = x
1159       if type(x) == "number" then x = "#"..x end
1160       operands[#operands+1] = x
1161     end
1162   end
1163
1164   return putop(ctx, name..suffix, operands)
1165 end
1166
1167 ------------------------------------------------------------------------------
1168
1169 -- Disassemble a block of code.
1170 local function disass_block(ctx, ofs, len)
1171   if not ofs then ofs = 0 end
1172   local stop = len and ofs+len or #ctx.code
1173   ctx.pos = ofs
1174   ctx.rel = nil
1175   while ctx.pos < stop do disass_ins(ctx) end
1176 end
1177
1178 -- Extended API: create a disassembler context. Then call ctx:disass(ofs, len).
1179 local function create(code, addr, out)
1180   local ctx = {}
1181   ctx.code = code
1182   ctx.addr = addr or 0
1183   ctx.out = out or io.write
1184   ctx.symtab = {}
1185   ctx.disass = disass_block
1186   ctx.hexdump = 8
1187   return ctx
1188 end
1189
1190 -- Simple API: disassemble code (a string) at address and output via out.
1191 local function disass(code, addr, out)
1192   create(code, addr, out):disass()
1193 end
1194
1195 -- Return register name for RID.
1196 local function regname(r)
1197   if r < 32 then return map_regs.x[r] end
1198   return map_regs.d[r-32]
1199 end
1200
1201 -- Public module functions.
1202 return {
1203   create = create,
1204   disass = disass,
1205   regname = regname
1206 }
1207