> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

Inside Ghidra: How the NSA Built a Decompiler That Understands 50+ CPU Architectures

[ View on GitHub ]

Inside Ghidra: How the NSA Built a Decompiler That Understands 50+ CPU Architectures

Hook

The NSA released a reverse engineering tool that handles obscure embedded processors better than $4,000 commercial software—all because they invented a domain-specific language most developers have never heard of.

Context

Before Ghidra's 2019 public release, reverse engineering tools faced an architectural problem: every CPU architecture required custom decompiler logic. IDA Pro's Hex-Rays decompiler worked beautifully on x86 but handled ARM poorly and basically ignored exotic architectures like Renesas V850 or NEC 78K. Binary Ninja and similar tools faced the same constraint—building a decompiler that transforms assembly into readable C-like pseudocode meant writing architecture-specific pattern matching and dataflow analysis for each processor family.

This created a reverse engineering ecosystem divided by architecture: security researchers analyzing Intel firmware used different tools than embedded systems engineers debugging automotive ECUs or IoT researchers tearing apart router firmware. The NSA, tasked with analyzing software across every conceivable platform from Windows malware to foreign weapons systems, needed something different. They built Ghidra around a radical idea: separate instruction decoding from analysis by creating an intermediate representation abstract enough to work universally, but detailed enough to preserve semantic meaning. The result is SLEIGH, a processor specification language that compiles architecture definitions into P-CODE, enabling a single decompiler implementation to produce quality pseudocode for everything from 6502 processors to modern ARM64.

Technical Insight

Core Engine

P-CODE IR

Transactions

Events

P-CODE Stream

Pseudocode

P-CODE Stream

Analysis Results

Shared State

Binary File

SLEIGH Processor

Program Database

Transactional Storage

Plugin Event Bus

C++ Decompiler via JNI

Swing UI

Pluggable Analyzers

Extension Plugins

Multi-user Server

System architecture — auto-generated

SLEIGH is essentially a compiler for instruction set architectures. Instead of hardcoding disassembly logic in Java or C++, you write declarative specifications describing how instructions decode and what they do. Here's a simplified example of how SLEIGH defines an ARM ADD instruction:

:ADD^s Rd, Rn, Rm is $(AMODE)=0 & opcode=0x4 & s & Rn & Rd & Rm {
    Rd = Rn + Rm;
    $(ZFLAG) = (Rd == 0);
    $(NFLAG) = (Rd s< 0);
}

The syntax before the opening brace defines the instruction encoding—bit patterns that match this specific instruction variant. The body describes the semantic behavior in P-CODE operations. When Ghidra loads a binary, it uses the compiled SLEIGH specification to translate machine code into P-CODE, a register-transfer language with operations like INT_ADD, LOAD, STORE, and BRANCH. This P-CODE feeds into the decompiler, emulator, and analysis engines without any architecture-specific code paths.

The decompiler itself is C++ code wrapped via JNI that operates entirely on P-CODE. It performs SSA transformation, aggressive constant propagation, and dead code elimination to reconstruct control flow. Because it's architecture-agnostic, adding support for a new processor means writing a SLEIGH specification—not reimplementing decompiler logic. This is why Ghidra handles exotic embedded chips that commercial tools ignore: someone just needs to write the specification, not rebuild the entire analysis stack.

Ghidra's Program database is where architectural sophistication meets practical engineering. It's a transactional document store implemented in Java that tracks every piece of analysis—disassembly, function boundaries, data types, cross-references, and user annotations. Here's how you'd programmatically add a function and propagate type information via Ghidra's scripting API:

import ghidra.program.model.symbol.*;
import ghidra.program.model.data.*;

Address entryPoint = currentProgram.getAddressFactory().getAddress("0x00401000");
FunctionManager funcMgr = currentProgram.getFunctionManager();

// Create function and set signature
Function func = funcMgr.createFunction("parse_header", entryPoint, 
    new AddressSet(entryPoint, entryPoint.add(0x200)), SourceType.USER_DEFINED);

// Define parameter types
Structure headerStruct = new StructureDataType("header_t", 0);
headerStruct.add(new DWordDataType(), "magic", null);
headerStruct.add(new WordDataType(), "version", null);

Parameter[] params = new Parameter[] {
    new ParameterImpl("hdr", new PointerDataType(headerStruct), currentProgram)
};

func.updateFunction(null, new ReturnParameterImpl(new IntegerDataType(), currentProgram),
    params, Function.FunctionUpdateType.DYNAMIC_STORAGE_ALL_PARAMS, true, SourceType.USER_DEFINED);

This code demonstrates Ghidra's type system in action. When you define header_t with specific fields and assign it as a function parameter, the decompiler propagates that information through dataflow analysis. Every access to hdr->magic in the pseudocode will now show field names instead of raw offsets, and the type inference engine will propagate the struct layout to any functions that receive this pointer.

The transactional nature of the Program database enables Ghidra's collaborative server. Every change—renaming a variable, retyping a function, adding a comment—is a versioned transaction. Multiple analysts can work on the same binary simultaneously, with the server merging changes and flagging conflicts when two people modify the same entity. This solved the "emailing .idb files back and forth" problem that plagued teams using IDA Pro for years. You can also query this transaction log to understand how analysis evolved, effectively time-traveling through your reverse engineering session.

The P-CODE emulator deserves special attention because it demonstrates the power of Ghidra's intermediate representation. Since every architecture compiles to P-CODE, the emulator works universally. You can write a single emulation script that works identically on ARM firmware and x86 malware:

from ghidra.app.emulator import EmulatorHelper

emuHelper = EmulatorHelper(currentProgram)
emuHelper.writeRegister("R0", 0x1000)  # Set up initial state
emuHelper.writeRegister("R1", 0x42)

# Execute function at current address
success = emuHelper.run(currentAddress, None, monitor)

if success:
    result = emuHelper.readRegister("R0")
    print("Function returned: 0x{:x}".format(result))

This same script works on any architecture—just change the register names. Commercial tools require architecture-specific debugging APIs, but Ghidra's P-CODE abstraction means the emulator, decompiler, and analysis engines all speak the same language. This is particularly powerful for automated malware analysis where you need to emulate suspicious functions across diverse samples without architecture-specific handling code.

Gotcha

Ghidra's performance is legitimately painful for large binaries. Initial auto-analysis on a 50MB executable can take 30+ minutes on a modern workstation, and memory consumption regularly exceeds 16GB for complex programs. The JVM-based architecture and transactional database create overhead that native tools avoid—IDA Pro and Binary Ninja will complete similar analysis in minutes. This isn't a minor inconvenience; it fundamentally changes your workflow. Real-time incident response becomes impractical when loading a firmware dump requires waiting through lunch.

The Swing-based UI feels dated because it is. Keyboard shortcuts are inconsistent, theming doesn't respect OS preferences, and the whole interface has the unmistakable aesthetic of mid-2000s Java applications. Binary Ninja's modern UI makes Ghidra look actively hostile to new users. More frustrating are missing features you'd expect from an NSA tool: there's no built-in binary diffing for comparing two versions of an executable, no integrated patch analysis, and collaboration requires setting up dedicated server infrastructure rather than simple file sharing. The decompiler quality is also uneven—x86 and ARM results are excellent, but MIPS and PowerPC often produce confusing pseudocode, and truly exotic architectures require manually tweaking SLEIGH specifications that assume deep knowledge of compiler internals.

Verdict

Use if: You're analyzing non-x86 architectures (especially embedded systems, IoT devices, or automotive firmware), building automated malware analysis pipelines that need scriptable headless operation, working on teams requiring true collaborative reverse engineering with conflict resolution, or simply can't justify $4,000 per seat for commercial tools. Ghidra's SLEIGH-based architecture support and transactional database solve problems IDA Pro doesn't acknowledge, and its free license means you can legally deploy analysis automation at scale. Skip if: You're primarily reverse engineering mainstream x86/x64 Windows or Linux software as an individual analyst, need responsive UI for iterative analysis sessions, work with binaries over 100MB regularly, or require live debugging integration. The Java-induced performance overhead and dated interface create friction that outweighs technical sophistication unless you specifically need collaborative features or exotic architecture support—Binary Ninja or IDA Pro will simply feel better for daily use.