XeXe

XeXe is a desktop type-inspection tool for ELF binaries with MIPS/ECOFF .mdebug debug information. It parses debug type metadata, presents discovered types in a searchable list, and renders selected types as read-only pseudo-C++ with syntax highlighting.

The current focus is PlayStation 2-era GCC/STABS/ECOFF debug data, including structures, unions, enums, typedefs, arrays, member fields, static fields, member functions, virtual functions, and inheritance.

Features

• ELF loading with .mdebug / ECOFF symbol table support.
• STABS type import through the vendored Chaos Compiler Collection (ccc).
• Type list with filtering/search support.
• Right-side type detail view with:
  • basic metadata: name, kind, size in hexadecimal bytes;
  • generated pseudo-C++ representation;
  • C++ syntax highlighting;
  • read-only selectable code text;
  • display options for static fields, access specifiers, regular methods, and virtual methods.
• Pseudo-C++ generation for:
  • enums;
  • structs/unions;
  • inheritance declarations;
  • instance and static fields;
  • regular, static, and virtual member methods;
  • typedefs, arrays, pointers, and references.
• Built-in MCP (Model Context Protocol) server over HTTP for external tooling:
  • start/stop from the MCP toolbar button, configurable host/port and optional bearer token;
  • tools: search_types, search_globals, search_functions, find_global_by_address, find_globals_by_type.

Technology Stack

• Language: C++20
• UI: Qt 6 Quick / QML / Qt Quick Controls 2
• Build system: CMake
• Concurrency: Qt Concurrent
• Debug type parsing: vendored Chaos Compiler Collection (third_party/ccc)
• Target debug formats: ELF, MIPS/ECOFF .mdebug, STABS
• Platform used during development: Windows / MSVC / Qt 6.7

Repository Layout

qml/                  QML user interface
src/core/             Reusable core: ELF loading, type import, C++ generation
src/models/           Qt list model for types
src/viewmodels/       UI-facing application state and async analysis
src/mcp/              MCP server: HTTP transport and JSON-RPC tool handlers
third_party/ccc/      Vendored Chaos Compiler Collection, MIT licensed
rnd/                  Ignored local reverse-engineering experiments
Examples/             Ignored local sample binaries/dumps

Building

Requirements:

• CMake 3.20 or newer
• C++20-capable compiler
• Qt 6.7 or newer with Quick, QuickControls2, and Concurrent

Example:

cmake -S . -B build
cmake --build build --config Release

On Windows, the build deploys Qt runtime dependencies for the produced executable via the configured Qt deployment tooling.

The reusable parsing and pseudo-C++ generation layer is built as the xexe_core static library. The Qt application links against that library and keeps UI-specific pieces, such as QML models and syntax highlighting, in the application layer.

Usage

1. Launch XeXe.
2. Open an ELF file containing MIPS/ECOFF .mdebug information.
3. Select a type from the left-hand list.
4. Inspect metadata and generated pseudo-C++ in the right-hand panel.
5. Use the Options panel above the code view to toggle generated output details.

MCP server

1. Click the MCP button in the toolbar (it turns green while the server is running).
2. Configure host (default 127.0.0.1), port (default 12555) and an optional access token. Use make random to generate a token with the xexemcp- prefix. When the token is empty, no authorization is required; otherwise clients must send Authorization: Bearer <token>.
3. Press Run to start the server, Stop to shut it down. If the port is busy, an error message box is shown.

The endpoint is http://<host>:<port>/mcp (Streamable HTTP transport, JSON-RPC 2.0). Supported methods: initialize, ping, tools/list, tools/call.

Third-Party Components

This project vendors parts of Chaos Compiler Collection (ccc) under third_party/ccc.

ccc is licensed under the MIT License and is used for robust parsing of MIPS/ECOFF .mdebug and STABS debug type information. See THIRD_PARTY_NOTICES.md and third_party/ccc/License.txt for details.

License

The main XeXe project code is proprietary and all rights are reserved unless a separate written license agreement says otherwise. See LICENSE.

Third-party components remain under their respective licenses.