# The listing, pinned on one binary per architecture the tree carries.
#
# `pd` rewrites one formatted string by successive substitutions, so these pin the spellings the
# rewriting is meant to keep. Two are ours and not radare2's: `nop word ptr cs:[rax + rax*0x1]` (the
# rule that drops `ptr` matches ` ptr [`, and this operand has a segment between), and a 64-bit
# immediate written signed, as Sleigh writes it.

# x86-64: the `ptr` and displacement spellings, and `jz` printed as `jne`'s comparison.
NAME=x86 listing
FILE=tests/coverage/pinned/hashes_gcc_x64_O2
CMDS=s 0x401330; pd 24
EXPECT=<<EOF
            0x00401330      f30f1efa       endbr64
            0x00401334      4885f6         test rsi, rsi
            0x00401337      7427           je 0x401360
            0x00401339      4801fe         add rsi, rdi
            0x0040133c      b8c59d1c81     mov eax, 0x811c9dc5
            0x00401341      0f1f800000..   nop dword [rax]
            0x00401348      0fb617         movzx edx, byte [rdi]
            0x0040134b      4883c701       add rdi, 0x1
            0x0040134f      31d0           xor eax, edx
            0x00401351      69c093010001   imul eax, eax, 0x1000193
            0x00401357      4839fe         cmp rsi, rdi
            0x0040135a      75ec           jne 0x401348
            0x0040135c      c3             ret
            0x0040135d      0f1f00         nop dword [rax]
            0x00401360      b8c59d1c81     mov eax, 0x811c9dc5
            0x00401365      c3             ret
            0x00401366      662e0f1f84..   nop word cs:[rax + rax]
            0x00401370      f30f1efa       endbr64
            0x00401374      48b8252322..   mov rax, -0x340d631b7bdddcdb
            0x0040137e      4885f6         test rsi, rsi
            0x00401381      7420           je 0x4013a3
            0x00401383      48b9b30100..   mov rcx, 0x100000001b3
            0x0040138d      4801fe         add rsi, rdi
            0x00401390      0fb617         movzx edx, byte [rdi]
EOF
RUN

# A call through a relocated slot, a jump through an unnamed one, and a compare against a data byte.
NAME=what a line reads
FILE=tests/coverage/pinned/hashes_gcc_x64_O2
CMDS=s 0x401000; pd 24
EXPECT=<<EOF
            0x00401000      f30f1efa       endbr64
            0x00401004      4883ec08       sub rsp, 0x8
            0x00401008      488b05d12f..   mov rax, qword [reloc.__gmon_start__]
            0x0040100f      4885c0         test rax, rax
            0x00401012      7402           je 0x401016
            0x00401014      ffd0           call rax
            0x00401016      4883c408       add rsp, 0x8
            0x0040101a      c3             ret
            0x0040101b      0000           add byte [rax], al
            0x0040101d      0000           add byte [rax], al
            0x0040101f      00ff           add bh, bh
            0x00401021      35ca2f0000     xor eax, 0x2fca
            0x00401026      ff25cc2f0000   jmp qword [0x403ff8]
            0x0040102c      0f1f4000       nop dword [rax]
            0x00401030      f30f1efa       endbr64
            0x00401034      6800000000     push 0x0
            0x00401039      e9e2ffffff     jmp 0x401020
            0x0040103e      6690           nop
            0x00401040      f30f1efa       endbr64
            0x00401044      ff25b62f0000   jmp qword [reloc.__printf_chk]
            0x0040104a      660f1f440000   nop word [rax + rax]
            0x00401050      f30f1efa       endbr64
            0x00401054      4883ec08       sub rsp, 0x8
            0x00401058      be3d000000     mov esi, 0x3d
EOF
RUN

# No range that is one value the instruction fixes, each note ending in its rung.
NAME=what the engine proved
FILE=tests/coverage/pinned/hashes_gcc_x64_O2
CMDS=s 0x401330; pdf; s 0x401530; pdf
EXPECT=<<EOF
            0x00401330      f30f1efa       endbr64
            0x00401334      4885f6         test rsi, rsi
            0x00401337      7427           je 0x401360
            0x00401339      4801fe         add rsi, rdi
            0x0040133c      b8c59d1c81     mov eax, 0x811c9dc5
            0x00401341      0f1f800000..   nop dword [rax]
            0x00401348      0fb617         movzx edx, byte [rdi] ; loop: latches 0x401348, exits 0x40135c (certified) ; induction rdi = rdi@entry, +0x1 per trip (certified) ; trips rsi@entry (solved)
            0x0040134b      4883c701       add rdi, 0x1
            0x0040134f      31d0           xor eax, edx
            0x00401351      69c093010001   imul eax, eax, 0x1000193
            0x00401357      4839fe         cmp rsi, rdi
            0x0040135a      75ec           jne 0x401348
            0x0040135c      c3             ret ; returns rax (certified)
            0x00401360      b8c59d1c81     mov eax, 0x811c9dc5
            0x00401365      c3             ret ; returns rax (certified)
            0x00401530      f30f1efa       endbr64
            0x00401534      4885f6         test rsi, rsi
            0x00401537      7440           je 0x401579
            0x00401539      4801fe         add rsi, rdi
            0x0040153c      b8ffffffff     mov eax, 0xffffffff
            0x00401541      0f1f800000..   nop dword [rax]
            0x00401548      0fb617         movzx edx, byte [rdi] ; loop: latches 0x40156d, exits 0x401576 (certified) ; induction rdi = rdi@entry, +0x1 per trip (certified) ; trips rsi@entry (solved)
            0x0040154b      31d0           xor eax, edx
            0x0040154d      ba08000000     mov edx, 0x8
            0x00401552      660f1f440000   nop word [rax + rax]
            0x00401558      89c1           mov ecx, eax ; loop: latches 0x401558, exits 0x40156d (certified)
            0x0040155a      83e001         and eax, 0x1 ; defines rax in [0x0, 0x1] (decoded)
            0x0040155d      f7d8           neg eax
            0x0040155f      d1e9           shr ecx, 0x1 ; defines rcx in [0x0, 0x7fffffff] (decoded)
            0x00401561      252083b8ed     and eax, 0xedb88320 ; defines rax in [0x0, 0xedb88320] (decoded)
            0x00401566      31c8           xor eax, ecx
            0x00401568      83ea01         sub edx, 0x1
            0x0040156b      75eb           jne 0x401558
            0x0040156d      4883c701       add rdi, 0x1
            0x00401571      4839f7         cmp rdi, rsi
            0x00401574      75d2           jne 0x401548
            0x00401576      f7d0           not eax
            0x00401578      c3             ret ; returns rax (certified)
            0x00401579      31c0           xor eax, eax
            0x0040157b      c3             ret ; returns rax (certified)
EOF
RUN

# Each arm of the tail switch labelled with the cases the dispatch sends there.
NAME=siphash24 cases
FILE=tests/coverage/pinned/hashes_gcc_x64_O2
CMDS=s sym.siphash24; pdf
EXPECT=<<EOF
            0x004018b0      f30f1efa       endbr64
            0x004018b4      48b8756573..   mov rax, 0x736f6d6570736575
            0x004018be      4989f0         mov r8, rsi
            0x004018c1      48be617265..   mov rsi, 0x6c7967656e657261
            0x004018cb      49bb6d6f64..   mov r11, 0x646f72616e646f6d
            0x004018d5      4d89c2         mov r10, r8
            0x004018d8      4831d0         xor rax, rdx
            0x004018db      4831f2         xor rdx, rsi
            0x004018de      4931cb         xor r11, rcx
            0x004018e1      48be736574..   mov rsi, 0x7465646279746573
            0x004018eb      4983e2f8       and r10, -0x8 ; defines r10 in [0x0, 0xfffffffffffffff8] (decoded)
            0x004018ef      4831f1         xor rcx, rsi
            0x004018f2      4901fa         add r10, rdi
            0x004018f5      4c89c6         mov rsi, r8
            0x004018f8      48c1e638       shl rsi, 0x38
            0x004018fc      4c39d7         cmp rdi, r10
            0x004018ff      7479           je 0x40197a
            0x00401901      0f1f800000..   nop dword [rax]
            0x00401908      4c8b0f         mov r9, qword [rdi] ; loop: latches 0x401908, exits 0x40197a (certified) ; induction rdi = rdi@entry, +0x8 per trip (certified)
            0x0040190b      4c01d8         add rax, r11
            0x0040190e      49c1c30d       rol r11, 0xd
            0x00401912      4883c708       add rdi, 0x8
            0x00401916      4931c3         xor r11, rax
            0x00401919      48c1c020       rol rax, 0x20
            0x0040191d      4c31c9         xor rcx, r9
            0x00401920      4801ca         add rdx, rcx
            0x00401923      48c1c110       rol rcx, 0x10
            0x00401927      4831d1         xor rcx, rdx
            0x0040192a      4c01da         add rdx, r11
            0x0040192d      49c1c311       rol r11, 0x11
            0x00401931      4801c8         add rax, rcx
            0x00401934      48c1c115       rol rcx, 0x15
            0x00401938      4931d3         xor r11, rdx
            0x0040193b      4831c1         xor rcx, rax
            0x0040193e      48c1c220       rol rdx, 0x20
            0x00401942      4c01d8         add rax, r11
            0x00401945      4801ca         add rdx, rcx
            0x00401948      49c1c30d       rol r11, 0xd
            0x0040194c      48c1c110       rol rcx, 0x10
            0x00401950      4931c3         xor r11, rax
            0x00401953      48c1c020       rol rax, 0x20
            0x00401957      4831d1         xor rcx, rdx
            0x0040195a      4c01da         add rdx, r11
            0x0040195d      49c1c311       rol r11, 0x11
            0x00401961      4801c8         add rax, rcx
            0x00401964      48c1c115       rol rcx, 0x15
            0x00401968      4931d3         xor r11, rdx
            0x0040196b      4831c1         xor rcx, rax
            0x0040196e      48c1c220       rol rdx, 0x20
            0x00401972      4c31c8         xor rax, r9
            0x00401975      4939fa         cmp r10, rdi
            0x00401978      758e           jne 0x401908
            0x0040197a      4183e007       and r8d, 0x7 ; defines r8 in [0x0, 0x7] (decoded)
            0x0040197e      3e42ff24c5..   jmp qword ds:[0x402020 + r8*0x8] ; switch table (8 cases) at 0x402020 (solved)
            ;-- case 7:                                                ; from 0x0040197e
            0x00401990      410fb67a06     movzx edi, byte [r10 + 0x6]
            0x00401995      48c1e730       shl rdi, 0x30 ; defines rdi in [0x0, 0xff000000000000] (solved)
            0x00401999      4809fe         or rsi, rdi
            ;-- case 6:                                                ; from 0x0040197e
            0x0040199c      410fb67a05     movzx edi, byte [r10 + 0x5]
            0x004019a1      48c1e728       shl rdi, 0x28 ; defines rdi in [0x0, 0xff0000000000] (solved)
            0x004019a5      4809fe         or rsi, rdi
            ;-- case 5:                                                ; from 0x0040197e
            0x004019a8      410fb67a04     movzx edi, byte [r10 + 0x4]
            0x004019ad      48c1e720       shl rdi, 0x20 ; defines rdi in [0x0, 0xff00000000] (solved)
            0x004019b1      4809fe         or rsi, rdi
            ;-- case 4:                                                ; from 0x0040197e
            0x004019b4      410fb67a03     movzx edi, byte [r10 + 0x3]
            0x004019b9      48c1e718       shl rdi, 0x18 ; defines rdi in [0x0, 0xff000000] (solved)
            0x004019bd      4809fe         or rsi, rdi
            ;-- case 3:                                                ; from 0x0040197e
            0x004019c0      410fb67a02     movzx edi, byte [r10 + 0x2]
            0x004019c5      48c1e710       shl rdi, 0x10 ; defines rdi in [0x0, 0xff0000] (solved)
            0x004019c9      4809fe         or rsi, rdi
            ;-- case 2:                                                ; from 0x0040197e
            0x004019cc      410fb67a01     movzx edi, byte [r10 + 0x1]
            0x004019d1      48c1e708       shl rdi, 0x8 ; defines rdi in [0x0, 0xff00] (solved)
            0x004019d5      4809fe         or rsi, rdi
            ;-- case 1:                                                ; from 0x0040197e
            0x004019d8      410fb63a       movzx edi, byte [r10]
            0x004019dc      4809fe         or rsi, rdi
            ;-- case 0:                                                ; from 0x0040197e
            0x004019df      4831f1         xor rcx, rsi
            0x004019e2      4a8d3c18       lea rdi, [rax + r11]
            0x004019e6      49c1c30d       rol r11, 0xd
            0x004019ea      4801ca         add rdx, rcx
            0x004019ed      4889f8         mov rax, rdi
            0x004019f0      48c1c110       rol rcx, 0x10
            0x004019f4      4931fb         xor r11, rdi
            0x004019f7      4831d1         xor rcx, rdx
            0x004019fa      48c1c020       rol rax, 0x20
            0x004019fe      4c01da         add rdx, r11
            0x00401a01      488d3c08       lea rdi, [rax + rcx]
            0x00401a05      4c89d8         mov rax, r11
            0x00401a08      48c1c115       rol rcx, 0x15
            0x00401a0c      48c1c011       rol rax, 0x11
            0x00401a10      4831f9         xor rcx, rdi
            0x00401a13      4831d0         xor rax, rdx
            0x00401a16      48c1c220       rol rdx, 0x20
            0x00401a1a      4801c7         add rdi, rax
            0x00401a1d      4801ca         add rdx, rcx
            0x00401a20      48c1c00d       rol rax, 0xd
            0x00401a24      48c1c110       rol rcx, 0x10
            0x00401a28      4831f8         xor rax, rdi
            0x00401a2b      48c1c720       rol rdi, 0x20
            0x00401a2f      4831d1         xor rcx, rdx
            0x00401a32      4801c2         add rdx, rax
            0x00401a35      48c1c011       rol rax, 0x11
            0x00401a39      4801cf         add rdi, rcx
            0x00401a3c      4831d0         xor rax, rdx
            0x00401a3f      48c1c115       rol rcx, 0x15
            0x00401a43      4831fe         xor rsi, rdi
            0x00401a46      48c1c220       rol rdx, 0x20
            0x00401a4a      4831f9         xor rcx, rdi
            0x00401a4d      4801c6         add rsi, rax
            0x00401a50      80f2ff         xor dl, 0xff
            0x00401a53      48c1c00d       rol rax, 0xd
            0x00401a57      4831f0         xor rax, rsi
            0x00401a5a      48c1c620       rol rsi, 0x20
            0x00401a5e      4801ca         add rdx, rcx
            0x00401a61      48c1c110       rol rcx, 0x10
            0x00401a65      4831d1         xor rcx, rdx
            0x00401a68      4801c2         add rdx, rax
            0x00401a6b      48c1c011       rol rax, 0x11
            0x00401a6f      4801ce         add rsi, rcx
            0x00401a72      48c1c115       rol rcx, 0x15
            0x00401a76      4831d0         xor rax, rdx
            0x00401a79      4831f1         xor rcx, rsi
            0x00401a7c      48c1c220       rol rdx, 0x20
            0x00401a80      4801c6         add rsi, rax
            0x00401a83      4801ca         add rdx, rcx
            0x00401a86      48c1c00d       rol rax, 0xd
            0x00401a8a      48c1c110       rol rcx, 0x10
            0x00401a8e      4831f0         xor rax, rsi
            0x00401a91      48c1c620       rol rsi, 0x20
            0x00401a95      4831d1         xor rcx, rdx
            0x00401a98      4801c2         add rdx, rax
            0x00401a9b      48c1c011       rol rax, 0x11
            0x00401a9f      4801ce         add rsi, rcx
            0x00401aa2      48c1c115       rol rcx, 0x15
            0x00401aa6      4831d0         xor rax, rdx
            0x00401aa9      4831f1         xor rcx, rsi
            0x00401aac      48c1c220       rol rdx, 0x20
            0x00401ab0      4801c6         add rsi, rax
            0x00401ab3      4801ca         add rdx, rcx
            0x00401ab6      48c1c00d       rol rax, 0xd
            0x00401aba      48c1c110       rol rcx, 0x10
            0x00401abe      4831f0         xor rax, rsi
            0x00401ac1      48c1c620       rol rsi, 0x20
            0x00401ac5      4831d1         xor rcx, rdx
            0x00401ac8      4801ce         add rsi, rcx
            0x00401acb      4801c2         add rdx, rax
            0x00401ace      48c1c011       rol rax, 0x11
            0x00401ad2      4831d0         xor rax, rdx
            0x00401ad5      48c1c115       rol rcx, 0x15
            0x00401ad9      4831f1         xor rcx, rsi
            0x00401adc      4801c6         add rsi, rax
            0x00401adf      48c1c00d       rol rax, 0xd
            0x00401ae3      4831c6         xor rsi, rax
            0x00401ae6      48c1c220       rol rdx, 0x20
            0x00401aea      4889c8         mov rax, rcx
            0x00401aed      4801ca         add rdx, rcx
            0x00401af0      48c1c010       rol rax, 0x10
            0x00401af4      4831d0         xor rax, rdx
            0x00401af7      4801f2         add rdx, rsi
            0x00401afa      48c1c611       rol rsi, 0x11
            0x00401afe      48c1c015       rol rax, 0x15
            0x00401b02      4831d0         xor rax, rdx
            0x00401b05      48c1c220       rol rdx, 0x20
            0x00401b09      4831f0         xor rax, rsi
            0x00401b0c      4831d0         xor rax, rdx
            0x00401b0f      c3             ret ; returns rax (certified)
EOF
RUN

# aarch64: a Mach-O whose operands reach data through a page and an offset.
NAME=aarch64 listing
FILE=tests/fixtures/code_pointer_table_O0
CMDS=s 0x100000420; pd 24
EXPECT=<<EOF
            0x100000420      ff4301d1       sub sp, sp, 0x50
            0x100000424      fd7b04a9       stp x29, x30, [sp, 0x40]
            0x100000428      fd030191       add x29, sp, 0x40
            0x10000042c      a0831ff8       stur x0, [x29, -0x8]
            0x100000430      a1031ff8       stur x1, [x29, -0x10]
            0x100000434      28000090       adrp x8, 0x100004000
            0x100000438      08010091       add x8, x8, 0x0
            0x10000043c      0001c03d       ldr q0, [x8]
            0x100000440      e007803d       str q0, [sp, 0x10]
            0x100000444      080940f9       ldr x8, [x8, 0x10]
            0x100000448      e81300f9       str x8, [sp, 0x20]
            0x10000044c      a8835ff8       ldur x8, [x29, -0x8]
            0x100000450      e80700f9       str x8, [sp, 0x8]
            0x100000454      ff0700b9       str wzr, [sp, 0x4]
            0x100000458      01000014       b 0x10000045c
            0x10000045c      e80740b9       ldr w8, [sp, 0x4]
            0x100000460      080d0071       subs w8, w8, 0x3
            0x100000464      22020054       b.hs 0x1000004a8
            0x100000468      01000014       b 0x10000046c
            0x10000046c      e80740b9       ldr w8, [sp, 0x4]
            0x100000470      e90308aa       mov x9, x8
            0x100000474      e8430091       add x8, sp, 0x10
            0x100000478      087969f8       ldr x8, [x8, x9, lsl 0x3]
            0x10000047c      e00740f9       ldr x0, [sp, 0x8]
EOF
RUN

# `pdf` folds each block, so the page and its offset are one address the table load reads.
NAME=aarch64 function listing
FILE=tests/fixtures/code_pointer_table_O0
CMDS=pdf @ sym._table_dispatch
EXPECT=<<EOF
            0x100000420      ff4301d1       sub sp, sp, 0x50
            0x100000424      fd7b04a9       stp x29, x30, [sp, 0x40]
            0x100000428      fd030191       add x29, sp, 0x40
            0x10000042c      a0831ff8       stur x0, [x29, -0x8]
            0x100000430      a1031ff8       stur x1, [x29, -0x10]
            0x100000434      28000090       adrp x8, 0x100004000
            0x100000438      08010091       add x8, x8, 0x0 ; defines x8 = 0x100004000 (folded)
            0x10000043c      0001c03d       ldr q0, [x8]
            0x100000440      e007803d       str q0, [sp, 0x10]
            0x100000444      080940f9       ldr x8, [x8, 0x10] ; [0x100004010:8] loaded 0x100000400 sym._table_op_mul (folded)
            0x100000448      e81300f9       str x8, [sp, 0x20]
            0x10000044c      a8835ff8       ldur x8, [x29, -0x8]
            0x100000450      e80700f9       str x8, [sp, 0x8]
            0x100000454      ff0700b9       str wzr, [sp, 0x4]
            0x100000458      01000014       b 0x10000045c
            0x10000045c      e80740b9       ldr w8, [sp, 0x4] ; loop: latches 0x100000498, exits 0x1000004a8 (certified) ; trips 0x4 (solved)
            0x100000460      080d0071       subs w8, w8, 0x3
            0x100000464      22020054       b.hs 0x1000004a8
            0x100000468      01000014       b 0x10000046c
            0x10000046c      e80740b9       ldr w8, [sp, 0x4] ; defines x8 in [0x0, 0x2] (solved)
            0x100000470      e90308aa       mov x9, x8 ; defines x9 in [0x0, 0x2] (solved)
            0x100000474      e8430091       add x8, sp, 0x10
            0x100000478      087969f8       ldr x8, [x8, x9, lsl 0x3]
            0x10000047c      e00740f9       ldr x0, [sp, 0x8]
            0x100000480      a9035ff8       ldur x9, [x29, -0x10]
            0x100000484      ea0740b9       ldr w10, [sp, 0x4] ; defines x10 in [0x0, 0x2] (solved)
            0x100000488      21010a8b       add x1, x9, x10
            0x10000048c      00013fd6       blr x8 ; indirect call: arguments unproven (certified)
            0x100000490      e00700f9       str x0, [sp, 0x8]
            0x100000494      01000014       b 0x100000498
            0x100000498      e80740b9       ldr w8, [sp, 0x4] ; defines x8 in [0x0, 0x2] (solved)
            0x10000049c      08050011       add w8, w8, 0x1 ; defines x8 in [0x1, 0x3] (solved)
            0x1000004a0      e80700b9       str w8, [sp, 0x4]
            0x1000004a4      eeffff17       b 0x10000045c
            0x1000004a8      e00740f9       ldr x0, [sp, 0x8]
            0x1000004ac      fd7b44a9       ldp x29, x30, [sp, 0x40]
            0x1000004b0      ff430191       add sp, sp, 0x50
            0x1000004b4      c0035fd6       ret
EOF
RUN

# ARM 32-bit: the register roles (`fp`, `ip`, `sp`, `lr`, `pc`), `mov` for Sleigh's `cpy`, and a
# BE8 Thumb-2 decode (little-endian code, big-endian data); radare2 reads it big-endian.
NAME=arm listing
FILE=crates/r2image/tests/data/arm_thumb_entry.elf
CMDS=pd 12
EXPECT=<<EOF
            0x00010054      4ff0000b       mov.w fp, 0x0
            0x00010058      4ff0000e       mov.w lr, 0x0
            0x0001005c      02bc           pop {r1}
            0x0001005e      6a46           mov r2, sp
EOF
RUN

# ARM 32-bit, audit W2: a Thumb `blx` back into ARM code states the target's set for the target
# alone, so the run after it stays Thumb and reads 0x476 as a fresh decode does.
NAME=thumb after a backward blx
FILE=tests/fixtures/special_sym_with_dot
CMDS=pd 6 @ 0x46e; ?e --fresh--; pd 3 @ 0x476
EXPECT=<<EOF
            0x0000046e      0548           ldr r0, [0x484] ; [0x484:4]=0x1c (decoded)
            0x00000470      7844           add r0, pc
            0x00000472      fff7a6ef       blx sym.imp.printf
            0x00000476      4ff0000e       mov.w lr, 0x0
            0x0000047a      0190           str r0, [sp, 0x4]
            0x0000047c      7046           mov r0, lr
--fresh--
            0x00000476      4ff0000e       mov.w lr, 0x0
            0x0000047a      0190           str r0, [sp, 0x4]
            0x0000047c      7046           mov r0, lr
EOF
RUN

# Big-endian ARM, audit W26: BE32 (no `EF_ARM_BE8`) reads its instructions most significant byte
# first, as objdump does; BE8 keeps them little-endian under its big-endian data.
NAME=be32 thumb listing
FILE=tests/fixtures/arm_thumb_movw_be.o
CMDS=pd 9 @ 0x8000034
EXPECT=<<EOF
            0x08000034      4770           bx lr
            0x08000036      f64f70fc       movw r0, 0xfffc
            0x0800003a      f6cf70fc       movt r0, 0xfffc
            0x0800003e      f47faffe       bne.w 0x800003e
            0x08000042      f003a7fe       beq.w 0x8044042
            0x08000046      4770           bx lr
            0x08000048      f2400308       movw r3, 0x8
            0x0800004c      f2c00308       movt r3, 0x8
            0x08000050      4770           bx lr
EOF
RUN

NAME=be8 arm listing
FILE=tests/fixtures/arm_plt_lld_be8.so
CMDS=pd 4 @ sym.f; pd 3 @ sym.imp.foo
EXPECT=<<EOF
            0x000101d4      10402de9       push {r4, lr}
            0x000101d8      0c0000eb       bl sym.imp.foo
            0x000101dc      0f0000eb       bl sym.imp.bar
            0x000101e0      1080bde8       pop {r4, pc}
            0x00010210      00c68fe2       adr ip, 0x10218
            0x00010214      20ca8ce2       add ip, ip, 0x20000
            0x00010218      7cf0bce5       ldr pc, [ip, 0x7c]!
EOF
RUN
