#include "sleela/decompiler/decompiler.hpp" #include #include #include #include namespace sleela::decompiler { namespace { Instruction base(const std::vector& b, std::size_t p, const std::string& mnemonic, double confidence=0.80) { Instruction i; i.address=p; i.bytes.push_back(b[p]); i.mnemonic=mnemonic; i.provenance={p,p,"stage4-x86",confidence}; return i; } std::int64_t rel8(std::uint8_t x){return static_cast(x);} std::int64_t rel32(const std::vector& b,std::size_t p){ return std::int64_t(std::int32_t(std::uint32_t(b[p])|(std::uint32_t(b[p+1])<<8)| (std::uint32_t(b[p+2])<<16)|(std::uint32_t(b[p+3])<<24))); } std::string hex(std::uint64_t v){std::ostringstream s;s<<"0x"<& b,std::size_t p,std::size_t end,bool addr64,bool oper_wide,ModRm& out){ if(p>=end)return false; const std::uint8_t m=b[p]; const unsigned mod=m>>6u,reg=(m>>3u)&7u,rm=m&7u; out.reg=static_cast(reg); std::size_t n=1; std::ostringstream t; if(mod==3){out.kind=Operand::Kind::Register;out.operand=reg_name(rm,oper_wide);out.length=n;return true;} out.kind=Operand::Kind::Memory;t<<"["; auto rd32v=[&](std::size_t q){return std::uint32_t(b[q])|(std::uint32_t(b[q+1])<<8)|(std::uint32_t(b[q+2])<<16)|(std::uint32_t(b[q+3])<<24);}; if(rm==4){ if(p+1>=end)return false; const std::uint8_t sib=b[p+1]; const unsigned scale=1u<<(sib>>6),index=(sib>>3)&7u,base_r=sib&7u; n++; bool wrote=false; if(index!=4){t<end)return false; const std::int32_t d=std::int32_t(rd32v(p+n)); if(wrote)t<=end)return false;t<(b[p+n]));n++;} else if(mod==2){if(p+n+4>end)return false;t<end)return false; const std::int32_t d=std::int32_t(rd32v(p+n)); if(addr64)t<<"rip"<=end)return false;t<(b[p+n]));n++;} else if(mod==2){if(p+n+4>end)return false;t<"; return s; } } // --- AArch64 (ARM64) fixed-width decoder ------------------------------------------------- // A64 instructions are 4 bytes, little-endian. This recovers the control-flow-relevant // subset (branches, compares, returns, indirect transfers, nop) needed to build a CFG; // other encodings are represented conservatively as a ".inst" word rather than guessed. namespace { std::uint32_t a64_word(const std::vector& b,std::size_t p){ return std::uint32_t(b[p])|(std::uint32_t(b[p+1])<<8)|(std::uint32_t(b[p+2])<<16)|(std::uint32_t(b[p+3])<<24); } std::int64_t sign_extend(std::uint64_t v,unsigned bits){ const std::uint64_t m=std::uint64_t(1)<<(bits-1); return std::int64_t((v^m)-m); } Instruction a64_base(std::size_t p,const std::vector& b,const std::string& mnem,double conf=0.85){ Instruction i;i.address=p;i.bytes.assign(b.begin()+p,b.begin()+p+4);i.mnemonic=mnem;i.provenance={p,p,"stage4-arm64",conf};return i; } Instruction decode_a64(const std::vector& b,std::size_t p){ const std::uint32_t w=a64_word(b,p); auto rel=[&](std::int64_t imm){return std::uint64_t(std::int64_t(p)+imm);}; if(w==0xd503201f) return a64_base(p,b,"nop"); if(w==0xd65f03c0){auto i=a64_base(p,b,"ret");i.is_return=true;return i;} // RET x30 if((w&0xfffffc1f)==0xd65f0000){auto i=a64_base(p,b,"ret");i.is_return=true;i.is_indirect=true;return i;} // RET Xn if((w&0xfc000000)==0x14000000||(w&0xfc000000)==0x94000000){ // B / BL imm26 const bool link=(w&0x80000000)!=0; auto t=rel(sign_extend((w&0x03ffffff),26)*4); auto i=a64_base(p,b,link?"bl":"b"); if(link)i.is_call=true;else i.is_branch=true; i.branch_targets.push_back(t); i.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)}); return i; } if((w&0xff000010)==0x54000000){ // B.cond imm19 auto t=rel(sign_extend((w>>5)&0x7ffff,19)*4); auto i=a64_base(p,b,"b.cond"); i.is_branch=true;i.is_conditional=true;i.branch_targets.push_back(t);i.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)});return i; } if((w&0x7e000000)==0x34000000){ // CBZ/CBNZ imm19 auto t=rel(sign_extend((w>>5)&0x7ffff,19)*4); auto i=a64_base(p,b,(w&0x01000000)?"cbnz":"cbz"); i.is_branch=true;i.is_conditional=true;i.branch_targets.push_back(t);i.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)});return i; } if((w&0x7e000000)==0x36000000){ // TBZ/TBNZ imm14 auto t=rel(sign_extend((w>>5)&0x3fff,14)*4); auto i=a64_base(p,b,(w&0x01000000)?"tbnz":"tbz"); i.is_branch=true;i.is_conditional=true;i.branch_targets.push_back(t);i.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)});return i; } if((w&0xfffffc1f)==0xd61f0000){auto i=a64_base(p,b,"br");i.is_branch=true;i.is_indirect=true;return i;} // BR Xn if((w&0xfffffc1f)==0xd63f0000){auto i=a64_base(p,b,"blr");i.is_call=true;i.is_indirect=true;return i;} // BLR Xn auto i=a64_base(p,b,".inst",0.30); i.operands.push_back({Operand::Kind::Immediate,hex(w),std::int64_t(w)}); return i; } } // --- ARM (A32) fixed-width decoder ------------------------------------------------------- // A32 instructions are 4 bytes, little-endian, with a 4-bit condition code in the top // nibble (0xE = AL/always; 0xF is reserved for unconditional-encoding space). This // recovers the control-flow-relevant subset (B/BL, BX/BLX register, pc-writing returns, // nop) for a CFG; other encodings are represented conservatively as a ".inst" word. // Thumb (T32) is variable-width and is intentionally out of scope for this increment. namespace { Instruction a32_base(std::size_t p,const std::vector& b,const std::string& mnem,double conf=0.80){ Instruction i;i.address=p;i.bytes.assign(b.begin()+p,b.begin()+p+4);i.mnemonic=mnem;i.provenance={p,p,"stage4-arm",conf};return i; } Instruction decode_a32(const std::vector& b,std::size_t p){ const std::uint32_t w=a64_word(b,p); // same little-endian word reader const std::uint32_t cond=w>>28; const bool always=(cond==0xE); if(w==0xe320f000) return a32_base(p,b,"nop"); // NOP (hint) on ARMv6K+ if((w&0x0e000000)==0x0a000000){ // B/BL: cccc 101L imm24 const bool link=(w&0x01000000)!=0; const std::int64_t off=sign_extend(w&0x00ffffff,24)*4; const std::uint64_t t=std::uint64_t(std::int64_t(p)+8+off); // ARM PC reads as insn+8 auto i=a32_base(p,b,link?"bl":"b"); if(link)i.is_call=true;else i.is_branch=true; if(!always)i.is_conditional=true; i.branch_targets.push_back(t);i.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)});return i; } if((w&0x0ffffff0)==0x012fff10){auto i=a32_base(p,b,"bx");i.is_branch=true;i.is_indirect=true;if((w&0xf)==14)i.is_return=true;if(!always)i.is_conditional=true;return i;} // BX Rm (BX lr == return) if((w&0x0ffffff0)==0x012fff30){auto i=a32_base(p,b,"blx");i.is_call=true;i.is_indirect=true;if(!always)i.is_conditional=true;return i;} // BLX Rm // Returns that write PC directly: LDM/POP with the PC bit set, or MOV pc,lr. if((w&0x0e108000)==0x08108000){auto i=a32_base(p,b,"ldm");i.is_return=true;i.is_indirect=true;if(!always)i.is_conditional=true;return i;} // LDM.. {..,pc} if((w&0x0fffffff)==0x01a0f00e){auto i=a32_base(p,b,"mov");i.is_return=true;i.is_indirect=true;return i;} // MOV pc, lr auto i=a32_base(p,b,".inst",0.30);i.operands.push_back({Operand::Kind::Immediate,hex(w),std::int64_t(w)});return i; } } // --- ARM Thumb (T32) variable-width decoder ---------------------------------------------- // Thumb is 16-bit by default; a first halfword with top-5-bits in {11101,11110,11111} // introduces a 32-bit instruction that consumes a second halfword. This recovers the // control-flow subset -- conditional/unconditional B, BL/BLX(imm), BX/BLX(reg), CBZ/CBNZ, // pc-writing POP, and NOP -- which is what the CFG stage needs. Each decoded instruction // reports its own byte length so the caller advances correctly; unknown encodings become // ".inst" of their detected width rather than being guessed. namespace { std::uint16_t thumb_hw(const std::vector& b,std::size_t p){ return std::uint16_t(b[p])|(std::uint16_t(b[p+1])<<8); } bool thumb_is_32bit(std::uint16_t hw1){ const std::uint16_t top=hw1&0xf800; return top==0xe800||top==0xf000||top==0xf800; } Instruction thumb_base(std::size_t p,const std::vector& b,std::size_t len,const std::string& mnem,double conf=0.80){ Instruction i;i.address=p;i.bytes.assign(b.begin()+p,b.begin()+p+len);i.mnemonic=mnem;i.provenance={p,p,"stage4-thumb",conf};return i; } // Decode one Thumb instruction at p (p+2 <= end guaranteed by caller). out_len is set to 2 or 4. Instruction decode_thumb(const std::vector& b,std::size_t p,std::size_t end,std::size_t& out_len){ const std::uint16_t hw1=thumb_hw(b,p); auto rel=[&](std::int64_t imm){return std::uint64_t(std::int64_t(p)+4+imm);}; // Thumb PC reads as insn+4 if(thumb_is_32bit(hw1)&&p+4<=end){ out_len=4; const std::uint16_t hw2=thumb_hw(b,p+2); // 32-bit B/BL/BLX family: hw1[15:11]=11110, hw2[15]=1, hw2[14]=1 selects branch class. if((hw1&0xf800)==0xf000&&(hw2&0x8000)==0x8000){ const std::uint32_t s=(hw1>>10)&1, imm10=hw1&0x3ff, j1=(hw2>>13)&1, j2=(hw2>>11)&1, imm11=hw2&0x7ff; const std::uint32_t op2=(hw2>>12)&0x7; // bit14..12 const std::uint32_t i1=~(j1^s)&1, i2=~(j2^s)&1; if(op2==0x5||op2==0x7){ // BL (op2 bit14=1,bit12=1) / BLX(imm) (bit12=0) -> both are calls const std::uint32_t imm=(s<<24)|(i1<<23)|(i2<<22)|(imm10<<12)|(imm11<<1); auto t=rel(sign_extend(imm,25)); auto in=thumb_base(p,b,4,(op2&0x1)?"bl":"blx"); in.is_call=true; in.branch_targets.push_back(t); in.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)}); return in; } if(op2==0x1||op2==0x3){ // B.W unconditional (T4) const std::uint32_t imm=(s<<24)|(i1<<23)|(i2<<22)|(imm10<<12)|(imm11<<1); auto t=rel(sign_extend(imm,25)); auto in=thumb_base(p,b,4,"b.w"); in.is_branch=true; in.branch_targets.push_back(t); in.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)}); return in; } if(op2==0x0||op2==0x2){ // B.W (T3): cond in hw1[9:6] const std::uint32_t cond=(hw1>>6)&0xf; if(cond<0xe){ const std::uint32_t imm11b=hw2&0x7ff, imm6=hw1&0x3f, j1b=(hw2>>13)&1, j2b=(hw2>>11)&1, sb=(hw1>>10)&1; const std::uint32_t imm=(sb<<20)|(j2b<<19)|(j1b<<18)|(imm6<<12)|(imm11b<<1); auto t=rel(sign_extend(imm,21)); auto in=thumb_base(p,b,4,"b.w"); in.is_branch=true; in.is_conditional=true; in.branch_targets.push_back(t); in.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)}); return in; } } } auto in=thumb_base(p,b,4,".inst",0.30); in.operands.push_back({Operand::Kind::Immediate,hex((std::uint32_t(hw1)<<16)|hw2),std::int64_t((std::uint32_t(hw1)<<16)|hw2)}); return in; } out_len=2; if(hw1==0xbf00) return thumb_base(p,b,2,"nop"); if((hw1&0xff00)==0x4700){ const bool link=(hw1&0x0080)!=0; const std::uint32_t rm=(hw1>>3)&0xf; // BX/BLX Rm auto in=thumb_base(p,b,2,link?"blx":"bx"); if(link)in.is_call=true;else in.is_branch=true; in.is_indirect=true; if(!link&&rm==14)in.is_return=true; return in; } if((hw1&0xfe00)==0xbc00&&(hw1&0x0100)){auto in=thumb_base(p,b,2,"pop");in.is_return=true;in.is_indirect=true;return in;} // POP {..,pc} -> return (check before PUSH mask) if((hw1&0xfe00)==0xb400){auto in=thumb_base(p,b,2,"push");return in;} // PUSH {reglist}/{..,lr} if((hw1&0xfe00)==0xbc00){auto in=thumb_base(p,b,2,"pop");return in;} // POP {reglist} (no pc) if((hw1&0xf000)==0xd000){ const std::uint32_t cond=(hw1>>8)&0xf; // B (T1), imm8 if(cond==0xe){auto in=thumb_base(p,b,2,".inst",0.30);return in;} // 0xDE = permanently UNDEFINED if(cond==0xf){auto in=thumb_base(p,b,2,"svc");return in;} // 0xDF = SVC, not a branch auto t=rel(sign_extend(hw1&0xff,8)*2); auto in=thumb_base(p,b,2,"b"); in.is_branch=true; in.is_conditional=true; in.branch_targets.push_back(t); in.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)}); return in; } if((hw1&0xf800)==0xe000){ auto t=rel(sign_extend(hw1&0x7ff,11)*2); // B (T2) unconditional, imm11 auto in=thumb_base(p,b,2,"b"); in.is_branch=true; in.branch_targets.push_back(t); in.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)}); return in; } if((hw1&0xf500)==0xb100){ const std::uint32_t i5=((hw1>>9)&1), imm5=(hw1>>3)&0x1f; // CBZ/CBNZ, positive imm only auto t=std::uint64_t(std::int64_t(p)+4+((i5<<6)|(imm5<<1))); auto in=thumb_base(p,b,2,(hw1&0x0800)?"cbnz":"cbz"); in.is_branch=true; in.is_conditional=true; in.branch_targets.push_back(t); in.operands.push_back({Operand::Kind::Relative,hex(t),std::int64_t(t)}); return in; } auto in=thumb_base(p,b,2,".inst",0.30); in.operands.push_back({Operand::Kind::Immediate,hex(hw1),hw1}); return in; } } std::vector Decoder::decode(const Artifact& a,std::uint64_t address,std::size_t length) const { return decode(a,address,length,DecodeMode::Auto); } std::vector Decoder::decode(const Artifact& a,std::uint64_t address,std::size_t length,DecodeMode mode) const { std::vector out;const auto& b=a.bytes();std::size_t p=static_cast(address); if(p>=b.size())return out;const auto end=std::min(b.size(),p+length); if(a.architecture()==Architecture::ARM64){ for(;p+4<=end;p+=4){auto i=decode_a64(b,p);i.text=render_instruction(i);out.push_back(std::move(i));} for(;pstd::uint64_t{ for(const auto& s:a.interfaces().sections) if(s.file_size&&off>=s.file_offset&&offCodeKind{ CodeKind k = arm_thumb_default?CodeKind::Thumb:CodeKind::Arm; if(mode==DecodeMode::Auto && !maps.empty()){ const std::uint64_t va=file_to_vaddr(off); for(const auto& m:maps){ if(m.address<=va) k=m.kind; else break; } } return k; }; while(pend)break; std::size_t len=2; auto i=decode_thumb(b,p,end,len); if(len==0)len=2; i.text=render_instruction(i); out.push_back(std::move(i)); p+=len; continue; } if(p+4>end)break; auto i=decode_a32(b,p); i.text=render_instruction(i); out.push_back(std::move(i)); p+=4; } for(;pconst char*{ switch(op&0x38){case 0x00:return "add";case 0x08:return "or";case 0x10:return "adc";case 0x18:return "sbb"; case 0x20:return "and";case 0x28:return "sub";case 0x30:return "xor";case 0x38:return "cmp";}return "alu";}; while(p=0x40&&c<=0x4f){have_prefix=true;rex_w=(c&0x08)!=0;++pfx; /*REX is the last prefix before the opcode*/ break;} break; } const std::size_t o=start+pfx; // opcode offset after any prefixes if(o>=end){ i=base(b,start,"db",0.25); i.operands.push_back({Operand::Kind::Immediate,hex(b[start]),b[start]}); i.bytes.assign(b.begin()+start,b.begin()+std::min(end,start+1)); mark_relocation(a,i); out.push_back(std::move(i)); p=start+1; continue; } const std::uint8_t op=b[o]; const bool wide=mode64&&rex_w; // REX.W selects 64-bit operand size for reg names auto emit=[&](const std::string& m,double c=0.80){Instruction x;x.address=start;x.bytes.push_back(b[start]);x.mnemonic=m;x.provenance={start,start,"stage4-x86",c};return x;}; auto consume=[&](std::size_t op_len){ n=pfx+op_len; }; // total length = prefixes + opcode-relative length if(op==0x90){i=emit("nop");consume(1);} else if(op==0xcc){i=emit("int3");consume(1);} else if(op==0xf4){i=emit("hlt");i.is_return=false;consume(1);} else if(op==0xc9){i=emit("leave");consume(1);} else if(op==0x98){i=emit(wide?"cdqe":"cwde");consume(1);} else if(op==0x99){i=emit(wide?"cqo":"cdq");consume(1);} else if(op>=0x50&&op<=0x5f){i=emit(op<0x58?"push":"pop");i.operands.push_back({Operand::Kind::Register,reg_name(op&7,mode64),0});consume(1);} else if(op==0x68&&o+4=0x70&&op<=0x7f&&o+1=0x80&&b[o+1]<=0x8f){i=emit("jcc");i.is_branch=true;i.is_conditional=true;consume(6);auto target=std::uint64_t(std::int64_t(start+n)+rel32(b,o+2));i.branch_targets.push_back(target);i.operands.push_back({Operand::Kind::Relative,hex(target),std::int64_t(target)});} else if(op==0xff&&o+1=0xb8&&op<=0xbf){ const std::size_t imm=wide?8:4; if(o+1+imm<=end){i=emit("mov");consume(1+imm);std::uint64_t v=0;for(std::size_t k=0;k