Organize source code and tests

5 files changed, 1101 insertions, 0 deletions

diff --git a/tests/test.bash b/tests/test.bash
new file mode 100644
index 0000000..6025908
--- /dev/null
+++ b/tests/test.bash
@@ -0,0 +1,709 @@
+#!/usr/bin/env bash
+#
+# SPDX-License-Identifier: Unlicense
+#
+# Tests against m68k-none-elf-as.
+
+AS=m68k-none-elf-as
+OBJCOPY=m68k-none-elf-objcopy
+LD="m68k-none-elf-ld -Ttest.ld"
+DISASM="../cmake-build/m68k-disasm -fabs-labels -frel-labels -flabels -fimm-hex -ffollow-jumps"
+TEST_DIR=/tmp/m68k-disasm-tests
+
+set -e
+CRED="\033[31m"
+CGREEN="\033[32m"
+CRST="\033[39m"
+
+rm -rf ${TEST_DIR}
+mkdir -p ${TEST_DIR}
+
+run_test_expect_short() {
+  local test_name=$1
+  local test_name_sanitized=${test_name//[^a-zA-Z0-9_\-]/-}
+  local data=$2
+  local file_orig_bin=${TEST_DIR}/${test_name_sanitized}.orig.bin
+  local file_asm=${TEST_DIR}/${test_name_sanitized}.S
+  local file_as_o=${TEST_DIR}/${test_name_sanitized}.as.o
+  local file_as_elf=${TEST_DIR}/${test_name_sanitized}.as.elf
+  local file_as_bin=${TEST_DIR}/${test_name_sanitized}.as.bin
+  echo -ne "Test expect .short \"${test_name}\"... "
+  echo -ne "${data}" >${file_orig_bin}
+  ${DISASM} -o ${file_asm} ${file_orig_bin}
+  ${AS} -m68000 -o ${file_as_o} ${file_asm}
+  ${LD} -o ${file_as_elf} ${file_as_o}
+  ${OBJCOPY} ${file_as_elf} -O binary ${file_as_bin}
+  if ! grep ".short" ${file_asm} >/dev/null 2>&1; then
+    echo -e "${CRED}FAIL${CRST}: NOT .short emitted, but .short EXPECTED"
+    cat ${file_asm}
+  elif ! cmp ${file_orig_bin} ${file_as_bin} >/dev/null 2>&1; then
+    echo -e "${CRED}FAIL${CRST}: output and input binaries do not match"
+    cat ${file_asm}
+    echo ${file_orig_bin}
+    hexdump -Cv ${file_orig_bin} | head -n1
+    echo ${file_as_bin}
+    hexdump -Cv ${file_as_bin} | head -n1
+  else
+    echo -e "${CGREEN}OK${CRST}"
+    #cat ${file_asm}
+  fi
+}
+
+run_test_simple() {
+  local test_name=$1
+  local test_name_sanitized=${test_name//[^a-zA-Z0-9_\-]/-}
+  local data=$2
+  local file_orig_bin=${TEST_DIR}/${test_name_sanitized}.orig.bin
+  local file_asm=${TEST_DIR}/${test_name_sanitized}.S
+  local file_as_o=${TEST_DIR}/${test_name_sanitized}.as.o
+  local file_as_elf=${TEST_DIR}/${test_name_sanitized}.as.elf
+  local file_as_bin=${TEST_DIR}/${test_name_sanitized}.as.bin
+  echo -ne "Test \"${test_name}\"... "
+  echo -ne "${data}" >${file_orig_bin}
+  ${DISASM} -o ${file_asm} ${file_orig_bin}
+  ${AS} -m68000 -o ${file_as_o} ${file_asm}
+  ${LD} -o ${file_as_elf} ${file_as_o}
+  ${OBJCOPY} ${file_as_elf} -O binary ${file_as_bin}
+  if ! cmp ${file_orig_bin} ${file_as_bin} >/dev/null 2>&1; then
+    echo -e "${CRED}FAIL${CRST}: output and input binaries do not match"
+    cat ${file_asm}
+    echo ${file_orig_bin}
+    hexdump -Cv ${file_orig_bin} | head -n1
+    echo ${file_as_bin}
+    hexdump -Cv ${file_as_bin} | head -n1
+  elif grep ".short" ${file_asm} >/dev/null 2>&1; then
+    echo -e "${CRED}FAIL${CRST}: .short emitted"
+    cat ${file_asm}
+  else
+    echo -e "${CGREEN}OK${CRST}"
+    #cat ${file_asm}
+  fi
+}
+
+run_test_iterative() {
+  local test_name=$1
+  local prefix=$2
+  local offset=$3
+  local count=$4
+  local step=$5
+  local suffix=$6
+  for i in $(seq 0 $(( step )) $(( count*step-1 )) ); do
+    local value=$(printf "%02x" $(( offset+i )))
+    run_test_simple "${test_name}:${value}" "${prefix}\x${value}${suffix}"
+  done
+}
+
+# bxxx cmpm
+#
+run_test_simple "cmpmb (An)+, (An)+" "\xb1\x08"
+run_test_simple "cmpmw (An)+, (An)+" "\xb1\x48"
+run_test_simple "cmpml (An)+, (An)+" "\xb1\x88"
+
+# bxxx eor
+#
+run_test_simple "eorb Dn, Dn" "\xb5\x01"
+run_test_simple "eorb Dn, (An)" "\xb5\x11"
+run_test_simple "eorb Dn, (An)+" "\xb5\x19"
+run_test_simple "eorw Dn, -(An)" "\xb5\x61"
+run_test_simple "eorl Dn, (xxx).L" "\xb5\xb9\xff\xff\x00\x00"
+
+# bxxx cmp
+#
+run_test_simple "cmpb Dn, Dn" "\xb4\x01"
+run_test_expect_short "cmpb An, Dn" "\xb4\x09"
+run_test_simple "cmpw An, Dn" "\xb4\x49"
+run_test_simple "cmpb (An), Dn" "\xb4\x11"
+run_test_simple "cmpb (An)+, Dn" "\xb4\x19"
+run_test_simple "cmpb -(An), Dn" "\xb4\x21"
+run_test_simple "cmpl (d8,PC,An), Dn" "\xb0\xbb\x88\xff"
+run_test_simple "cmpw (xxx).W, Dn" "\xb0\x78\x88\xff"
+# GNU AS would emit CMPI for "cmp #imm,Xn", so we disassemble it as short
+run_test_expect_short "cmpl #imm, D6" "\xb6\xbc\x44\xd1\xe6\xe9"
+
+# bxxx cmpa
+#
+run_test_simple "cmpaw Dn, An" "\xb4\xc1"
+run_test_simple "cmpal An, An" "\xbb\xca"
+run_test_simple "cmpaw (An)+, An" "\xba\xda"
+run_test_simple "cmpal (xxx).L, An" "\xbb\xf9\x80\x00\x00\x00"
+run_test_simple "cmpaw #imm, An" "\xba\xfc\x01\x00"
+run_test_simple "cmpal #imm, An" "\xbb\xfc\x80\x00\x00\x00"
+
+# cxxx divu divs
+#
+run_test_simple "divuw Dn, Dn" "\x82\xc6"
+run_test_simple "divsw (An), Dn" "\x83\xd6"
+run_test_simple "divuw (An)+, Dn" "\x82\xde"
+run_test_simple "divsw -(An), Dn" "\x83\xe6"
+run_test_simple "divuw (d16,An), Dn" "\x82\xee\xa0\x00"
+run_test_simple "divsw (d8,An,Dn:l), Dn" "\x83\xf6\x68\xf0"
+run_test_simple "divuw (xxx).W, Dn" "\x82\xf8\x30\x00"
+run_test_simple "divsw (xxx).L, Dn" "\x83\xf9\x80\x00\x00\x00"
+run_test_simple "divuw (d16,PC), Dn" "\x82\xfa\xff\xff"
+run_test_simple "divsw (d8,PC,An:w), Dn" "\x83\xfb\x90\xff"
+run_test_simple "divuw #imm, Dn" "\x82\xfc\x30\x00"
+
+# cxxx mulu muls
+#
+run_test_simple "muluw Dn, Dn" "\xc2\xc6"
+run_test_simple "mulsw (An), Dn" "\xc3\xd6"
+run_test_simple "muluw (An)+, Dn" "\xc2\xde"
+run_test_simple "mulsw -(An), Dn" "\xc3\xe6"
+run_test_simple "muluw (d16,An), Dn" "\xc2\xee\xa0\x00"
+run_test_simple "mulsw (d8,An,Dn:l), Dn" "\xc3\xf6\x68\xf0"
+run_test_simple "muluw (xxx).W, Dn" "\xc2\xf8\x30\x00"
+run_test_simple "mulsw (xxx).L, Dn" "\xc3\xf9\x80\x00\x00\x00"
+run_test_simple "muluw (d16,PC), Dn" "\xc2\xfa\xff\xff"
+run_test_simple "mulsw (d8,PC,An:w), Dn" "\xc3\xfb\x90\xff"
+run_test_simple "muluw #imm, Dn" "\xc2\xfc\x30\x00"
+
+# cxxx exg
+#
+run_test_simple "exg Dn, Dn" "\xcd\x41"
+run_test_simple "exg Dn, An" "\xcd\x89"
+run_test_simple "exg An, An" "\xcd\x49"
+
+# cxxx and
+#
+run_test_simple "andb Dn, Dn" "\xc4\x01"
+run_test_expect_short "andb An, Dn" "\xc4\x09"
+run_test_expect_short "andw An, Dn" "\xc4\x49"
+run_test_simple "andb (An), Dn" "\xc4\x11"
+run_test_simple "andb (An)+, Dn" "\xc4\x19"
+run_test_simple "andw -(An), Dn" "\xc4\x61"
+run_test_simple "andl (d8,PC,An), Dn" "\xc0\xbb\xc8\x07"
+# GNU AS would emit ANDI for "and #imm,Xn", so we disassemble it as short
+run_test_expect_short "andl #imm, D6" "\xc6\xbc\x44\xd1\xe6\xe9"
+
+# cxxx abcd
+#
+run_test_simple "abcd Dn, Dn" "\xc1\x01"
+run_test_simple "abcd -(An), -(An)" "\xc1\x09"
+
+# 8xxx sbcd
+#
+run_test_simple "sbcdb Dn, Dn" "\x81\x01"
+run_test_simple "sbcdb -(An), -(An)" "\x81\x09"
+
+# 8xxx or
+#
+run_test_simple "orb Dn, Dn" "\x84\x01"
+run_test_expect_short "orb An, Dn" "\x84\x09"
+run_test_expect_short "orw An, Dn" "\x84\x49"
+run_test_simple "orb (An), Dn" "\x84\x11"
+run_test_simple "orb (An)+, Dn" "\x84\x19"
+run_test_simple "orw -(An), Dn" "\x84\x61"
+run_test_simple "orl (d8,PC,An), Dn" "\x80\xbb\x88\x07"
+# GNU AS would emit ORI for "or #imm,Xn", so we disassemble it as short
+run_test_expect_short "orl #imm, D6" "\x86\xbc\x44\xd1\xe6\xe9"
+run_test_expect_short "orl D2, D0 swapped direction" "\x81\x42"
+
+# 48xx nbcd swap pea
+#
+run_test_simple "swapw Dn" "\x48\x47"
+run_test_simple "swapw Dn" "\x48\x42"
+run_test_simple "peal (An)" "\x48\x50"
+run_test_simple "peal (d16,An)" "\x48\x68\x80\x00"
+run_test_simple "peal (d8,An,An)" "\x48\x77\x90\xfe"
+run_test_simple "peal (d16,PC)" "\x48\x7a\x7f\xff"
+run_test_simple "peal (d8,PC,Dn)" "\x48\x7b\x68\xfe"
+run_test_simple "nbcdb Dn" "\x48\x03"
+run_test_simple "nbcdb (An)" "\x48\x14"
+run_test_simple "nbcdb (An)+" "\x48\x1c"
+run_test_simple "nbcdb -(An)" "\x48\x25"
+run_test_simple "nbcdb (d16,An)" "\x48\x28\x80\x00"
+run_test_simple "nbcdb (d8,An,An)" "\x48\x37\x90\xfe"
+
+# 48xx ext
+#
+run_test_simple "extw %d7" "\x48\x87"
+run_test_simple "extl %d4" "\x48\xc4"
+
+# exxx asl, asr, lsl, lsr, roxl, roxr, rol, ror
+#
+run_test_simple "asrb Dn, Dn" "\xe2\x22"
+run_test_simple "asrb #1, Dn" "\xe2\x02"
+run_test_simple "asrb #8, Dn" "\xe0\x02"
+run_test_simple "aslb #7, Dn" "\xef\x02"
+run_test_simple "asrw Dn, Dn" "\xe2\x62"
+run_test_simple "asrl Dn, Dn" "\xe2\xa2"
+run_test_simple "aslw #6, Dn" "\xed\x43"
+run_test_simple "asll #5, Dn" "\xeb\x83"
+run_test_simple "asrw (An)" "\xe0\xd0"
+run_test_simple "lsrw (An)+" "\xe2\xd8"
+run_test_simple "roxrw -(An)" "\xe4\xe0"
+run_test_simple "rorw (d16,An)" "\xe6\xef\x01\x00"
+# Found on random tests
+run_test_simple "lsrb D1,D4" "\xe2\x2c"
+
+# 9xxx subx
+#
+run_test_simple "subxb Dn, Dn" "\x91\x00"
+run_test_simple "subxw Dn, Dn" "\x93\x47"
+run_test_simple "subxl Dn, Dn" "\x95\x86"
+run_test_simple "subxb -(An), -(An)" "\x91\x08"
+run_test_simple "subxw -(An), -(An)" "\x93\x4f"
+run_test_simple "subxl -(An), -(An)" "\x95\x8e"
+
+# 9xxx suba
+#
+run_test_simple "subaw Dn, An" "\x94\xc1"
+run_test_simple "subal An, An" "\x9b\xca"
+run_test_simple "subaw (An)+, An" "\x9a\xda"
+run_test_simple "subaw #imm, An" "\x9a\xfc\x01\x00"
+run_test_simple "subal #imm, An" "\x9b\xfc\x80\x00\x00\x00"
+
+# 9xxx sub
+#
+run_test_simple "subb Dn, Dn" "\x94\x01"
+run_test_expect_short "subb An, Dn" "\x94\x09"
+run_test_simple "subw An, Dn" "\x94\x49"
+run_test_simple "subb (An), Dn" "\x94\x11"
+run_test_simple "subb (An)+, Dn" "\x94\x19"
+run_test_simple "subb -(An), Dn" "\x94\x21"
+# GNU AS would emit SUBQ for "sub #imm,Xn", so we disassemble it as short
+run_test_expect_short "subl #imm, D6" "\x96\xbc\x44\xd1\xe6\xe9"
+
+# dxxx addx
+#
+run_test_simple "addxb Dn, Dn" "\xd1\x00"
+run_test_simple "addxw Dn, Dn" "\xd3\x47"
+run_test_simple "addxl Dn, Dn" "\xd5\x86"
+run_test_simple "addxb -(An), -(An)" "\xd1\x08"
+run_test_simple "addxw -(An), -(An)" "\xd3\x4f"
+run_test_simple "addxl -(An), -(An)" "\xd5\x8e"
+
+# dxxx adda
+#
+run_test_simple "addaw Dn, An" "\xd4\xc1"
+run_test_simple "addal An, An" "\xdb\xca"
+run_test_simple "addaw (An)+, An" "\xda\xda"
+run_test_simple "addaw #imm, An" "\xda\xfc\x01\x00"
+run_test_simple "addal #imm, An" "\xdb\xfc\x80\x00\x00\x00"
+
+# dxxx add
+#
+run_test_simple "addb Dn, Dn" "\xd4\x01"
+run_test_expect_short "addb An, Dn" "\xd4\x09"
+run_test_simple "addw An, Dn" "\xd4\x49"
+run_test_simple "addb (An), Dn" "\xd4\x11"
+run_test_simple "addb (An)+, Dn" "\xd4\x19"
+run_test_simple "addb -(An), Dn" "\xd4\x21"
+run_test_simple "addl (d8,PC,An), Dn" "\xd0\xbb\x88\xff"
+# GNU AS would emit ADDI for "add #imm,Xn", so we disassemble it as short
+run_test_expect_short "addl #imm, D6" "\xd6\xbc\x44\xd1\xe6\xe9"
+
+# 4xxx chkw
+#
+run_test_simple "chkw Dn" "\x47\x82"
+run_test_simple "chkw (An)" "\x41\x90"
+run_test_simple "chkw (An)+" "\x47\x9b"
+run_test_simple "chkw (d16,An)" "\x47\xa9\x80\x00"
+run_test_simple "chkw (d8,An,Xi)" "\x47\xb2\xa8\x7f"
+
+# 4xxx leal
+#
+run_test_simple "leal (An)" "\x41\xd0"
+run_test_simple "leal (d16,An)" "\x47\xe9\x80\x00"
+run_test_simple "leal (d8,An,Xi)" "\x47\xf2\xa8\x7f"
+run_test_simple "leal (d16,PC)" "\x47\xfa\x7f\xff"
+run_test_simple "leal (d8,PC,Xi)" "\x47\xfb\xa8\x80"
+
+# 0xxx movep
+#
+run_test_simple "movepw Dn to (An)" "\x01\x0b\x00\xa0"
+run_test_simple "movepl Dn to (An)" "\x03\x4a\x00\xa0"
+run_test_simple "movepw (An) to Dn" "\x05\x89\x00\xa0"
+run_test_simple "movepl (An) to Dn" "\x07\xc8\x00\xa0"
+
+# 0xxx bitwise ops
+#
+run_test_simple "btstl immediate in Dn" "\x08\x07\x00\x06"
+run_test_simple "btstb immediate in (An)" "\x08\x17\x00\x06"
+run_test_simple "btstb immediate in (xxx).L" "\x08\x39\x00\x06\xff\x00\x00\x00"
+run_test_simple "btstb Dn in (xxx).L" "\x03\x39\xff\x00\x00\x00"
+run_test_simple "bchgb Dn in (xxx).L" "\x05\x79\xff\x00\x00\x00"
+run_test_simple "bclrb Dn in (xxx).L" "\x07\xb9\xff\x00\x00\x00"
+run_test_simple "bsetb Dn in (xxx).L" "\x09\xf9\xff\x00\x00\x00"
+run_test_expect_short "btstb large immediate in (xxx).L" "\x08\x39\x10\x21\xff\x00\x00\x00"
+
+# 0xxx immediate ops
+#
+run_test_simple "orib #0, D0" "\x00\x00\x00\x00"
+run_test_simple "orib zero to CCR" "\x00\x3c\x00\x00"
+run_test_simple "orib positive to CCR" "\x00\x3c\x00\x01"
+run_test_simple "orib positive to CCR" "\x00\x3c\x00\x7f"
+run_test_expect_short "orib #imm (too much for orib) to CCR" "\x00\x3c\x01\x00"
+run_test_simple "orib negative to CCR" "\x00\x3c\xff\x80"
+run_test_simple "orib negative to CCR" "\x00\x3c\xff\xff"
+run_test_simple "oriw zero to SR" "\x00\x7c\x00\x00"
+run_test_simple "oriw positive to SR" "\x00\x7c\x00\x0a"
+run_test_simple "andiw positive to SR" "\x02\x7c\x00\x0a"
+run_test_simple "eoriw positive to SR" "\x0a\x7c\x00\x0a"
+run_test_simple "andib positive to CCR" "\x02\x3c\x00\x0a"
+run_test_simple "eorib positive to CCR" "\x0a\x3c\x00\x0a"
+run_test_simple "orib positive to Dn" "\x00\x07\x00\x0a"
+run_test_simple "oriw positive to Dn" "\x00\x45\x00\x0a"
+run_test_simple "oril positive to Dn" "\x00\x83\x00\x00\x00\x0a"
+run_test_simple "andib negative to Dn" "\x00\x07\xff\x80"
+run_test_simple "andiw negative to Dn" "\x00\x45\xff\x80"
+run_test_simple "andil negative to Dn" "\x00\x83\xff\x80\x00\x00"
+run_test_simple "addiw zero to (An)+" "\x06\x5a\x00\x00"
+run_test_simple "subiw zero from -(An)" "\x06\x62\x00\x00"
+run_test_simple "cmpib zero to (An)" "\x0c\x12\x00\x20"
+run_test_simple "cmpiw zero to (An)" "\x0c\x52\x00\x30"
+run_test_simple "cmpil zero to (An)" "\x0c\x92\x00\x00\x00\x40"
+# From random tests
+run_test_expect_short "cmpil with invalid opsize" "\x0c\xe4\x26\xa3"
+
+# 4axx
+#
+run_test_simple "tas Dn" "\x4a\xc2"
+run_test_simple "tstb Dn" "\x4a\x02"
+run_test_simple "tstw Dn" "\x4a\x42"
+run_test_simple "tstl Dn" "\x4a\x82"
+run_test_expect_short "tas (d16,PC)" "\x4a\xfa\xff\xff"
+run_test_expect_short "tas (d8,PC,Xi)" "\x4a\xfb\x00\x00"
+
+# 4xxx
+#
+run_test_simple "negxb Dn" "\x40\x04"
+run_test_simple "clrb Dn" "\x42\x05"
+run_test_simple "negb Dn" "\x44\x06"
+run_test_simple "notb Dn" "\x46\x07"
+run_test_simple "negxw Dn" "\x40\x44"
+run_test_simple "clrw Dn" "\x42\x45"
+run_test_simple "negw Dn" "\x44\x46"
+run_test_simple "notw Dn" "\x46\x47"
+run_test_simple "negxl Dn" "\x40\x84"
+run_test_simple "clrl Dn" "\x42\x85"
+run_test_simple "negl Dn" "\x44\x86"
+run_test_simple "notl Dn" "\x46\x87"
+
+# 4e4x
+#
+run_test_simple "trap 0" "\x4e\x40"
+run_test_simple "trap 8" "\x4e\x48"
+run_test_simple "trap 15" "\x4e\x4f"
+
+# 4e5x
+#
+run_test_simple "linkw positive" "\x4e\x52\x01\x00"
+run_test_simple "linkw negative" "\x4e\x52\xff\xff"
+run_test_simple "linkw negative" "\x4e\x52\x80\x00"
+run_test_simple "unlk" "\x4e\x5a"
+
+# 4e6x
+#
+run_test_simple "move to USP" "\x4e\x62"
+run_test_simple "move from USP" "\x4e\x6f"
+
+# 4xxx
+#
+run_test_simple "move from SR" "\x40\xc1"
+run_test_simple "move to CCR" "\x44\xc2"
+run_test_simple "move to SR" "\x46\xc3"
+
+# 70xx / 72xx/ 74xx / 76xx / 78xx / 7axx / 7cxx / 7exx
+#
+run_test_simple "moveq #0 to D0" "\x70\x00"
+run_test_simple "moveq #1 to D2" "\x74\x01"
+run_test_simple "moveq #127 to D7" "\x7e\x7f"
+run_test_simple "moveq #-1 to D5" "\x7a\xff"
+run_test_simple "moveq #-128 to D1" "\x72\x80"
+
+# 1xxx [xxxx [xxxx]]
+#
+run_test_simple "moveb Dn to Dn" "\x10\x01"
+run_test_expect_short "moveb An to Dn" "\x10\x09"
+run_test_simple "moveb (An) to Dn" "\x10\x11"
+run_test_simple "moveb (An)+ to Dn" "\x10\x19"
+run_test_simple "moveb -(An) to Dn" "\x10\x21"
+run_test_simple "moveb (d16,An) to Dn" "\x10\x29\xfc\xeb"
+run_test_simple "moveb (d8,An,Xi) to Dn" "\x10\x31\x98\x70"
+run_test_simple "moveb (xxx).W to Dn" "\x10\x38\x98\x70"
+run_test_simple "moveb (xxx).L to Dn" "\x10\x39\x30\x30\x30\x70"
+run_test_simple "moveb (d16,PC) to Dn" "\x10\x3a\xfc\xeb"
+run_test_simple "moveb (d8,PC,Xi) to Dn" "\x10\x3b\xa8\x70"
+run_test_simple "moveb #imm to Dn" "\x10\x3c\xff\xff"
+
+# 3xxx [xxxx [xxxx]]
+#
+run_test_simple "movew Dn to Dn" "\x3e\x02"
+run_test_simple "movew An to Dn" "\x3e\x0a"
+run_test_simple "movew (An) to Dn" "\x3e\x12"
+run_test_simple "movew (An)+ to Dn" "\x30\x1a"
+run_test_simple "movew -(An) to Dn" "\x30\x22"
+run_test_simple "movew (d16,An) to Dn" "\x30\x2a\x3f\xff"
+run_test_simple "movew (d8,An,Xi) to Dn" "\x30\x32\x90\x80"
+run_test_simple "movew (xxx).W to Dn" "\x30\x38\x90\x80"
+run_test_simple "movew (xxx).L to Dn" "\x30\x39\xaa\xaa\xaa\xaa"
+run_test_simple "movew (d16,PC) to Dn" "\x30\x3a\x3f\xff"
+run_test_simple "movew (d8,PC,Xi) to Dn" "\x30\x3b\xa0\x80"
+run_test_simple "movew #imm to Dn" "\x30\x3c\xa5\xa5"
+run_test_simple "moveaw Dn" "\x30\x41"
+run_test_simple "moveaw #imm" "\x30\x7c\xa8\x90"
+
+# 2xxx [xxxx [xxxx]]
+#
+run_test_simple "movel Dn to Dn" "\x24\x05"
+run_test_simple "movel An to Dn" "\x24\x0d"
+run_test_simple "movel (An) to Dn" "\x24\x15"
+run_test_simple "movel (An)+ to Dn" "\x24\x1d"
+run_test_simple "movel -(An) to Dn" "\x24\x25"
+run_test_simple "movel (d16,An) to Dn" "\x24\x2d\x78\x20"
+run_test_simple "movel (d8,An,Xi) to Dn" "\x24\x35\x98\x90"
+run_test_simple "movel (xxx).W to Dn" "\x24\x38\x78\x90"
+run_test_simple "movel (xxx).L to Dn" "\x24\x39\x00\x00\x78\x90"
+run_test_simple "movel (d16,PC) to Dn" "\x24\x3a\x78\x20"
+run_test_simple "movel (d8,PC,Xi) to Dn" "\x24\x3b\xa8\x90"
+run_test_simple "movel #imm to Dn" "\x24\x3c\xa8\x90\x00\x00"
+run_test_simple "moveal Dn" "\x20\x41"
+run_test_simple "moveal #imm" "\x20\x7c\xa8\x90\x00\x00"
+
+# From random tests
+#
+run_test_simple "movel %pc@(-16,%a0:l),%a3@+ with nop" "\x26\xfb\x88\xf0\x4e\x71"
+
+# 4890 xxx
+#
+run_test_simple "movemw single register to (An)" "\x48\x90\x00\x01"
+run_test_simple "movemw d0-d1,a0-a1 to (An)" "\x48\x90\x03\x03"
+run_test_simple "moveml 6 spans to (An)" "\x48\xd0\xb6\xdb"
+run_test_simple "movemw 8 non-neighboring regs to (An)" "\x48\x90\x55\x55"
+run_test_simple "moveml other 8 non-neighboring regs to (An)" "\x48\xd0\xaa\xaa"
+run_test_simple "moveml all registers to (An)" "\x48\xd0\xff\xff"
+run_test_simple "movemw all registers to -(An)" "\x48\xa0\xff\xff"
+run_test_simple "moveml all registers to (d16,An)" "\x48\xe8\xff\xff\x30\x1d"
+run_test_simple "movemw all registers to (d8,An,Xi)" "\x48\xb7\xff\xff\x48\x0a"
+run_test_simple "moveml all registers to (xxx).W" "\x48\xf8\xff\xff\x80\x10"
+run_test_simple "movemw all registers to (xxx).L" "\x48\xb9\xff\xff\x00\x00\x7f\xf0"
+run_test_simple "movemw (An) to all registers " "\x4c\x90\xff\xff"
+run_test_simple "moveml (An)+ to all registers" "\x4c\xd8\xff\xff"
+run_test_simple "movemw (d16,An) to all registers" "\x4c\xa8\xff\xff\x30\x1d"
+run_test_simple "moveml (d8,An,Xi) to all registers" "\x4c\xf7\xff\xff\x48\x0a"
+run_test_simple "movemw (xxx).W to all registers" "\x4c\xb8\xff\xff\x80\x10"
+run_test_simple "moveml (xxx).L to all registers" "\x4c\xf9\xff\xff\x00\x00\x7f\xf0"
+
+# From random tests
+#
+run_test_expect_short "movem truncated" "\x48\x92"
+
+# 5x38 / 5x78 / 5xb8 (xxx).W
+#
+run_test_simple "addqb #8,offset:w" "\x50\x38\x00\x73"
+run_test_simple "addql #4,offset:w" "\x58\xb8\x80\x14"
+
+# 5x39 / 5x79 / 5xb9 (xxx).L
+#
+run_test_simple "addqw #5,offset:l" "\x5a\x79\x18\xfc\x00\x00"
+run_test_simple "addql #1,offset:l" "\x52\xb9\xf1\x00\x00\x01"
+
+# 5x30..5x37 / 5x70..5x77 / 5xb0..5xb7, (d16, An, Xi), Brief Extension Word
+#
+run_test_simple "addqb #8,a7(positive,d0:w)" "\x50\x37\x00\x73"
+run_test_simple "addqw #5,a2(negative,d1:l)" "\x5a\x72\x18\xfc"
+run_test_simple "addql #1,a3(negative,a3:w)" "\x52\xb3\xb0\x81"
+
+# 5x28..5x2f / 5x68..5x6f / 5xa8..5xaf, (d16, An), Displacement Word
+#
+run_test_simple "addqb #8,a7(positive)" "\x50\x2f\x00\x80"
+run_test_simple "addqw #5,a2(negative)" "\x5a\x6a\xfc\xfc"
+run_test_simple "addql #1,a3(negative)" "\x52\xab\xff\xff"
+
+# 5x20..5x27 / 5x60..5x67 / 5xa0..5xa7, -(An)
+#
+run_test_simple "addqb #8,-(a7)" "\x50\x27"
+run_test_simple "addqw #5,-(a2)" "\x5a\x62"
+run_test_simple "addql #1,-(a3)" "\x52\xa3"
+
+# 5x18..5x1f / 5x58..5x5f / 5x98..5x9f, (An)+
+#
+run_test_simple "addqb #8,(a7)+" "\x50\x1f"
+run_test_simple "addqw #5,(a2)+" "\x5a\x5a"
+run_test_simple "addql #1,(a3)+" "\x52\x9d"
+
+# 5x10..5x17 / 5x50..5x57 / 5x90..5x97, (An)
+#
+run_test_simple "addqb #8,(a7)" "\x50\x17"
+run_test_simple "addqw #5,(a2)" "\x5a\x52"
+run_test_simple "addql #1,(a3)" "\x52\x93"
+
+# 5x08..5x0f / 5x48..5x4f / 5x88..5x8f, An
+#
+# NOTE: addqb with An does not exits
+run_test_simple "addqw #6,a7" "\x5c\x4f"
+run_test_simple "addql #1,a5" "\x52\x8d"
+
+# 5x00..5x07 / 5x40..5x47 / 5x80..5x87, Dn
+#
+run_test_simple "addqb #8,d7" "\x50\x07"
+run_test_simple "addqw #5,d2" "\x5a\x42"
+run_test_simple "addql #1,d3" "\x52\x83"
+
+# 50f9 xxxx
+#
+run_test_simple "st d16:l positive" "\x51\xf9\x00\x00\x00\x74"
+run_test_simple "st d16:l negative" "\x51\xf9\xc0\xfe\xba\xbe"
+
+# 50f8 xxxx
+#
+run_test_simple "st d16:w positive" "\x51\xf8\x00\x66"
+run_test_simple "st d16:w negative" "\x51\xf8\x80\xc4"
+
+# 51f0 xxxx
+#
+run_test_simple "sf (d16:w,A4,D3) positive" "\x51\xf4\xb0\x04"
+run_test_simple "sf (d16:w,A3,A6) negative" "\x51\xf3\x60\xf2"
+
+# 5fe8 xxxx
+#
+run_test_simple "sle (d16,A0) positive" "\x5f\xe8\x00\xa0"
+run_test_simple "sle (d16,A0) negative" "\x5f\xe8\xe4\x02"
+
+# 5ee1
+#
+run_test_simple "sgt -(%a1)" "\x5e\xe1"
+
+# 56df
+#
+run_test_simple "sne (%a7)+" "\x56\xdf"
+
+# 5dd3
+#
+run_test_simple "slt (%a3)" "\x5d\xd3"
+
+# 57cx
+#
+run_test_iterative "seq Xn" "\x57" 0xc0 8 1
+
+# 50cf xxxx
+#
+run_test_simple "dbt negative displacement" "\x50\xcf\xff\xfc"
+run_test_simple "dbt positive displacement" "\x50\xcf\x01\x08"
+
+# 50c9 7ffe
+#
+# From random tests
+run_test_simple "dbt %d1,.+32768" "\x50\xc9\x7f\xfe"
+
+# 60xx
+#
+run_test_simple "bras negative displacement" "\x60\xfc"
+run_test_simple "bras positive displacement" "\x60\x08"
+
+# 60xx (xxxx)
+#
+run_test_simple "braw negative displacement" "\x60\x00\xf8\x2e"
+run_test_simple "braw positive displacement" "\x60\x00\x03\xe6"
+run_test_simple "braw zero displacement" "\x60\x00\x00\x00"
+
+# 61xx (xxxx)
+#
+run_test_simple "bsrs negative displacement" "\x61\x88"
+run_test_simple "bsrw positive displacement" "\x61\x00\x03\xe6"
+
+# 6xxx
+#
+run_test_simple "bhis" "\x62\x0a"
+run_test_simple "blss" "\x63\x0a"
+run_test_simple "bccs" "\x64\x0a"
+run_test_simple "bcss" "\x65\x0a"
+run_test_simple "bnes" "\x66\x0a"
+run_test_simple "beqs" "\x67\x0a"
+run_test_simple "bvcs" "\x68\x0a"
+run_test_simple "bvss" "\x69\x0a"
+run_test_simple "bpls" "\x6a\x0a"
+run_test_simple "bmis" "\x6b\x0a"
+run_test_simple "bges" "\x6c\x0a"
+run_test_simple "blts" "\x6d\x0a"
+run_test_simple "bgts" "\x6e\x0a"
+run_test_simple "bles" "\x6f\x0a"
+
+# 4afc
+#
+# reset
+#
+run_test_simple "illegal" "\x4a\xfc"
+
+# 4e70
+#
+# reset
+run_test_simple "reset" "\x4e\x70"
+
+# 4e71
+#
+# nop
+run_test_simple "nop" "\x4e\x71"
+
+# 4e72 xxxx
+#
+run_test_simple "stop #8:w" "\x4e\x72\x00\x08"
+run_test_simple "stop #ffff:w" "\x4e\x72\xff\xff"
+
+# 4e73
+#
+# rte
+run_test_simple "rte" "\x4e\x73"
+
+# 4e75
+#
+# rts
+run_test_simple "rts" "\x4e\x75"
+
+# 4e76
+#
+# trapv
+run_test_simple "trapv" "\x4e\x76"
+
+# 4e77
+#
+# rtr
+run_test_simple "rtr" "\x4e\x77"
+
+# 4e90..4e97
+#
+run_test_iterative "jsr M2 all An" "\x4e" 0x90 8 1 ""
+
+# (4ea8..4eaf) xxxx
+#
+run_test_simple "jsr M5 zero value" "\x4e\xa8\x00\x00"
+run_test_iterative "jsr M5 all An, positive" "\x4e" 0xa8 8 1 "\x00\x0a"
+run_test_simple "jsr M5 A0 negative" "\x4e\xa8\x80\x0f"
+
+# (4eb0..4eb7) xxxx
+#
+run_test_iterative "jsr M6 arbitrary An, positive" "\x4e" 0xb0 8 1 "\x00\x0f"
+run_test_simple "jsr M6 A0 negative" "\x4e\xb0\x00\xf0"
+run_test_simple "jsr M6 A0 zero" "\x4e\xb0\x00\x00"
+run_test_simple "jsr M6 address register" "\x4e\xb0\x80\x0a"
+run_test_simple "jsr M6 long displacement positive" "\x4e\xb0\x08\x0c"
+run_test_simple "jsr M6 long displacement negative" "\x4e\xb0\x08\xb0"
+run_test_iterative "jsr M6 arbitrary Xn2" "\x4e\xb0" 0x00 8 0x10 "\x0f"
+
+# 4eb8 xxxx Word displacement
+#
+run_test_simple "jsr M7 Xn0 zero" "\x4e\xb8\x00\x00"
+run_test_simple "jsr M7 Xn0 positive" "\x4e\xb8\x00\x1f"
+run_test_simple "jsr M7 Xn0 negative" "\x4e\xb8\x8a\x0c"
+
+# 4eb9 xxxx Long displacement
+#
+run_test_simple "jsr M7 X1 zero" "\x4e\xb9\x00\x00\x00\x00"
+run_test_simple "jsr M7 X1 positive" "\x4e\xb9\x10\xbb\x43\x1f"
+run_test_simple "jsr M7 X1 negative" "\x4e\xb9\x80\xcc\xd9\x8a"
+
+# 4eba xxxx
+#
+run_test_simple "jsr M7 X2 zero value" "\x4e\xba\x00\x00"
+run_test_simple "jsr M7 X2 positive value" "\x4e\xba\x00\x1f"
+run_test_simple "jsr M7 X2 negative value" "\x4e\xba\x8a\x0c"
+
+# 4ebb xxxx
+#
+run_test_simple "jsr M7 X3 negative" "\x4e\xbb\x00\xf0"
+run_test_simple "jsr M7 X3 zero displacement" "\x4e\xbb\x00\x00"
+run_test_simple "jsr M7 X3 An2=A0" "\x4e\xbb\x80\x0a"
+run_test_simple "jsr M7 X3 long positive displacement" "\x4e\xbb\x08\x0c"
+run_test_simple "jsr M7 X3 long negative displacement" "\x4e\xbb\x08\xb0"
+run_test_iterative "jsr M7 X3 arbitrary Dn2" "\x4e\xbb" 0x00 8 0x10 "\x0f"
diff --git a/tests/test.ld b/tests/test.ld
new file mode 100644
index 0000000..f939414
--- /dev/null
+++ b/tests/test.ld
@@ -0,0 +1,19 @@
+/* SPDX-License-Identifier: Unlicense
+ */
+
+MEMORY {
+    ROM(rx) : ORIGIN = 0x00000000, LENGTH = 4M
+}
+
+SECTIONS {
+    . = ORIGIN(ROM);
+    .text : {
+        KEEP(*(.text))
+        . = ALIGN(2);
+        *(.text*)
+        . = ALIGN(2);
+        KEEP(*(.rodata))
+        *(.rodata*)
+        . = ALIGN(2);
+    } >ROM
+}
diff --git a/tests/test_labels_referencing.bash b/tests/test_labels_referencing.bash
new file mode 100644
index 0000000..8b5df40
--- /dev/null
+++ b/tests/test_labels_referencing.bash
@@ -0,0 +1,110 @@
+#!/usr/bin/env bash
+#
+# SPDX-License-Identifier: Unlicense
+#
+# Tests against m68k-none-elf-as.
+
+AS=m68k-none-elf-as
+OBJCOPY=m68k-none-elf-objcopy
+LD="m68k-none-elf-ld -Ttest.ld"
+DISASM="../cmake-build/m68k-disasm -ffollow-jumps"
+TEST_DIR=/tmp/m68k-disasm-tests-labels-referencing
+
+set -e
+CRED="\033[31m"
+CGREEN="\033[32m"
+CRST="\033[39m"
+
+rm -rf ${TEST_DIR}
+mkdir -p ${TEST_DIR}
+
+run_test_r() {
+  local test_name=$1
+  local test_name_sanitized=${test_name//[^a-zA-Z0-9_\-]/-}
+  local data=$2
+  local args=$3
+  local file_orig_bin=${TEST_DIR}/${test_name_sanitized}.orig.bin
+  local file_asm=${TEST_DIR}/${test_name_sanitized}.S
+  local file_as_o=${TEST_DIR}/${test_name_sanitized}.as.o
+  local file_as_elf=${TEST_DIR}/${test_name_sanitized}.as.elf
+  local file_as_bin=${TEST_DIR}/${test_name_sanitized}.as.bin
+  echo -ne "Test \"${test_name}\"... "
+  echo -ne "${data}" >${file_orig_bin}
+  ${DISASM} $args -o ${file_asm} ${file_orig_bin}
+  ${AS} -m68000 -o ${file_as_o} ${file_asm}
+  ${LD} -o ${file_as_elf} ${file_as_o}
+  ${OBJCOPY} ${file_as_elf} -O binary ${file_as_bin}
+  if ! cmp ${file_orig_bin} ${file_as_bin}; then
+    cat ${file_asm}
+    echo -e "${CRED}FAIL${CRST}: output and input binaries do not match"
+    hexdump -Cv ${file_orig_bin} >${file_orig_bin}.txt
+    hexdump -Cv ${file_as_bin} >${file_as_bin}.txt
+    echo ${file_orig_bin}
+    echo ${file_as_bin}
+    exit
+  elif grep ".short" ${file_asm} >/dev/null 2>&1; then
+    echo -e "${CRED}FAIL${CRST}: .short emitted"
+    cat ${file_asm}
+    exit
+  fi
+  local run_check=$4
+  $run_check
+  #echo && cat ${file_asm}
+  echo -e "${CGREEN}OK${CRST}"
+}
+
+run_check_rdisp() {
+  if grep -e "\s\.\([+-]\+\|\s\+\|$\)" ${file_asm} >/dev/null 2>&1; then
+    echo -e "${CRED}FAIL${CRST}: raw displacement emitted"
+    cat ${file_asm}
+    exit
+  fi
+}
+
+run_check_r() {
+  if grep -e "[^0-9a-zA-Z_+][0-9]\+" ${file_asm} >/dev/null 2>&1; then
+    echo -e "${CRED}FAIL${CRST}: raw number or displacement emitted"
+    cat ${file_asm}
+    exit
+  fi
+}
+
+run_check_dummy() { :; }
+
+run_test_rdisp() {
+  run_test_r "$1" "$2" "-flabels -frel-labels" run_check_rdisp
+}
+
+run_test_rword() {
+  run_test_r "$1" "$2" "-flabels -fabs-labels" run_check_r
+}
+
+run_test_rpcrel() {
+  run_test_r "$1" "$2" "-flabels -frel-labels" run_check_r
+}
+
+run_test_rlocal() {
+  run_test_r "$1" "$2" "-flabels -frel-labels -fabs-labels -fshort-ref-local-labels" run_check_dummy
+}
+
+run_test_rdisp "bras ." "\x60\xfe"
+run_test_rdisp "bras .-2" "\x4e\x71\x60\xfc"
+run_test_rdisp "bras .-1" "\x4e\x71\x60\xfd"
+run_test_rdisp "braw .+2" "\x4e\x71\x60\x00\x00\x00"
+run_test_rword "moveml 0x0:w,%d0" "\x4c\xf8\x00\x01\x00\x00"
+run_test_rword "moveml 0x6:w,%a0" "\x4c\xf8\x01\x00\x00\x06\x4e\x71\x4e\x71"
+run_test_rword "movemw 0x0:l,%a0" "\x4e\x71\x4e\x71\x4c\xb9\x01\x00\x00\x00\x00\x02"
+run_test_rpcrel "movemw (0,PC),%a0" "\x4e\x71\x4e\x71\x4c\xba\x01\x00\x00\x00"
+run_test_rpcrel "lea (0,PC)" "\x47\xfa\x00\x00"
+run_test_rpcrel "jmp (0,PC)" "\x4e\xfa\x00\x00"
+run_test_rword "peal 0x0:w" "\x48\x78\x00\x00"
+run_test_rword "peal 0x0:l" "\x48\x79\x00\x00\x00\x00"
+run_test_rpcrel "peal (0,PC)" "\x48\x7a\x00\x00"
+run_test_rword "nbcd 0x0:w" "\x48\x38\x00\x00"
+run_test_rword "nbcd 0x6:l with nop" "\x48\x39\x00\x00\x00\x06\x4e\x71"
+run_test_rword "cmpl 0x4:w, D2 with nop" "\xb4\xb8\x00\x04\x4e\x71"
+run_test_rword "cmpw 0x0:l, D2" "\xb4\x79\x00\x00\x00\x00"
+run_test_rpcrel "cmpl (0,PC), D2" "\xb4\xba\x00\x00"
+run_test_rpcrel "cmpl (-2,PC), D2" "\xb4\xba\xff\xfe"
+run_test_rlocal "bras 1f; nop; 1: bras 1b" "\x60\x02\x4e\x71\x60\xfe"
+run_test_rlocal "2: bras 1f; nop; 1: bras 2b" "\x60\x02\x4e\x71\x60\xfa"
diff --git a/tests/test_random.bash b/tests/test_random.bash
new file mode 100644
index 0000000..3c7a0d2
--- /dev/null
+++ b/tests/test_random.bash
@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+#
+# SPDX-License-Identifier: Unlicense
+#
+# Tests against m68k-none-elf-as.
+
+AS=m68k-none-elf-as
+OBJCOPY=m68k-none-elf-objcopy
+LD="m68k-none-elf-ld -Ttest.ld"
+DISASM="../cmake-build/m68k-disasm -frdc -fxrefs-to -fxrefs-from -flabels -frel-labels -fabs-labels -fshort-ref-local-labels -fimm-hex -ffollow-jumps"
+TEST_DIR=/tmp/m68k-disasm-random-tests
+
+set -e
+CRED="\033[31m"
+CGREEN="\033[32m"
+CRST="\033[39m"
+
+rm -rf ${TEST_DIR}
+mkdir -p ${TEST_DIR}
+
+run_test_random() {
+  local pass_number=$1
+  local blocks_count=$2
+  local test_name_sanitized=${pass_number//[^a-zA-Z0-9_\-]/-}
+  local file_orig_bin=${TEST_DIR}/${test_name_sanitized}.orig.bin
+  local file_asm=${TEST_DIR}/${test_name_sanitized}.S
+  local file_as_o=${TEST_DIR}/${test_name_sanitized}.as.o
+  local file_as_elf=${TEST_DIR}/${test_name_sanitized}.as.elf
+  local file_as_bin=${TEST_DIR}/${test_name_sanitized}.as.bin
+  echo -ne "Test random, pass ${pass_number}... "
+  dd if=/dev/urandom of=${file_orig_bin} bs=1024 count=${blocks_count} >/dev/null 2>&1
+  ${DISASM} -o ${file_asm} ${file_orig_bin}
+  ${AS} -o ${file_as_o} ${file_asm}
+  ${LD} -o ${file_as_elf} ${file_as_o}
+  ${OBJCOPY} ${file_as_elf} -O binary ${file_as_bin}
+  if ! cmp ${file_orig_bin} ${file_as_bin}; then
+    echo -e "${CRED}FAIL${CRST}: output and input binaries do not match"
+    hexdump -Cv ${file_orig_bin} >${file_orig_bin}.txt
+    hexdump -Cv ${file_as_bin} >${file_as_bin}.txt
+    echo ${file_orig_bin}
+    echo ${file_as_bin}
+    exit
+  else
+    echo -e "${CGREEN}OK${CRST}"
+    rm ${file_orig_bin} ${file_asm} ${file_as_o} ${file_as_elf} ${file_as_bin}
+  fi
+}
+
+# Tiny tests are mostly for ensuring that bounds checking is working properly,
+# because it is more likely to encounter something that looks like a truncated
+# instruction.
+#
+# If there is an obvious bug, then it will most likely be detected
+# here and it is easier to dissect tiny test blob than huge test trying to debug
+# single test case.
+for i in `seq 1 1000`; do
+  run_test_random tiny$i 1
+done
+
+# Huge tests are for the broad coverage. They catch a lot!
+for i in `seq 1 10`; do
+  run_test_random huge$i 1024
+done
diff --git a/tests/test_walk_and_follow_jumps.bash b/tests/test_walk_and_follow_jumps.bash
new file mode 100644
index 0000000..0f11e09
--- /dev/null
+++ b/tests/test_walk_and_follow_jumps.bash
@@ -0,0 +1,200 @@
+#!/usr/bin/env bash
+#
+# SPDX-License-Identifier: Unlicense
+#
+# Tests against reference text for -ffollow-jumps and -fwalk features
+
+TEST_DIR=/tmp/m68k-disasm-follow-jumps-walk-tests
+DISASM="../cmake-build/m68k-disasm -flabels -frel-labels -fabs-labels"
+
+set -e
+CRED="\033[31m"
+CGREEN="\033[32m"
+CRST="\033[39m"
+
+rm -rf ${TEST_DIR}
+mkdir -p ${TEST_DIR}
+
+OUTPUT_ASM="$TEST_DIR"/output.S
+TRACE="$TEST_DIR"/trace.txt
+REFERENCE="$TEST_DIR"/reference.S
+REFERENCE_W="$TEST_DIR"/reference_w.S
+REFERENCE_F="$TEST_DIR"/reference_f.S
+REFERENCE_WF="$TEST_DIR"/reference_wf.S
+
+run_test_inner() {
+  local test_name=$1
+  local disasm_args="$2"
+  local input="$3"
+  local reference="$4"
+  echo -ne "Test \"${test_name}\" ($disasm_args)... "
+  echo -ne "$input" | ${DISASM} --indent='  ' $disasm_args -t "$TRACE" -o "$OUTPUT_ASM" -
+  if ! diff --ignore-trailing-space "$reference" "$OUTPUT_ASM" >/dev/null 2>&1; then
+    echo -e "${CRED}FAIL${CRST}: output and reference text files do not match"
+    diff --color=always --unified --ignore-trailing-space "$reference" "$OUTPUT_ASM" || true
+  else
+    echo -e "${CGREEN}OK${CRST}"
+  fi
+}
+
+run_test() {
+  local test_name=$1
+  local input="$2"
+  local reference="$3"
+  local reference_w="$4"
+  local reference_f="$5"
+  local reference_wf="$6"
+  run_test_inner "$test_name" "" "$input" "$reference"
+  run_test_inner "$test_name" "-fwalk" "$input" "$reference_w"
+  run_test_inner "$test_name" "-ffollow-jumps" "$input" "$reference_f"
+  run_test_inner "$test_name" "-fwalk -ffollow-jumps" "$input" "$reference_wf"
+}
+
+
+echo -e "0" >"$TRACE"
+cat >"$REFERENCE" << EOF
+  nop
+  .short 0x4e71
+EOF
+cat >"$REFERENCE_W" << EOF
+  nop
+  nop
+EOF
+# $REFERENCE_F is same as $REFERENCE
+# $REFERENCE_WF is same as $REFERENCE_W
+run_test "linear nops, trace @0" "\x4e\x71\x4e\x71" \
+  "$REFERENCE" "$REFERENCE_W" "$REFERENCE" "$REFERENCE_W"
+
+
+cat >"$REFERENCE" << EOF
+  nop
+  .short 0x6002
+  .short 0x4e71
+  .short 0x4e71
+EOF
+cat >"$REFERENCE_W" << EOF
+  nop
+  bras L00000006
+  .short 0x4e71
+L00000006:
+  .short 0x4e71
+EOF
+# $REFERENCE_F is same as $REFERENCE
+cat >"$REFERENCE_WF" << EOF
+  nop
+  bras L00000006
+  .short 0x4e71
+L00000006:
+  nop
+EOF
+run_test "nop and unconditional branch, trace @0" "\x4e\x71\x60\x02\x4e\x71\x4e\x71" \
+  "$REFERENCE" "$REFERENCE_W" "$REFERENCE" "$REFERENCE_WF"
+
+
+cat >"$REFERENCE" << EOF
+  nop
+  .short 0x6602
+  .short 0x4e71
+  .short 0x4e71
+EOF
+cat >"$REFERENCE_W" << EOF
+  nop
+  bnes L00000006
+  nop
+L00000006:
+  nop
+EOF
+# $REFERENCE_F is same as $REFERENCE
+# $REFERENCE_WF is same as $REFERENCE_W
+run_test "nop and conditional branch, trace @0" "\x4e\x71\x66\x02\x4e\x71\x4e\x71" \
+  "$REFERENCE" "$REFERENCE_W" "$REFERENCE" "$REFERENCE_W"
+
+
+cat >"$REFERENCE" << EOF
+  bnes L00000004
+  .short 0x4e71
+L00000004:
+  .short 0x4e71
+EOF
+cat >"$REFERENCE_W" << EOF
+  bnes L00000004
+  nop
+L00000004:
+  nop
+EOF
+cat >"$REFERENCE_F" << EOF
+  bnes L00000004
+  .short 0x4e71
+L00000004:
+  nop
+EOF
+# $REFERENCE_WF is same as $REFERENCE_W
+run_test "conditional branch, trace @0" "\x66\x02\x4e\x71\x4e\x71" \
+  "$REFERENCE" "$REFERENCE_W" "$REFERENCE_F" "$REFERENCE_W"
+
+
+cat >"$REFERENCE" << EOF
+  bras L00000004
+  .short 0x4e71
+L00000004:
+  .short 0x4e71
+EOF
+# $REFERENCE_W is same as $REFERENCE
+cat >"$REFERENCE_F" << EOF
+  bras L00000004
+  .short 0x4e71
+L00000004:
+  nop
+EOF
+# $REFERENCE_WF is same as $REFERENCE_F
+run_test "unconditional branch, trace @0" "\x60\x02\x4e\x71\x4e\x71" \
+  "$REFERENCE" "$REFERENCE" "$REFERENCE_F" "$REFERENCE_F"
+
+
+echo -e "0\n2" >"$TRACE"
+cat >"$REFERENCE" << EOF
+L00000000:
+  nop
+  bnes L00000000
+  .short 0x4e71
+EOF
+cat >"$REFERENCE_W" << EOF
+L00000000:
+  nop
+  bnes L00000000
+  nop
+EOF
+# $REFERENCE_F is same as $REFERENCE
+# $REFERENCE_WF is same as $REFERENCE_W
+run_test "nop and conditional branch backwards, trace @0, @2" "\x4e\x71\x66\xfc\x4e\x71" \
+  "$REFERENCE" "$REFERENCE_W" "$REFERENCE" "$REFERENCE_W"
+
+
+echo -e "2" >"$TRACE"
+cat >"$REFERENCE" << EOF
+L00000000:
+  .short 0x4e71
+  bnes L00000000
+  .short 0x4e71
+EOF
+cat >"$REFERENCE_W" << EOF
+L00000000:
+  .short 0x4e71
+  bnes L00000000
+  nop
+EOF
+cat >"$REFERENCE_F" << EOF
+L00000000:
+  nop
+  bnes L00000000
+  .short 0x4e71
+EOF
+cat >"$REFERENCE_WF" << EOF
+L00000000:
+  nop
+  bnes L00000000
+  nop
+EOF
+run_test "nop and conditional branch backwards, trace @2" "\x4e\x71\x66\xfc\x4e\x71" \
+  "$REFERENCE" "$REFERENCE_W" "$REFERENCE_F" "$REFERENCE_WF"
+