Home /Modules/decompiler/test_core.cpp

test_core.cpp

decompiler/tests/test_core.cpp · 346 line(s) · c

#include "sleela/decompiler/decompiler.hpp"
#include "sleela/decompiler/errors.hpp"
#include "sleela/decompiler/output.hpp"
#include "sleela/decompiler/slir.hpp"
#include "sleela/decompiler/vm.hpp"
#include "sleela/decompiler/destination.hpp"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <string>
#include <vector>
#include <fstream>
static void put16(std::vector<std::uint8_t>& b,std::size_t p,std::uint16_t v){b[p]=std::uint8_t(v);b[p+1]=std::uint8_t(v>>8);}
static void put32(std::vector<std::uint8_t>& b,std::size_t p,std::uint32_t v){for(int i=0;i<4;++i)b[p+i]=std::uint8_t(v>>(8*i));}
static void put64(std::vector<std::uint8_t>& b,std::size_t p,std::uint64_t v){for(int i=0;i<8;++i)b[p+i]=std::uint8_t(v>>(8*i));}
int main(){
    {
        using namespace sleela::decompiler;
        DecompilerError e(ErrorCode::InvalidAddress, "bad address", 17, 0x401000, "decoder");
        assert(e.code() == ErrorCode::InvalidAddress);
        assert(e.file_offset() == 17);
        assert(e.virtual_address() == 0x401000);
        assert(e.stage() == "decoder");
        assert(std::string(error_code_name(e.code())) == "InvalidAddress");
    }

    {const unsigned char bytes[]={'M','Z',0,1,2,3};auto a=sleela::decompiler::Artifact::from_bytes(bytes,"sample.exe");assert(a.format()==sleela::decompiler::Format::PE);assert(a.size()==6);auto i=sleela::decompiler::Decoder{}.decode(a,0,4);assert(i.size()==4);}
    {std::vector<std::uint8_t> ar{'!','<','a','r','c','h','>','\n'};std::string h(60,' ');h.replace(0,16,"member.o/");h.replace(48,10,"2");h[58]=char(96);h[59]='\n';ar.insert(ar.end(),h.begin(),h.end());ar.insert(ar.end(),{0x7f,'E','L','F'});auto a=sleela::decompiler::Artifact::from_bytes(ar,"libsample.a");assert(a.format()==sleela::decompiler::Format::GNUArchive);assert(a.artifact_class()==sleela::decompiler::ArtifactClass::StaticArchive);assert(a.interfaces().archive_members.size()==1);assert(a.interfaces().archive_members[0].name=="member.o");assert(a.interfaces().archive_members[0].format==sleela::decompiler::Format::ELF);}
    {std::vector<std::uint8_t> elf(0x140,0);elf[0]=0x7f;elf[1]='E';elf[2]='L';elf[3]='F';elf[4]=2;elf[5]=1;elf[6]=1;put16(elf,16,2);put16(elf,18,62);put64(elf,24,0x100);put64(elf,32,0);put64(elf,40,0);put16(elf,52,64);put16(elf,54,56);put16(elf,56,0);
        const std::uint8_t code[]={0xe8,0x01,0x00,0x00,0x00,0x74,0x02,0xff,0xd0,0xc3};std::copy(std::begin(code),std::end(code),elf.begin()+0x100);
        auto a=sleela::decompiler::Artifact::from_bytes(elf,"fixture.elf");assert(a.format()==sleela::decompiler::Format::ELF);assert(a.architecture()==sleela::decompiler::Architecture::X86_64);
        auto ins=sleela::decompiler::Decoder{}.decode(a,0x100,sizeof(code));assert(ins.size()==4);assert(ins[0].is_call&&ins[0].branch_targets[0]==0x106);assert(ins[1].is_branch&&ins[1].is_conditional&&ins[1].branch_targets[0]==0x109);assert(ins[2].is_call&&ins[2].is_indirect&&ins[2].operands[0].kind==sleela::decompiler::Operand::Kind::Register);assert(ins[3].is_return);
        auto cfg=sleela::decompiler::Analyzer{}.build_cfg(ins);assert(cfg.blocks.size()>=3);assert(!cfg.edges.empty());auto funcs=sleela::decompiler::Analyzer{}.recover_function_candidates(a,cfg);assert(!funcs.empty());
    }
    // PE/COFF: real import-directory recovery (DLL dependency + imported function name).
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> pe(0x400,0);
        pe[0]='M';pe[1]='Z'; put32(pe,0x3c,0x80);              // e_lfanew -> PE header at 0x80
        const std::size_t h=0x80; pe[h]='P';pe[h+1]='E';pe[h+2]=0;pe[h+3]=0;
        put16(pe,h+4,0x8664);                                   // machine x86-64
        put16(pe,h+6,1);                                        // 1 section
        put16(pe,h+20,0xF0);                                    // SizeOfOptionalHeader
        put16(pe,h+22,0x0002);                                  // characteristics: EXECUTABLE_IMAGE
        const std::size_t opt=h+24; put16(pe,opt,0x20b);        // PE32+ magic
        put64(pe,opt+24,0x140000000ull);                        // ImageBase
        put32(pe,opt+108,16);                                   // NumberOfRvaAndSizes
        const std::size_t dirs=opt+112;
        // Section ".idata" maps RVA 0x1000 -> file 0x200.
        const std::size_t st=opt+0xF0; const char* sn=".idata";
        for(int i=0;i<6;++i)pe[st+i]=std::uint8_t(sn[i]);
        put32(pe,st+8,0x200);put32(pe,st+12,0x1000);put32(pe,st+16,0x200);put32(pe,st+20,0x200);
        // Import directory at RVA 0x1000 (file 0x200): one descriptor + terminator.
        put32(pe,dirs+1*8,0x1000);put32(pe,dirs+1*8+4,40);      // data directory [1] = IMPORT
        const std::size_t id=0x200;
        put32(pe,id+0,0x1040);                                   // OriginalFirstThunk RVA 0x1040 (file 0x240)
        put32(pe,id+12,0x1060);                                  // Name RVA 0x1060 (file 0x260)
        put32(pe,id+16,0x1040);                                  // FirstThunk
        // terminator descriptor is the zeroed 20 bytes that follow
        put64(pe,0x240,0x1050);                                  // thunk -> hint/name RVA 0x1050 (file 0x250), then 0 terminator
        const char* fn="CreateFileW"; for(std::size_t i=0;i<11;++i)pe[0x250+2+i]=std::uint8_t(fn[i]);
        const char* dll="KERNEL32.dll"; for(std::size_t i=0;i<12;++i)pe[0x260+i]=std::uint8_t(dll[i]);
        auto a=Artifact::from_bytes(pe,"sample.exe");
        assert(a.format()==Format::PE);
        assert(a.architecture()==Architecture::X86_64);
        assert(a.interfaces().sections.size()==1);
        bool saw_dll=false,saw_fn=false;
        for(const auto& im:a.interfaces().imports){if(im.library=="KERNEL32.dll")saw_dll=true;if(im.name=="CreateFileW")saw_fn=true;}
        assert(saw_dll&&saw_fn);
    }

    // Mach-O: thin 64-bit object header is recognized and classified.
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> mo(0x80,0);
        mo[0]=0xcf;mo[1]=0xfa;mo[2]=0xed;mo[3]=0xfe;                 // MH_MAGIC_64 (little-endian)
        put32(mo,4,0x01000007);                                      // cputype x86_64
        put32(mo,12,2);                                              // filetype MH_EXECUTE
        put32(mo,16,0);                                             // ncmds 0 (header-only fixture)
        auto a=Artifact::from_bytes(mo,"sample.macho");
        assert(a.format()==Format::MachO);
        assert(a.architecture()==Architecture::X86_64);
        assert(a.artifact_class()==ArtifactClass::Executable);
    }

    // ARM (A32): real control-flow decode (BL, B, BX lr=return) and CFG construction.
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> elf(0x140,0);
        elf[0]=0x7f;elf[1]='E';elf[2]='L';elf[3]='F';elf[4]=1;elf[5]=1;elf[6]=1;   // 32-bit ELF
        put16(elf,16,2);put16(elf,18,40);                                          // ET_EXEC, EM_ARM
        put32(elf,28,0);put32(elf,32,0);put16(elf,40,32);put16(elf,42,56);put16(elf,44,0);
        auto w=[&](std::size_t off,std::uint32_t v){for(int k=0;k<4;++k)elf[off+k]=std::uint8_t(v>>(8*k));};
        w(0x100,0xeb000000);   // bl  (pc+8 + 0)
        w(0x104,0xea000001);   // b   (pc+8 + 4)
        w(0x108,0xe12fff1e);   // bx lr  -> return
        auto a=Artifact::from_bytes(elf,"fixture.arm");
        assert(a.architecture()==Architecture::ARM);
        auto ins=Decoder{}.decode(a,0x100,12);
        assert(ins.size()==3);
        assert(ins[0].is_call&&ins[0].mnemonic=="bl");
        assert(ins[1].is_branch&&ins[1].mnemonic=="b");
        assert(ins[2].is_return&&ins[2].mnemonic=="bx");
        auto cfg=Analyzer{}.build_cfg(ins);
        assert(!cfg.blocks.empty());
    }

    // ARM Thumb (T32): variable-width control-flow decode, bytes from llvm-mc (thumbv7).
    // Layout: bl(4) b.w(4) beq(2) b(2) cbz(2) bx-lr(2) nop(2) nop(2) = 8 instructions.
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> elf(0x140,0);
        elf[0]=0x7f;elf[1]='E';elf[2]='L';elf[3]='F';elf[4]=1;elf[5]=1;elf[6]=1;   // 32-bit ELF
        put16(elf,16,2);put16(elf,18,40);                                          // ET_EXEC, EM_ARM
        put16(elf,40,32);put16(elf,42,56);put16(elf,44,0);
        const std::uint8_t code[]={0x00,0xf0,0x07,0xf8, 0x00,0xf0,0x05,0xb8, 0x03,0xd0, 0x02,0xe0, 0x08,0xb1, 0x70,0x47, 0x00,0xbf, 0x00,0xbf};
        std::copy(std::begin(code),std::end(code),elf.begin()+0x100);
        auto a=Artifact::from_bytes(elf,"fixture.thumb");
        assert(a.architecture()==Architecture::ARM);
        auto ins=Decoder{}.decode(a,0x100,sizeof(code),DecodeMode::ArmThumb);
        assert(ins.size()==8);                                   // widths resolved correctly
        assert(ins[0].mnemonic=="bl"&&ins[0].is_call&&ins[0].bytes.size()==4);
        assert(ins[1].mnemonic=="b.w"&&ins[1].is_branch&&ins[1].bytes.size()==4);
        assert(ins[2].mnemonic=="b"&&ins[2].is_conditional&&ins[2].bytes.size()==2);
        assert(ins[3].mnemonic=="b"&&ins[3].is_branch&&!ins[3].is_conditional);
        assert(ins[4].mnemonic=="cbz"&&ins[4].is_conditional);
        assert(ins[5].mnemonic=="bx"&&ins[5].is_return);
        assert(ins[6].mnemonic=="nop"&&ins[7].mnemonic=="nop");
        // All five branch/call instructions should resolve to the same target (0x112).
        assert(ins[0].branch_targets[0]==0x112);
        assert(ins[1].branch_targets[0]==0x112);
        assert(ins[2].branch_targets[0]==0x112);
        assert(ins[3].branch_targets[0]==0x112);
        assert(ins[4].branch_targets[0]==0x112);
        auto cfg=Analyzer{}.build_cfg(ins);
        assert(!cfg.blocks.empty());
        // POP {..,pc} must classify as a return and not be shadowed by the PUSH mask.
        // push {r4,lr}=10 b5 | pop {r4,pc}=10 bd | pop {r4,r5}=30 bc  (llvm-mc thumbv7)
        std::vector<std::uint8_t> pp(0x140,0);
        pp[0]=0x7f;pp[1]='E';pp[2]='L';pp[3]='F';pp[4]=1;pp[5]=1;pp[6]=1;put16(pp,16,2);put16(pp,18,40);
        const std::uint8_t ppc[]={0x10,0xb5, 0x10,0xbd, 0x30,0xbc};
        std::copy(std::begin(ppc),std::end(ppc),pp.begin()+0x100);
        auto pa=Artifact::from_bytes(pp,"fixture.thumbpp");
        auto pi=Decoder{}.decode(pa,0x100,sizeof(ppc),DecodeMode::ArmThumb);
        assert(pi.size()==3);
        assert(pi[0].mnemonic=="push"&&!pi[0].is_return);
        assert(pi[1].mnemonic=="pop"&&pi[1].is_return);
        assert(pi[2].mnemonic=="pop"&&!pi[2].is_return);
    }

    // Operand-level recovery: the rendered .text must carry both operands in Intel order.
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> elf(0x140,0);
        elf[0]=0x7f;elf[1]='E';elf[2]='L';elf[3]='F';elf[4]=2;elf[5]=1;elf[6]=1;
        put16(elf,16,2);put16(elf,18,62);put64(elf,24,0x100);put16(elf,52,64);put16(elf,54,56);put16(elf,56,0);
        // mov rbp,rsp (48 89 e5) | sub rsp,0x10 (48 83 ec 10) | mov [rbp-4],0x2a (c7 45 fc ..) | lea rax,[rbp-8] (48 8d 45 f8)
        const std::uint8_t code[]={0x48,0x89,0xe5, 0x48,0x83,0xec,0x10, 0xc7,0x45,0xfc,0x2a,0x00,0x00,0x00, 0x48,0x8d,0x45,0xf8};
        std::copy(std::begin(code),std::end(code),elf.begin()+0x100);
        auto a=Artifact::from_bytes(elf,"fixture.ops");
        auto ins=Decoder{}.decode(a,0x100,sizeof(code));
        assert(ins.size()==4);
        assert(ins[0].text=="mov rbp, rsp");
        assert(ins[1].text=="sub rsp, 0x10");
        assert(ins[2].text=="mov [rbp-0x4], 0x2a");   // signed displacement rendered as -0x4
        assert(ins[3].text=="lea rax, [rbp-0x8]");
    }

    // Beautified emission: header carries an include guard and a documented prototype;
    // source carries the provenance banner and an operand-level evidence line.
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> elf(0x140,0);
        elf[0]=0x7f;elf[1]='E';elf[2]='L';elf[3]='F';elf[4]=2;elf[5]=1;elf[6]=1;
        put16(elf,16,2);put16(elf,18,62);put64(elf,24,0x100);put16(elf,52,64);put16(elf,54,56);put16(elf,56,0);
        const std::uint8_t code[]={0x48,0x89,0xe5,0xc3};   // mov rbp,rsp ; ret
        std::copy(std::begin(code),std::end(code),elf.begin()+0x100);
        auto a=Artifact::from_bytes(elf,"fixture.emit");
        auto ins=Decoder{}.decode(a,0x100,sizeof(code));
        auto cfg=Analyzer{}.build_cfg(ins);
        auto funcs=Analyzer{}.recover_function_candidates(a,cfg);
        DecompilationOptions opt{SourceLanguage::CPlusPlus,"unit"};
        const std::string hdr=SourceEmitter::emit_header(a,funcs,opt);
        assert(hdr.find("#ifndef SLECOMPILER_UNIT_H")!=std::string::npos);
        assert(hdr.find("#define SLECOMPILER_UNIT_H")!=std::string::npos);
        assert(hdr.find("#endif /* SLECOMPILER_UNIT_H */")!=std::string::npos);
        assert(hdr.find("namespace slecompiler")!=std::string::npos);
        const std::string src=SourceEmitter::emit(a,ins,cfg,funcs,opt);
        assert(src.find("Generated by Slecompiler")!=std::string::npos);
        assert(src.find("mov rbp, rsp")!=std::string::npos);   // operand-level evidence present
        assert(src.find("@brief Recovered native function")!=std::string::npos);
    }

    // SLIR lifting: instructions lift to architecture-neutral operations with statement text.
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> elf(0x140,0);
        elf[0]=0x7f;elf[1]='E';elf[2]='L';elf[3]='F';elf[4]=2;elf[5]=1;elf[6]=1;
        put16(elf,16,2);put16(elf,18,62);put64(elf,24,0x100);put16(elf,52,64);put16(elf,54,56);put16(elf,56,0);
        // mov rbp,rsp | sub rsp,0x10 | cmp [rbp-4],0x7f | ret
        const std::uint8_t code[]={0x48,0x89,0xe5, 0x48,0x83,0xec,0x10, 0x83,0x7d,0xfc,0x7f, 0xc3};
        std::copy(std::begin(code),std::end(code),elf.begin()+0x100);
        auto a=Artifact::from_bytes(elf,"fixture.lift");
        auto ins=Decoder{}.decode(a,0x100,sizeof(code));
        auto cfg=Analyzer{}.build_cfg(ins);
        auto funcs=Analyzer{}.recover_function_candidates(a,cfg);
        auto mod=Lifter{}.lift(a,ins,cfg,funcs);
        assert(!mod.functions.empty());
        const auto& ops=mod.functions.front().blocks.front().operations;
        assert(ops.size()==4);
        assert(ops[0].opcode==OpCode::Move && ops[0].text=="rbp = rsp;");
        assert(ops[1].opcode==OpCode::Sub  && ops[1].text=="rsp -= 0x10;");
        assert(ops[2].opcode==OpCode::Compare);
        assert(ops[3].opcode==OpCode::Return && ops[3].text=="return;");
        // The source emitter renders the lifted statements into the function body.
        DecompilationOptions opt{SourceLanguage::CPlusPlus,"lift"};
        const std::string src=SourceEmitter::emit(a,ins,cfg,funcs,mod,opt);
        assert(src.find("rbp = rsp;")!=std::string::npos);
        assert(src.find("rsp -= 0x10;")!=std::string::npos);
    }

    // SLIR lift is VM-executable: a hand-built constant-add module runs and yields 42.
    {
        using namespace sleela::decompiler;
        Module m; m.name="vm-check"; m.architecture=Architecture::X86_64;
        Function fn; fn.name="add"; fn.address=0x1000;
        SlirBlock b; b.id=0;
        Operation c0; c0.opcode=OpCode::Const; c0.immediate=40; c0.outputs.push_back({0,"u64","a"});
        Operation c1; c1.opcode=OpCode::Const; c1.immediate=2;  c1.outputs.push_back({1,"u64","b"});
        Operation ad; ad.opcode=OpCode::Add; ad.inputs={{0,"u64","a"},{1,"u64","b"}}; ad.outputs.push_back({2,"u64","r"});
        Operation rt; rt.opcode=OpCode::Return;
        b.operations={c0,c1,ad,rt}; fn.blocks.push_back(b); m.functions.push_back(fn);
        Vm vm({4096,32,true}); vm.load(m);
        assert(vm.run());
        assert(vm.register_value(2)==42);
    }

    // Destination adapter: URI parsing for all schemes, DNS/IPv4/IPv6, ports, credentials.
    {
        using namespace sleela::decompiler;
        Destination d; std::string err;
        // Bare local path and file: scheme.
        assert(parse_destination("/tmp/out.cpp", d, err) && d.kind==DestinationKind::File && d.path=="/tmp/out.cpp");
        assert(parse_destination("file:/var/x.c", d, err) && d.kind==DestinationKind::File && d.path=="/var/x.c");
        // FTP with credentials, DNS host, explicit port.
        assert(parse_destination("ftp://user:pass@ftp.example.org:2121/incoming/r.cpp", d, err));
        assert(d.kind==DestinationKind::FtpStore && d.host=="ftp.example.org" && d.port==2121);
        assert(d.username=="user" && d.password=="pass" && d.path=="/incoming/r.cpp");
        // HTTP POST, IPv4 literal, default port (0 => transport default 80).
        assert(parse_destination("http://192.0.2.10/upload/r.c", d, err));
        assert(d.kind==DestinationKind::HttpPost && d.host=="192.0.2.10" && d.port==0 && d.path=="/upload/r.c");
        // Explicit POST and PUT schemes.
        assert(parse_destination("http+put://host.example:8080/a", d, err) && d.kind==DestinationKind::HttpPut && d.port==8080);
        assert(parse_destination("http+post://host.example/a", d, err) && d.kind==DestinationKind::HttpPost);
        // IPv6 literal in brackets, with port; IP preference set to IPv6.
        assert(parse_destination("http://[2001:db8::1]:8443/p", d, err));
        assert(d.host=="2001:db8::1" && d.port==8443 && d.ip_preference==IpPreference::IPv6);
        // IPv6 literal without explicit port.
        assert(parse_destination("sftp://[2001:db8::2]/remote/r.c", d, err));
        assert(d.kind==DestinationKind::Sftp && d.host=="2001:db8::2" && d.port==0);
        // SFTP with user, DNS host.
        assert(parse_destination("sftp://deploy@build.example.net/out/r.cpp", d, err));
        assert(d.username=="deploy" && d.host=="build.example.net" && d.path=="/out/r.cpp");
        // Unsupported scheme fails cleanly.
        assert(!parse_destination("gopher://host/x", d, err) && !err.empty());
        // kind names
        assert(std::string(destination_kind_name(DestinationKind::FtpStore))=="ftp");
        assert(std::string(destination_kind_name(DestinationKind::HttpPost))=="http-post");
        assert(std::string(destination_kind_name(DestinationKind::Sftp))=="sftp");
    }

    // Destination adapter: local File and Directory delivery actually write bytes.
    {
        using namespace sleela::decompiler;
        Destination f; std::string err;
        assert(parse_destination("file:/tmp/slecompiler_unit_out.txt", f, err));
        auto r = deliver(f, "hello-slir");
        assert(r.ok && r.bytes_sent==10);
        std::ifstream in("/tmp/slecompiler_unit_out.txt", std::ios::binary);
        std::string got((std::istreambuf_iterator<char>(in)), {});
        assert(got=="hello-slir");
    }

    // x86-64 extended opcodes: REX.W prefix, ModR/M mov, leave, int3, ret.
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> elf(0x140,0);
        elf[0]=0x7f;elf[1]='E';elf[2]='L';elf[3]='F';elf[4]=2;elf[5]=1;elf[6]=1;
        put16(elf,16,2);put16(elf,18,62);put64(elf,24,0x100);put16(elf,52,64);put16(elf,54,56);put16(elf,56,0);
        // 48 89 e5  mov rbp,rsp (REX.W + mov r/m,r)  |  c9 leave  |  cc int3  |  c3 ret
        const std::uint8_t code[]={0x48,0x89,0xe5, 0xc9, 0xcc, 0xc3};
        std::copy(std::begin(code),std::end(code),elf.begin()+0x100);
        auto a=Artifact::from_bytes(elf,"fixture.x64");
        auto ins=Decoder{}.decode(a,0x100,sizeof(code));
        assert(ins.size()==4);                           // prefix folds into the mov
        assert(ins[0].mnemonic=="mov"&&ins[0].bytes.size()==3);
        assert(ins[1].mnemonic=="leave");
        assert(ins[2].mnemonic=="int3");
        assert(ins[3].mnemonic=="ret"&&ins[3].is_return);
    }

    // x86-64 immediate-group ALU + mov-imm, bytes from llvm-mc (x86_64).
    // sub rsp,0x10 (48 83 ec 10) | cmp [rbp-4],0x7f (83 7d fc 7f) | mov [rbp-8],0xdeadbeef (c7 45 f8 ..)
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> elf(0x140,0);
        elf[0]=0x7f;elf[1]='E';elf[2]='L';elf[3]='F';elf[4]=2;elf[5]=1;elf[6]=1;
        put16(elf,16,2);put16(elf,18,62);put64(elf,24,0x100);put16(elf,52,64);put16(elf,54,56);put16(elf,56,0);
        const std::uint8_t code[]={0x48,0x83,0xec,0x10, 0x83,0x7d,0xfc,0x7f, 0xc7,0x45,0xf8,0xef,0xbe,0xad,0xde};
        std::copy(std::begin(code),std::end(code),elf.begin()+0x100);
        auto a=Artifact::from_bytes(elf,"fixture.imm");
        auto ins=Decoder{}.decode(a,0x100,sizeof(code));
        assert(ins.size()==3);                                   // all three lengths resolved exactly
        assert(ins[0].mnemonic=="sub"&&ins[0].bytes.size()==4);
        assert(ins[1].mnemonic=="cmp"&&ins[1].bytes.size()==4);
        assert(ins[2].mnemonic=="mov"&&ins[2].bytes.size()==7);
        assert(ins[2].operands.size()>=2&&ins[2].operands.back().value==std::int64_t(0xdeadbeef));
    }

    // ARM64: real A64 control-flow decode (BL, B.cond, CBZ, RET) and CFG construction.
    {
        using namespace sleela::decompiler;
        std::vector<std::uint8_t> elf(0x140,0);
        elf[0]=0x7f;elf[1]='E';elf[2]='L';elf[3]='F';elf[4]=2;elf[5]=1;elf[6]=1;
        put16(elf,16,2);put16(elf,18,183);                          // ET_EXEC, EM_AARCH64
        put64(elf,24,0x100);put64(elf,32,0);put64(elf,40,0);put16(elf,52,64);put16(elf,54,56);put16(elf,56,0);
        auto w=[&](std::size_t off,std::uint32_t v){elf[off]=std::uint8_t(v);elf[off+1]=std::uint8_t(v>>8);elf[off+2]=std::uint8_t(v>>16);elf[off+3]=std::uint8_t(v>>24);};
        w(0x100,0x94000002);                                        // bl  +8
        w(0x104,0x54000040);                                        // b.cond +8
        w(0x108,0xb4000040);                                        // cbz  +8
        w(0x10c,0xd65f03c0);                                        // ret
        auto a=Artifact::from_bytes(elf,"fixture.arm64");
        assert(a.architecture()==Architecture::ARM64);
        auto ins=Decoder{}.decode(a,0x100,16);
        assert(ins.size()==4);
        assert(ins[0].is_call&&ins[0].mnemonic=="bl"&&ins[0].branch_targets[0]==0x108);
        assert(ins[1].is_branch&&ins[1].is_conditional&&ins[1].mnemonic=="b.cond");
        assert(ins[2].is_branch&&ins[2].is_conditional&&ins[2].mnemonic=="cbz");
        assert(ins[3].is_return);
        auto cfg=Analyzer{}.build_cfg(ins);
        assert(!cfg.blocks.empty());
    }

    return 0;
}