Struct Decompilation 

#[non_exhaustive]
pub struct Decompilation {
    pub nef: NefFile,
    pub manifest: Option<ContractManifest>,
    pub warnings: Vec<String>,
    pub instructions: Vec<Instruction>,
    pub cfg: Cfg,
    pub call_graph: CallGraph,
    pub xrefs: Xrefs,
    pub types: TypeInfo,
    pub pseudocode: Option<String>,
    pub high_level: Option<String>,
    pub csharp: Option<String>,
    pub ssa: Option<SsaForm>,
}

Result of a successful decompilation run.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

nef: NefFile

Parsed NEF container.

manifest: Option<ContractManifest>

Optional parsed contract manifest.

warnings: Vec<String>

Non-fatal warnings emitted during disassembly or rendering.

instructions: Vec<Instruction>

Disassembled instruction stream from the NEF script.

cfg: Cfg

Control flow graph built from the instruction stream.

call_graph: CallGraph

Best-effort call graph extracted from the instruction stream.

xrefs: Xrefs

Best-effort cross-reference information for locals/args/statics.

types: TypeInfo

Best-effort primitive/collection type inference.

pseudocode: Option<String>

Optional rendered pseudocode output.

high_level: Option<String>

Optional rendered high-level output.

csharp: Option<String>

Optional rendered C# output.

ssa: Option<SsaForm>

SSA form of the control flow graph (computed lazily).

Implementations

impl Decompilation

pub fn cfg_to_dot(&self) -> String

Get the control flow graph as DOT format for visualization.

The DOT output can be rendered using Graphviz or similar tools.

Example

let decompilation = decompiler.decompile_bytes(&nef_bytes)?;
let dot = decompilation.cfg_to_dot();
std::fs::write("cfg.dot", dot)?;
// Then run: dot -Tpng cfg.dot -o cfg.png

pub fn ssa(&self) -> Option<&SsaForm>

Get or compute the SSA form of this decompilation.

SSA form is computed lazily on first call and cached for subsequent calls.

Returns

Option<&SsaForm> - The SSA form, or None if CFG has no blocks.

Examples

let decompilation = decompiler.decompile_bytes(&nef_bytes)?;
if let Some(ssa) = decompilation.ssa() {
    println!("SSA Stats: {}", ssa.stats());
    println!("{}", ssa.render());
}

pub fn compute_ssa(&mut self)

Compute SSA form if not already computed.

This is a convenience method for computing SSA form lazily. After calling this, ssa() will return Some(...).

pub fn ssa_stats(&self) -> Option<String>

Get SSA statistics if SSA form is available.

Returns

Option<String> - Formatted statistics string, or None if SSA not computed.

pub fn render_ssa(&self) -> Option<String>

Render SSA form if available.

Returns

Option<String> - Rendered SSA code, or None if SSA not computed.

Trait Implementations

impl Clone for Decompilation

fn clone(&self) -> Decompilation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Decompilation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.