#include "sleela/decompiler/output.hpp" #include #include #include #include #include #include namespace sleela::decompiler { namespace { // --- small formatting helpers ------------------------------------------------------------ std::string sanitize(std::string s) { for (char& c : s) if (!(std::isalnum(static_cast(c)) || c == '_')) c = '_'; if (s.empty() || std::isdigit(static_cast(s.front()))) s = "_" + s; return s; } std::string hex0x(std::uint64_t v) { std::ostringstream s; s << "0x" << std::hex << v; return s.str(); } std::string hexpad(std::uint64_t v, int w) { std::ostringstream s; s << std::hex << std::setw(w) << std::setfill('0') << v; return s.str(); } std::string bytes_hex(const std::vector& b, std::size_t maxn = 10) { std::ostringstream s; std::size_t n = std::min(b.size(), maxn); for (std::size_t i = 0; i < n; ++i) { if (i) s << ' '; s << hexpad(b[i], 2); } if (b.size() > maxn) s << " ..."; return s.str(); } std::string guard_macro(const std::string& base) { std::string g = "SLECOMPILER_" + sanitize(base) + "_H"; for (char& c : g) c = static_cast(std::toupper(static_cast(c))); return g; } std::string arch_name(Architecture a) { switch (a) { case Architecture::X86: return "x86"; case Architecture::X86_64: return "x86-64"; case Architecture::ARM: return "ARM (A32/Thumb)"; case Architecture::ARM64: return "AArch64 (ARM64)"; default: return "unknown"; } } std::string format_name(Format f) { switch (f) { case Format::ELF: return "ELF"; case Format::PE: return "PE/COFF"; case Format::MachO: return "Mach-O"; case Format::GNUArchive: return "GNU archive"; case Format::Raw: return "raw"; default: return "unknown"; } } // Confidence -> evidence word, so a reviewer can weigh each line. const char* evidence_word(double c) { if (c >= 0.90) return "observed"; if (c >= 0.75) return "decoded"; if (c >= 0.40) return "inferred"; return "unknown"; } // A banner carried by every artifact we emit, establishing provenance up front. // `top`/`bot` are the rule lines; `mid` is the per-line comment prefix (e.g. " *", "//"). void banner(std::ostream& out, const Artifact& a, const char* top, const char* mid, const char* bot, const char* title) { out << top << "\n" << mid << " " << title << "\n" << mid << "\n" << mid << " Generated by Slecompiler (MEARVK LLC). Evidence-derived reconstruction;\n" << mid << " NOT a guarantee of the original source. Recovered declarations preserve\n" << mid << " provenance and distinguish observed evidence from inference.\n" << mid << "\n" << mid << " input : " << a.name() << "\n" << mid << " format : " << format_name(a.format()) << "\n" << mid << " arch : " << arch_name(a.architecture()) << "\n" << mid << " sha256 : " << a.sha256() << "\n" << bot << "\n\n"; } // Render the per-function evidence block (instruction table + CFG note) as line comments. // `lc` is the full line-comment lead (indent + comment marker) for the target language, so // every emitted evidence line is itself a valid comment in that language. void function_evidence(std::ostream& out, const std::string& lc, const Symbol& f, const std::vector& ins, const DecompilationOptions& opt) { // Collect the instructions that belong to this function window (>= f.address). std::vector body; for (const auto& i : ins) if (i.address >= f.address) body.push_back(&i); std::sort(body.begin(), body.end(), [](const Instruction* x, const Instruction* y){ return x->address < y->address; }); // Trim at the first return so the table stays tight around the function. std::size_t count = body.size(); for (std::size_t k = 0; k < body.size(); ++k) { if (body[k]->is_return) { count = k + 1; break; } } if (opt.emit_cfg_summary) { std::size_t branches = 0, calls = 0, rets = 0; for (std::size_t k = 0; k < count; ++k) { branches += body[k]->is_branch; calls += body[k]->is_call; rets += body[k]->is_return; } out << lc << "control flow: " << count << " insn, " << branches << " branch, " << calls << " call, " << rets << " return\n"; } if (opt.emit_instruction_evidence && count) { out << lc << "evidence (address | bytes | instruction | basis):\n"; for (std::size_t k = 0; k < count && k < 64; ++k) { const auto& i = *body[k]; std::ostringstream row; row << lc << " " << hexpad(i.address, 8) << " " << std::left << std::setw(23) << bytes_hex(i.bytes) << " " << std::left << std::setw(28) << (i.text.empty() ? i.mnemonic : i.text) << " " << evidence_word(i.provenance.confidence); out << row.str() << "\n"; } if (count > 64) out << lc << " ... (" << (count - 64) << " more)\n"; } } // Find a lifted SLIR function matching an entry address. const Function* lifted_for(const Module* mod, std::uint64_t address) { if (!mod) return nullptr; for (const auto& f : mod->functions) if (f.address == address) return &f; return nullptr; } // Render a function's lifted SLIR statements, indented by `ind`. Returns true if it wrote // a body, false if there was nothing lifted (caller then emits the fallback note). bool lifted_body(std::ostream& out, const std::string& ind, const Function* f, const std::string& comment_prefix = "") { if (!f) return false; std::size_t stmts = 0; for (const auto& blk : f->blocks) for (const auto& o : blk.operations) if (!o.text.empty()) ++stmts; if (!stmts) return false; for (const auto& blk : f->blocks) for (const auto& o : blk.operations) if (!o.text.empty()) out << ind << comment_prefix << o.text << "\n"; return true; } // --- C / C++ ------------------------------------------------------------------------------ std::string emit_c_like(const Artifact& a, const std::vector& ins, const std::vector& funcs, const DecompilationOptions& opt, bool cpp, const Module* mod = nullptr) { std::ostringstream out; banner(out, a, "/* ----------------------------------------------------------------------- */", " *", " */", cpp ? "Slecompiler reconstruction (C++)" : "Slecompiler reconstruction (C)"); const std::string header = sanitize(opt.source_name) + (cpp ? ".hpp" : ".h"); out << "#include \"" << header << "\"\n\n"; if (cpp) out << "#include \n#include \n\nnamespace slecompiler {\n\n"; else out << "#include \n#include \n\n"; if (funcs.empty()) { out << "/**\n * @brief Analysis window with no recovered function boundary.\n" << " * @note Instruction evidence is retained below for review.\n */\n"; out << "void slecompiler_decompiled(void) {\n"; function_evidence(out, " // ", {"window", ins.empty() ? 0 : ins.front().address, false, {}}, ins, opt); out << "}\n"; } for (const auto& f : funcs) { out << "/**\n"; out << " * @brief Recovered native function `" << f.name << "`.\n"; out << " * @note Entry " << hex0x(f.address) << "; " << evidence_word(f.provenance.confidence) << " evidence.\n"; out << " */\n"; out << "void " << sanitize(f.name) << "(void) {\n"; if (!lifted_body(out, " ", lifted_for(mod, f.address))) out << " /* Body not yet lifted to statements; see evidence below. */\n"; out << "\n"; function_evidence(out, " // ", f, ins, opt); out << "}\n\n"; } if (cpp) out << "} // namespace slecompiler\n"; return out.str(); } std::string emit_c_header(const Artifact& a, const std::vector& funcs, const DecompilationOptions& opt, bool cpp) { std::ostringstream out; banner(out, a, "/* ----------------------------------------------------------------------- */", " *", " */", cpp ? "Slecompiler reconstruction header (C++)" : "Slecompiler reconstruction header (C)"); const std::string g = guard_macro(opt.source_name); out << "#ifndef " << g << "\n#define " << g << "\n\n"; if (cpp) out << "#include \n\nnamespace slecompiler {\n\n"; else out << "#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n"; if (funcs.empty()) out << "/* No function boundary was recovered for the selected window. */\n"; for (const auto& f : funcs) { out << "/** Recovered native function `" << f.name << "` (entry " << hex0x(f.address) << ", " << evidence_word(f.provenance.confidence) << "). */\n"; out << "void " << sanitize(f.name) << "(void);\n\n"; } if (cpp) out << "} // namespace slecompiler\n"; else out << "#ifdef __cplusplus\n}\n#endif\n"; out << "\n#endif /* " << g << " */\n"; return out.str(); } // --- Java --------------------------------------------------------------------------------- std::string emit_java(const Artifact& a, const std::vector& ins, const std::vector& funcs, const DecompilationOptions& opt, const Module* mod = nullptr) { std::ostringstream out; banner(out, a, "// ----------------------------------------------------------------------- //", "//", "// ----------------------------------------------------------------------- //", "Slecompiler reconstruction (Java)"); const std::string cls = sanitize(opt.source_name); out << "public final class " << cls << " {\n"; out << " private " << cls << "() { /* static holder */ }\n\n"; for (const auto& f : funcs) { out << " /**\n"; out << " * Recovered native function {@code " << f.name << "}.\n"; out << " *

Entry " << hex0x(f.address) << "; " << evidence_word(f.provenance.confidence) << " evidence.\n"; out << " */\n"; out << " public static void " << sanitize(f.name) << "() {\n"; if (!lifted_body(out, " ", lifted_for(mod, f.address))) out << " // Body not yet lifted to statements; see evidence below.\n"; out << "\n"; function_evidence(out, " // ", f, ins, opt); out << " }\n\n"; } if (funcs.empty()) { out << " public static void decompiled() {\n"; function_evidence(out, " // ", {"window", ins.empty() ? 0 : ins.front().address, false, {}}, ins, opt); out << " }\n"; } out << "}\n"; return out.str(); } // --- Sleela ------------------------------------------------------------------------------- std::string emit_sleela(const Artifact& a, const std::vector& ins, const std::vector& funcs, const DecompilationOptions& opt, const Module* mod = nullptr) { std::ostringstream out; banner(out, a, "< ----------------------------------------------------------------------- >", "<", "< ----------------------------------------------------------------------- >", "Slecompiler reconstruction (Sleela)"); out << "module " << sanitize(opt.source_name) << " {\n"; for (const auto& f : funcs) { out << " << recovered native function " << f.name << " @ " << hex0x(f.address) << " (" << evidence_word(f.provenance.confidence) << ") >>\n"; out << " function " << sanitize(f.name) << "() {\n"; // Lifted statements are shown as Sleela `<` annotations (the lift targets a neutral // pseudo-C form, not Sleela grammar), so the emitted module stays lexically valid. if (!lifted_body(out, " < ", lifted_for(mod, f.address))) out << " << body not yet lifted to statements; see evidence below >>\n"; out << "\n"; function_evidence(out, " < ", f, ins, opt); out << " }\n\n"; } if (funcs.empty()) { out << " function decompiled() {\n"; function_evidence(out, " < ", {"window", ins.empty() ? 0 : ins.front().address, false, {}}, ins, opt); out << " }\n"; } out << "}\n"; return out.str(); } } // namespace std::string SourceEmitter::language_name(SourceLanguage l) { switch (l) { case SourceLanguage::Java: return "java"; case SourceLanguage::Sleela: return "sleela"; case SourceLanguage::C: return "c"; case SourceLanguage::CPlusPlus: return "c++"; } return "unknown"; } std::string SourceEmitter::extension(SourceLanguage l) { switch (l) { case SourceLanguage::Java: return ".java"; case SourceLanguage::Sleela: return ".sleela"; case SourceLanguage::C: return ".c"; case SourceLanguage::CPlusPlus: return ".cpp"; } return ".txt"; } std::string SourceEmitter::header_extension(SourceLanguage l) { switch (l) { case SourceLanguage::C: return ".h"; case SourceLanguage::CPlusPlus: return ".hpp"; case SourceLanguage::Java: return ".java"; case SourceLanguage::Sleela: return ".sleela"; } return ".h"; } std::string SourceEmitter::emit(const Artifact& a, const std::vector& ins, const ControlFlowGraph& cfg, const std::vector& funcs, const DecompilationOptions& options) { (void)cfg; switch (options.language) { case SourceLanguage::Java: return emit_java(a, ins, funcs, options); case SourceLanguage::Sleela: return emit_sleela(a, ins, funcs, options); case SourceLanguage::C: return emit_c_like(a, ins, funcs, options, false); case SourceLanguage::CPlusPlus: return emit_c_like(a, ins, funcs, options, true); } throw std::invalid_argument("unsupported source output language"); } std::string SourceEmitter::emit(const Artifact& a, const std::vector& ins, const ControlFlowGraph& cfg, const std::vector& funcs, const Module& module, const DecompilationOptions& options) { (void)cfg; switch (options.language) { case SourceLanguage::Java: return emit_java(a, ins, funcs, options, &module); case SourceLanguage::Sleela: return emit_sleela(a, ins, funcs, options, &module); case SourceLanguage::C: return emit_c_like(a, ins, funcs, options, false, &module); case SourceLanguage::CPlusPlus: return emit_c_like(a, ins, funcs, options, true, &module); } throw std::invalid_argument("unsupported source output language"); } std::string SourceEmitter::emit_header(const Artifact& a, const std::vector& funcs, const DecompilationOptions& options) { switch (options.language) { case SourceLanguage::C: return emit_c_header(a, funcs, options, false); case SourceLanguage::CPlusPlus: return emit_c_header(a, funcs, options, true); case SourceLanguage::Java: { std::vector none; return emit_java(a, none, funcs, options); } case SourceLanguage::Sleela: { std::vector none; return emit_sleela(a, none, funcs, options); } } throw std::invalid_argument("unsupported header output language"); } } // namespace sleela::decompiler