Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.
Initial Ghidrust commit
oofz908192fcc281
diff --git a/.gitignore b/.gitignorenew file mode 100644index 0000000..f22c32d--- /dev/null+++ b/.gitignore@@ -0,0 +1,24 @@+# Build+/target+**/target+*.pdb++# IDE / local tooling+.idea/+.vscode/+.grok/+terminals/+mcps/++# OS+.DS_Store+Thumbs.db++# Local RE / bench artifacts+*.gdecomp+*_metrics.log+re_metrics.log++# Local development notes (parity tracking, roadmaps, private benches)+# Not published — research/metrics stay in docs/+dev/diff --git a/Cargo.lock b/Cargo.locknew file mode 100644index 0000000..1c2816d--- /dev/null+++ b/Cargo.lock@@ -0,0 +1,4492 @@+# This file is automatically @generated by Cargo.+# It is not intended for manual editing.+version = 4++[[package]]+name = "ab_glyph"+version = "0.2.32"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2"+dependencies = [+ "ab_glyph_rasterizer",+ "owned_ttf_parser",+]++[[package]]+name = "ab_glyph_rasterizer"+version = "0.1.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"++[[package]]+name = "accesskit"+version = "0.17.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d3d3b8f9bae46a948369bc4a03e815d4ed6d616bd00de4051133a5019dc31c5a"++[[package]]+name = "accesskit_atspi_common"+version = "0.10.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7c5dd55e6e94949498698daf4d48fb5659e824d7abec0d394089656ceaf99d4f"+dependencies = [+ "accesskit",+ "accesskit_consumer",+ "atspi-common",+ "serde",+ "thiserror 1.0.69",+ "zvariant 4.2.0",+]++[[package]]+name = "accesskit_consumer"+version = "0.26.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f47983a1084940ba9a39c077a8c63e55c619388be5476ac04c804cfbd1e63459"+dependencies = [+ "accesskit",+ "hashbrown 0.15.5",+ "immutable-chunkmap",+]++[[package]]+name = "accesskit_macos"+version = "0.18.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7329821f3bd1101e03a7d2e03bd339e3ac0dc64c70b4c9f9ae1949e3ba8dece1"+dependencies = [+ "accesskit",+ "accesskit_consumer",+ "hashbrown 0.15.5",+ "objc2 0.5.2",+ "objc2-app-kit 0.2.2",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "accesskit_unix"+version = "0.13.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fcee751cc20d88678c33edaf9c07e8b693cd02819fe89053776f5313492273f5"+dependencies = [+ "accesskit",+ "accesskit_atspi_common",+ "async-channel",+ "async-executor",+ "async-task",+ "atspi",+ "futures-lite",+ "futures-util",+ "serde",+ "zbus 4.4.0",+]++[[package]]+name = "accesskit_windows"+version = "0.24.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "24fcd5d23d70670992b823e735e859374d694a3d12bfd8dd32bd3bd8bedb5d81"+dependencies = [+ "accesskit",+ "accesskit_consumer",+ "hashbrown 0.15.5",+ "paste",+ "static_assertions",+ "windows",+ "windows-core",+]++[[package]]+name = "accesskit_winit"+version = "0.23.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6a6a48dad5530b6deb9fc7a52cc6c3bf72cdd9eb8157ac9d32d69f2427a5e879"+dependencies = [+ "accesskit",+ "accesskit_macos",+ "accesskit_unix",+ "accesskit_windows",+ "raw-window-handle",+ "winit",+]++[[package]]+name = "adler2"+version = "2.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"++[[package]]+name = "ahash"+version = "0.8.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"+dependencies = [+ "cfg-if",+ "getrandom 0.3.4",+ "once_cell",+ "version_check",+ "zerocopy",+]++[[package]]+name = "android-activity"+version = "0.6.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0f2a1bb052857d5dd49572219344a7332b31b76405648eabac5bc68978251bcd"+dependencies = [+ "android-properties",+ "bitflags 2.13.0",+ "cc",+ "jni",+ "libc",+ "log",+ "ndk",+ "ndk-context",+ "ndk-sys 0.6.0+11769913",+ "num_enum",+ "thiserror 2.0.18",+]++[[package]]+name = "android-properties"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04"++[[package]]+name = "android_system_properties"+version = "0.1.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"+dependencies = [+ "libc",+]++[[package]]+name = "arboard"+version = "3.6.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"+dependencies = [+ "clipboard-win",+ "image",+ "log",+ "objc2 0.6.4",+ "objc2-app-kit 0.3.2",+ "objc2-core-foundation",+ "objc2-core-graphics",+ "objc2-foundation 0.3.2",+ "parking_lot",+ "percent-encoding",+ "windows-sys 0.60.2",+ "x11rb",+]++[[package]]+name = "arrayref"+version = "0.3.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"++[[package]]+name = "arrayvec"+version = "0.7.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"++[[package]]+name = "as-raw-xcb-connection"+version = "1.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"++[[package]]+name = "ash"+version = "0.38.0+1.3.281"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f"+dependencies = [+ "libloading",+]++[[package]]+name = "ashpd"+version = "0.11.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d2f3f79755c74fd155000314eb349864caa787c6592eace6c6882dad873d9c39"+dependencies = [+ "async-fs",+ "async-net",+ "enumflags2",+ "futures-channel",+ "futures-util",+ "rand 0.9.5",+ "raw-window-handle",+ "serde",+ "serde_repr",+ "url",+ "wayland-backend",+ "wayland-client",+ "wayland-protocols",+ "zbus 5.17.0",+]++[[package]]+name = "async-broadcast"+version = "0.7.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"+dependencies = [+ "event-listener",+ "event-listener-strategy",+ "futures-core",+ "pin-project-lite",+]++[[package]]+name = "async-channel"+version = "2.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"+dependencies = [+ "concurrent-queue",+ "event-listener-strategy",+ "futures-core",+ "pin-project-lite",+]++[[package]]+name = "async-executor"+version = "1.14.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a"+dependencies = [+ "async-task",+ "concurrent-queue",+ "fastrand",+ "futures-lite",+ "pin-project-lite",+ "slab",+]++[[package]]+name = "async-fs"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5"+dependencies = [+ "async-lock",+ "blocking",+ "futures-lite",+]++[[package]]+name = "async-io"+version = "2.6.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"+dependencies = [+ "autocfg",+ "cfg-if",+ "concurrent-queue",+ "futures-io",+ "futures-lite",+ "parking",+ "polling",+ "rustix 1.1.4",+ "slab",+ "windows-sys 0.61.2",+]++[[package]]+name = "async-lock"+version = "3.4.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"+dependencies = [+ "event-listener",+ "event-listener-strategy",+ "pin-project-lite",+]++[[package]]+name = "async-net"+version = "2.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b948000fad4873c1c9339d60f2623323a0cfd3816e5181033c6a5cb68b2accf7"+dependencies = [+ "async-io",+ "blocking",+ "futures-lite",+]++[[package]]+name = "async-process"+version = "2.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"+dependencies = [+ "async-channel",+ "async-io",+ "async-lock",+ "async-signal",+ "async-task",+ "blocking",+ "cfg-if",+ "event-listener",+ "futures-lite",+ "rustix 1.1.4",+]++[[package]]+name = "async-recursion"+version = "1.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "async-signal"+version = "0.2.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485"+dependencies = [+ "async-io",+ "async-lock",+ "atomic-waker",+ "cfg-if",+ "futures-core",+ "futures-io",+ "rustix 1.1.4",+ "signal-hook-registry",+ "slab",+ "windows-sys 0.61.2",+]++[[package]]+name = "async-task"+version = "4.7.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"++[[package]]+name = "async-trait"+version = "0.1.89"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "atomic-waker"+version = "1.1.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"++[[package]]+name = "atspi"+version = "0.22.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "be534b16650e35237bb1ed189ba2aab86ce65e88cc84c66f4935ba38575cecbf"+dependencies = [+ "atspi-common",+ "atspi-connection",+ "atspi-proxies",+]++[[package]]+name = "atspi-common"+version = "0.6.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1909ed2dc01d0a17505d89311d192518507e8a056a48148e3598fef5e7bb6ba7"+dependencies = [+ "enumflags2",+ "serde",+ "static_assertions",+ "zbus 4.4.0",+ "zbus-lockstep",+ "zbus-lockstep-macros",+ "zbus_names 3.0.0",+ "zvariant 4.2.0",+]++[[package]]+name = "atspi-connection"+version = "0.6.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "430c5960624a4baaa511c9c0fcc2218e3b58f5dbcc47e6190cafee344b873333"+dependencies = [+ "atspi-common",+ "atspi-proxies",+ "futures-lite",+ "zbus 4.4.0",+]++[[package]]+name = "atspi-proxies"+version = "0.6.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a5e6c5de3e524cf967569722446bcd458d5032348554d9a17d7d72b041ab7496"+dependencies = [+ "atspi-common",+ "serde",+ "zbus 4.4.0",+ "zvariant 4.2.0",+]++[[package]]+name = "autocfg"+version = "1.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"++[[package]]+name = "bincode"+version = "1.3.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"+dependencies = [+ "serde",+]++[[package]]+name = "bit-set"+version = "0.8.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"+dependencies = [+ "bit-vec",+]++[[package]]+name = "bit-vec"+version = "0.8.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"++[[package]]+name = "bitflags"+version = "1.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"++[[package]]+name = "bitflags"+version = "2.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"+dependencies = [+ "serde_core",+]++[[package]]+name = "block"+version = "0.1.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"++[[package]]+name = "block-buffer"+version = "0.10.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"+dependencies = [+ "generic-array",+]++[[package]]+name = "block2"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f"+dependencies = [+ "objc2 0.5.2",+]++[[package]]+name = "block2"+version = "0.6.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"+dependencies = [+ "objc2 0.6.4",+]++[[package]]+name = "blocking"+version = "1.6.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"+dependencies = [+ "async-channel",+ "async-task",+ "futures-io",+ "futures-lite",+ "piper",+]++[[package]]+name = "bumpalo"+version = "3.20.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"++[[package]]+name = "bytemuck"+version = "1.25.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d6aedf8ae72766347502cf3cb4f41cf5e9cc37d28bee90f1fdaaae15f9cf9424"+dependencies = [+ "bytemuck_derive",+]++[[package]]+name = "bytemuck_derive"+version = "1.11.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f65693059b6b9c588b9f62fed1cedbf0a8b805631457ea162d68f0de186f3de5"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "byteorder-lite"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"++[[package]]+name = "bytes"+version = "1.12.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"++[[package]]+name = "calloop"+version = "0.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec"+dependencies = [+ "bitflags 2.13.0",+ "log",+ "polling",+ "rustix 0.38.44",+ "slab",+ "thiserror 1.0.69",+]++[[package]]+name = "calloop"+version = "0.14.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4dbf9978365bac10f54d1d4b04f7ce4427e51f71d61f2fe15e3fed5166474df7"+dependencies = [+ "bitflags 2.13.0",+ "polling",+ "rustix 1.1.4",+ "slab",+ "tracing",+]++[[package]]+name = "calloop-wayland-source"+version = "0.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "95a66a987056935f7efce4ab5668920b5d0dac4a7c99991a67395f13702ddd20"+dependencies = [+ "calloop 0.13.0",+ "rustix 0.38.44",+ "wayland-backend",+ "wayland-client",+]++[[package]]+name = "calloop-wayland-source"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "138efcf0940a02ebf0cc8d1eff41a1682a46b431630f4c52450d6265876021fa"+dependencies = [+ "calloop 0.14.4",+ "rustix 1.1.4",+ "wayland-backend",+ "wayland-client",+]++[[package]]+name = "cc"+version = "1.2.67"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e17dd265a7d0f31ef544e1b20e03add05d3b45b491b633b10d67145d2acc1a38"+dependencies = [+ "find-msvc-tools",+ "jobserver",+ "libc",+ "shlex",+]++[[package]]+name = "cfg-if"+version = "1.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"++[[package]]+name = "cfg_aliases"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"++[[package]]+name = "cgl"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0ced0551234e87afee12411d535648dd89d2e7f34c78b753395567aff3d447ff"+dependencies = [+ "libc",+]++[[package]]+name = "clipboard-win"+version = "5.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"+dependencies = [+ "error-code",+]++[[package]]+name = "codespan-reporting"+version = "0.11.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"+dependencies = [+ "termcolor",+ "unicode-width",+]++[[package]]+name = "combine"+version = "4.6.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"+dependencies = [+ "bytes",+ "memchr",+]++[[package]]+name = "concurrent-queue"+version = "2.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"+dependencies = [+ "crossbeam-utils",+]++[[package]]+name = "core-foundation"+version = "0.9.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"+dependencies = [+ "core-foundation-sys",+ "libc",+]++[[package]]+name = "core-foundation"+version = "0.10.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"+dependencies = [+ "core-foundation-sys",+ "libc",+]++[[package]]+name = "core-foundation-sys"+version = "0.8.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"++[[package]]+name = "core-graphics"+version = "0.23.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"+dependencies = [+ "bitflags 1.3.2",+ "core-foundation 0.9.4",+ "core-graphics-types",+ "foreign-types",+ "libc",+]++[[package]]+name = "core-graphics-types"+version = "0.1.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"+dependencies = [+ "bitflags 1.3.2",+ "core-foundation 0.9.4",+ "libc",+]++[[package]]+name = "cpufeatures"+version = "0.2.17"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"+dependencies = [+ "libc",+]++[[package]]+name = "crc32fast"+version = "1.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"+dependencies = [+ "cfg-if",+]++[[package]]+name = "crossbeam-deque"+version = "0.8.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"+dependencies = [+ "crossbeam-epoch",+ "crossbeam-utils",+]++[[package]]+name = "crossbeam-epoch"+version = "0.9.20"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"+dependencies = [+ "crossbeam-utils",+]++[[package]]+name = "crossbeam-utils"+version = "0.8.22"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"++[[package]]+name = "crunchy"+version = "0.2.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"++[[package]]+name = "crypto-common"+version = "0.1.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"+dependencies = [+ "generic-array",+ "typenum",+]++[[package]]+name = "cursor-icon"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f"++[[package]]+name = "digest"+version = "0.10.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"+dependencies = [+ "block-buffer",+ "crypto-common",+]++[[package]]+name = "dispatch"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"++[[package]]+name = "dispatch2"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.6.2",+ "libc",+ "objc2 0.6.4",+]++[[package]]+name = "displaydoc"+version = "0.2.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1ac70aa55017e108007fbaf5aa0f54b021c98f92ff8af59d42eda9da96e3dd4f"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "dlib"+version = "0.5.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a"+dependencies = [+ "libloading",+]++[[package]]+name = "document-features"+version = "0.2.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"+dependencies = [+ "litrs",+]++[[package]]+name = "downcast-rs"+version = "1.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"++[[package]]+name = "dpi"+version = "0.1.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"++[[package]]+name = "ecolor"+version = "0.31.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bc4feb366740ded31a004a0e4452fbf84e80ef432ecf8314c485210229672fd1"+dependencies = [+ "bytemuck",+ "emath",+]++[[package]]+name = "eframe"+version = "0.31.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d0dfe0859f3fb1bc6424c57d41e10e9093fe938f426b691e42272c2f336d915c"+dependencies = [+ "ahash",+ "bytemuck",+ "document-features",+ "egui",+ "egui-wgpu",+ "egui-winit",+ "egui_glow",+ "glow",+ "glutin",+ "glutin-winit",+ "image",+ "js-sys",+ "log",+ "objc2 0.5.2",+ "objc2-app-kit 0.2.2",+ "objc2-foundation 0.2.2",+ "parking_lot",+ "percent-encoding",+ "profiling",+ "raw-window-handle",+ "static_assertions",+ "wasm-bindgen",+ "wasm-bindgen-futures",+ "web-sys",+ "web-time",+ "winapi",+ "windows-sys 0.59.0",+ "winit",+]++[[package]]+name = "egui"+version = "0.31.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "25dd34cec49ab55d85ebf70139cb1ccd29c977ef6b6ba4fe85489d6877ee9ef3"+dependencies = [+ "accesskit",+ "ahash",+ "bitflags 2.13.0",+ "emath",+ "epaint",+ "log",+ "nohash-hasher",+ "profiling",+]++[[package]]+name = "egui-wgpu"+version = "0.31.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d319dfef570f699b6e9114e235e862a2ddcf75f0d1a061de9e1328d92146d820"+dependencies = [+ "ahash",+ "bytemuck",+ "document-features",+ "egui",+ "epaint",+ "log",+ "profiling",+ "thiserror 1.0.69",+ "type-map",+ "web-time",+ "wgpu",+ "winit",+]++[[package]]+name = "egui-winit"+version = "0.31.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7d9dfbb78fe4eb9c3a39ad528b90ee5915c252e77bbab9d4ebc576541ab67e13"+dependencies = [+ "accesskit_winit",+ "ahash",+ "arboard",+ "bytemuck",+ "egui",+ "log",+ "profiling",+ "raw-window-handle",+ "smithay-clipboard",+ "web-time",+ "webbrowser",+ "winit",+]++[[package]]+name = "egui_glow"+version = "0.31.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "910906e3f042ea6d2378ec12a6fd07698e14ddae68aed2d819ffe944a73aab9e"+dependencies = [+ "ahash",+ "bytemuck",+ "egui",+ "glow",+ "log",+ "memoffset",+ "profiling",+ "wasm-bindgen",+ "web-sys",+ "winit",+]++[[package]]+name = "either"+version = "1.16.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"++[[package]]+name = "emath"+version = "0.31.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9e4cadcff7a5353ba72b7fea76bf2122b5ebdbc68e8155aa56dfdea90083fe1b"+dependencies = [+ "bytemuck",+]++[[package]]+name = "endi"+version = "1.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"++[[package]]+name = "enumflags2"+version = "0.7.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"+dependencies = [+ "enumflags2_derive",+ "serde",+]++[[package]]+name = "enumflags2_derive"+version = "0.7.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "epaint"+version = "0.31.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "41fcc0f5a7c613afd2dee5e4b30c3e6acafb8ad6f0edb06068811f708a67c562"+dependencies = [+ "ab_glyph",+ "ahash",+ "bytemuck",+ "ecolor",+ "emath",+ "epaint_default_fonts",+ "log",+ "nohash-hasher",+ "parking_lot",+ "profiling",+]++[[package]]+name = "epaint_default_fonts"+version = "0.31.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fc7e7a64c02cf7a5b51e745a9e45f60660a286f151c238b9d397b3e923f5082f"++[[package]]+name = "equivalent"+version = "1.0.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"++[[package]]+name = "errno"+version = "0.3.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"+dependencies = [+ "libc",+ "windows-sys 0.61.2",+]++[[package]]+name = "error-code"+version = "3.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59"++[[package]]+name = "event-listener"+version = "5.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"+dependencies = [+ "concurrent-queue",+ "parking",+ "pin-project-lite",+]++[[package]]+name = "event-listener-strategy"+version = "0.5.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"+dependencies = [+ "event-listener",+ "pin-project-lite",+]++[[package]]+name = "fastrand"+version = "2.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"++[[package]]+name = "fax"+version = "0.2.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a"++[[package]]+name = "fdeflate"+version = "0.3.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"+dependencies = [+ "simd-adler32",+]++[[package]]+name = "find-msvc-tools"+version = "0.1.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"++[[package]]+name = "flate2"+version = "1.1.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"+dependencies = [+ "crc32fast",+ "miniz_oxide",+]++[[package]]+name = "foldhash"+version = "0.1.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"++[[package]]+name = "foreign-types"+version = "0.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"+dependencies = [+ "foreign-types-macros",+ "foreign-types-shared",+]++[[package]]+name = "foreign-types-macros"+version = "0.2.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "foreign-types-shared"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"++[[package]]+name = "form_urlencoded"+version = "1.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"+dependencies = [+ "percent-encoding",+]++[[package]]+name = "futures-channel"+version = "0.3.32"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"+dependencies = [+ "futures-core",+]++[[package]]+name = "futures-core"+version = "0.3.32"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"++[[package]]+name = "futures-io"+version = "0.3.32"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"++[[package]]+name = "futures-lite"+version = "2.6.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"+dependencies = [+ "fastrand",+ "futures-core",+ "futures-io",+ "parking",+ "pin-project-lite",+]++[[package]]+name = "futures-macro"+version = "0.3.32"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "futures-sink"+version = "0.3.32"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"++[[package]]+name = "futures-task"+version = "0.3.32"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"++[[package]]+name = "futures-util"+version = "0.3.32"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"+dependencies = [+ "futures-core",+ "futures-io",+ "futures-macro",+ "futures-sink",+ "futures-task",+ "memchr",+ "pin-project-lite",+ "slab",+]++[[package]]+name = "generic-array"+version = "0.14.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"+dependencies = [+ "typenum",+ "version_check",+]++[[package]]+name = "gethostname"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8"+dependencies = [+ "rustix 1.1.4",+ "windows-link",+]++[[package]]+name = "getrandom"+version = "0.2.17"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"+dependencies = [+ "cfg-if",+ "libc",+ "wasi",+]++[[package]]+name = "getrandom"+version = "0.3.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"+dependencies = [+ "cfg-if",+ "libc",+ "r-efi 5.3.0",+ "wasip2",+]++[[package]]+name = "getrandom"+version = "0.4.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"+dependencies = [+ "cfg-if",+ "libc",+ "r-efi 6.0.0",+]++[[package]]+name = "ghidrust-cli"+version = "0.1.0"+dependencies = [+ "ghidrust-core",+ "ghidrust-decomp",+ "serde",+ "serde_json",+]++[[package]]+name = "ghidrust-core"+version = "0.1.0"+dependencies = [+ "bincode",+ "bytemuck",+ "pollster",+ "rayon",+ "serde",+ "serde_json",+ "wgpu",+]++[[package]]+name = "ghidrust-decomp"+version = "0.1.0"+dependencies = [+ "bytemuck",+ "ghidrust-core",+ "pollster",+ "serde",+ "wgpu",+]++[[package]]+name = "ghidrust-gui"+version = "0.1.0"+dependencies = [+ "eframe",+ "egui",+ "ghidrust-core",+ "rfd",+]++[[package]]+name = "gl_generator"+version = "0.14.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d"+dependencies = [+ "khronos_api",+ "log",+ "xml-rs",+]++[[package]]+name = "glow"+version = "0.16.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c5e5ea60d70410161c8bf5da3fdfeaa1c72ed2c15f8bbb9d19fe3a4fad085f08"+dependencies = [+ "js-sys",+ "slotmap",+ "wasm-bindgen",+ "web-sys",+]++[[package]]+name = "glutin"+version = "0.32.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "12124de845cacfebedff80e877bb37b5b75c34c5a4c89e47e1cdd67fb6041325"+dependencies = [+ "bitflags 2.13.0",+ "cfg_aliases",+ "cgl",+ "dispatch2",+ "glutin_egl_sys",+ "glutin_glx_sys",+ "glutin_wgl_sys",+ "libloading",+ "objc2 0.6.4",+ "objc2-app-kit 0.3.2",+ "objc2-core-foundation",+ "objc2-foundation 0.3.2",+ "once_cell",+ "raw-window-handle",+ "wayland-sys",+ "windows-sys 0.52.0",+ "x11-dl",+]++[[package]]+name = "glutin-winit"+version = "0.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "85edca7075f8fc728f28cb8fbb111a96c3b89e930574369e3e9c27eb75d3788f"+dependencies = [+ "cfg_aliases",+ "glutin",+ "raw-window-handle",+ "winit",+]++[[package]]+name = "glutin_egl_sys"+version = "0.7.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4c4680ba6195f424febdc3ba46e7a42a0e58743f2edb115297b86d7f8ecc02d2"+dependencies = [+ "gl_generator",+ "windows-sys 0.52.0",+]++[[package]]+name = "glutin_glx_sys"+version = "0.6.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8a7bb2938045a88b612499fbcba375a77198e01306f52272e692f8c1f3751185"+dependencies = [+ "gl_generator",+ "x11-dl",+]++[[package]]+name = "glutin_wgl_sys"+version = "0.6.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2c4ee00b289aba7a9e5306d57c2d05499b2e5dc427f84ac708bd2c090212cf3e"+dependencies = [+ "gl_generator",+]++[[package]]+name = "gpu-alloc"+version = "0.6.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "45cf04b2726f02df5508c6de726acdc90cdf97ac771a9a0ffd8ba10a6e696bf9"+dependencies = [+ "bitflags 2.13.0",+ "gpu-alloc-types",+]++[[package]]+name = "gpu-alloc-types"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b2bbed164dd10ed526c2e4fe3e721ca4a71c61730e5aafac6844b417b3227058"+dependencies = [+ "bitflags 2.13.0",+]++[[package]]+name = "gpu-allocator"+version = "0.27.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c151a2a5ef800297b4e79efa4f4bec035c5f51d5ae587287c9b952bdf734cacd"+dependencies = [+ "log",+ "presser",+ "thiserror 1.0.69",+ "windows",+]++[[package]]+name = "gpu-descriptor"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b89c83349105e3732062a895becfc71a8f921bb71ecbbdd8ff99263e3b53a0ca"+dependencies = [+ "bitflags 2.13.0",+ "gpu-descriptor-types",+ "hashbrown 0.15.5",+]++[[package]]+name = "gpu-descriptor-types"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91"+dependencies = [+ "bitflags 2.13.0",+]++[[package]]+name = "half"+version = "2.7.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"+dependencies = [+ "cfg-if",+ "crunchy",+ "zerocopy",+]++[[package]]+name = "hashbrown"+version = "0.15.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"+dependencies = [+ "foldhash",+]++[[package]]+name = "hashbrown"+version = "0.17.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"++[[package]]+name = "heck"+version = "0.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"++[[package]]+name = "hermit-abi"+version = "0.5.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"++[[package]]+name = "hex"+version = "0.4.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"++[[package]]+name = "hexf-parse"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"++[[package]]+name = "icu_collections"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"+dependencies = [+ "displaydoc",+ "potential_utf",+ "utf8_iter",+ "yoke",+ "zerofrom",+ "zerovec",+]++[[package]]+name = "icu_locale_core"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"+dependencies = [+ "displaydoc",+ "litemap",+ "tinystr",+ "writeable",+ "zerovec",+]++[[package]]+name = "icu_normalizer"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"+dependencies = [+ "icu_collections",+ "icu_normalizer_data",+ "icu_properties",+ "icu_provider",+ "smallvec",+ "zerovec",+]++[[package]]+name = "icu_normalizer_data"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"++[[package]]+name = "icu_properties"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"+dependencies = [+ "icu_collections",+ "icu_locale_core",+ "icu_properties_data",+ "icu_provider",+ "zerotrie",+ "zerovec",+]++[[package]]+name = "icu_properties_data"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"++[[package]]+name = "icu_provider"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"+dependencies = [+ "displaydoc",+ "icu_locale_core",+ "writeable",+ "yoke",+ "zerofrom",+ "zerotrie",+ "zerovec",+]++[[package]]+name = "idna"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"+dependencies = [+ "idna_adapter",+ "smallvec",+ "utf8_iter",+]++[[package]]+name = "idna_adapter"+version = "1.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"+dependencies = [+ "icu_normalizer",+ "icu_properties",+]++[[package]]+name = "image"+version = "0.25.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"+dependencies = [+ "bytemuck",+ "byteorder-lite",+ "moxcms",+ "num-traits",+ "png",+ "tiff",+]++[[package]]+name = "immutable-chunkmap"+version = "2.1.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "45b30d0eb3d4282f694894b75bc50807ab6e3203436681cc235fa364acf7f5e1"+dependencies = [+ "arrayvec",+]++[[package]]+name = "indexmap"+version = "2.14.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"+dependencies = [+ "equivalent",+ "hashbrown 0.17.1",+]++[[package]]+name = "itoa"+version = "1.0.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"++[[package]]+name = "jni"+version = "0.22.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"+dependencies = [+ "cfg-if",+ "combine",+ "jni-macros",+ "jni-sys 0.4.1",+ "log",+ "simd_cesu8",+ "thiserror 2.0.18",+ "walkdir",+ "windows-link",+]++[[package]]+name = "jni-macros"+version = "0.22.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"+dependencies = [+ "proc-macro2",+ "quote",+ "rustc_version",+ "simd_cesu8",+ "syn",+]++[[package]]+name = "jni-sys"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"+dependencies = [+ "jni-sys 0.4.1",+]++[[package]]+name = "jni-sys"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"+dependencies = [+ "jni-sys-macros",+]++[[package]]+name = "jni-sys-macros"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"+dependencies = [+ "quote",+ "syn",+]++[[package]]+name = "jobserver"+version = "0.1.35"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"+dependencies = [+ "getrandom 0.4.3",+ "libc",+]++[[package]]+name = "js-sys"+version = "0.3.103"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "53b44bfcdb3f8d5837a46dae1ca9660a837176eee74a28b229bc626816589102"+dependencies = [+ "cfg-if",+ "futures-util",+ "wasm-bindgen",+]++[[package]]+name = "khronos-egl"+version = "6.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76"+dependencies = [+ "libc",+ "libloading",+ "pkg-config",+]++[[package]]+name = "khronos_api"+version = "3.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"++[[package]]+name = "libc"+version = "0.2.186"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"++[[package]]+name = "libloading"+version = "0.8.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"+dependencies = [+ "cfg-if",+ "windows-link",+]++[[package]]+name = "libredox"+version = "0.1.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c943259e342f1e06ff2da7a83eabdfe7f92ce10262688dbf1895ff0b3e6e4652"+dependencies = [+ "bitflags 2.13.0",+ "libc",+ "plain",+ "redox_syscall 0.9.0",+]++[[package]]+name = "linux-raw-sys"+version = "0.4.15"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"++[[package]]+name = "linux-raw-sys"+version = "0.12.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"++[[package]]+name = "litemap"+version = "0.8.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"++[[package]]+name = "litrs"+version = "1.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"++[[package]]+name = "lock_api"+version = "0.4.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"+dependencies = [+ "scopeguard",+]++[[package]]+name = "log"+version = "0.4.33"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"++[[package]]+name = "malloc_buf"+version = "0.0.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"+dependencies = [+ "libc",+]++[[package]]+name = "memchr"+version = "2.8.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"++[[package]]+name = "memmap2"+version = "0.9.11"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0"+dependencies = [+ "libc",+]++[[package]]+name = "memoffset"+version = "0.9.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"+dependencies = [+ "autocfg",+]++[[package]]+name = "metal"+version = "0.31.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f569fb946490b5743ad69813cb19629130ce9374034abe31614a36402d18f99e"+dependencies = [+ "bitflags 2.13.0",+ "block",+ "core-graphics-types",+ "foreign-types",+ "log",+ "objc",+ "paste",+]++[[package]]+name = "miniz_oxide"+version = "0.8.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"+dependencies = [+ "adler2",+ "simd-adler32",+]++[[package]]+name = "moxcms"+version = "0.8.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"+dependencies = [+ "num-traits",+ "pxfm",+]++[[package]]+name = "naga"+version = "24.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e380993072e52eef724eddfcde0ed013b0c023c3f0417336ed041aa9f076994e"+dependencies = [+ "arrayvec",+ "bit-set",+ "bitflags 2.13.0",+ "cfg_aliases",+ "codespan-reporting",+ "hexf-parse",+ "indexmap",+ "log",+ "rustc-hash 1.1.0",+ "spirv",+ "strum",+ "termcolor",+ "thiserror 2.0.18",+ "unicode-xid",+]++[[package]]+name = "ndk"+version = "0.9.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"+dependencies = [+ "bitflags 2.13.0",+ "jni-sys 0.3.1",+ "log",+ "ndk-sys 0.6.0+11769913",+ "num_enum",+ "raw-window-handle",+ "thiserror 1.0.69",+]++[[package]]+name = "ndk-context"+version = "0.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"++[[package]]+name = "ndk-sys"+version = "0.5.0+25.2.9519653"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691"+dependencies = [+ "jni-sys 0.3.1",+]++[[package]]+name = "ndk-sys"+version = "0.6.0+11769913"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"+dependencies = [+ "jni-sys 0.3.1",+]++[[package]]+name = "nix"+version = "0.29.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"+dependencies = [+ "bitflags 2.13.0",+ "cfg-if",+ "cfg_aliases",+ "libc",+ "memoffset",+]++[[package]]+name = "nohash-hasher"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"++[[package]]+name = "num-traits"+version = "0.2.19"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"+dependencies = [+ "autocfg",+]++[[package]]+name = "num_enum"+version = "0.7.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"+dependencies = [+ "num_enum_derive",+ "rustversion",+]++[[package]]+name = "num_enum_derive"+version = "0.7.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"+dependencies = [+ "proc-macro-crate",+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "objc"+version = "0.2.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"+dependencies = [+ "malloc_buf",+]++[[package]]+name = "objc-sys"+version = "0.3.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310"++[[package]]+name = "objc2"+version = "0.5.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804"+dependencies = [+ "objc-sys",+ "objc2-encode",+]++[[package]]+name = "objc2"+version = "0.6.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"+dependencies = [+ "objc2-encode",+]++[[package]]+name = "objc2-app-kit"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.5.1",+ "libc",+ "objc2 0.5.2",+ "objc2-core-data",+ "objc2-core-image",+ "objc2-foundation 0.2.2",+ "objc2-quartz-core",+]++[[package]]+name = "objc2-app-kit"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.6.2",+ "objc2 0.6.4",+ "objc2-core-foundation",+ "objc2-core-graphics",+ "objc2-foundation 0.3.2",+]++[[package]]+name = "objc2-cloud-kit"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-core-location",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "objc2-contacts"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a5ff520e9c33812fd374d8deecef01d4a840e7b41862d849513de77e44aa4889"+dependencies = [+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "objc2-core-data"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "objc2-core-foundation"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"+dependencies = [+ "bitflags 2.13.0",+ "dispatch2",+ "objc2 0.6.4",+]++[[package]]+name = "objc2-core-graphics"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"+dependencies = [+ "bitflags 2.13.0",+ "dispatch2",+ "objc2 0.6.4",+ "objc2-core-foundation",+ "objc2-io-surface",+]++[[package]]+name = "objc2-core-image"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80"+dependencies = [+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-foundation 0.2.2",+ "objc2-metal",+]++[[package]]+name = "objc2-core-location"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "000cfee34e683244f284252ee206a27953279d370e309649dc3ee317b37e5781"+dependencies = [+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-contacts",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "objc2-encode"+version = "4.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"++[[package]]+name = "objc2-foundation"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.5.1",+ "dispatch",+ "libc",+ "objc2 0.5.2",+]++[[package]]+name = "objc2-foundation"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"+dependencies = [+ "bitflags 2.13.0",+ "objc2 0.6.4",+ "objc2-core-foundation",+]++[[package]]+name = "objc2-io-surface"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"+dependencies = [+ "bitflags 2.13.0",+ "objc2 0.6.4",+ "objc2-core-foundation",+]++[[package]]+name = "objc2-link-presentation"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398"+dependencies = [+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-app-kit 0.2.2",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "objc2-metal"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "objc2-quartz-core"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-foundation 0.2.2",+ "objc2-metal",+]++[[package]]+name = "objc2-symbols"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0a684efe3dec1b305badae1a28f6555f6ddd3bb2c2267896782858d5a78404dc"+dependencies = [+ "objc2 0.5.2",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "objc2-ui-kit"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-cloud-kit",+ "objc2-core-data",+ "objc2-core-image",+ "objc2-core-location",+ "objc2-foundation 0.2.2",+ "objc2-link-presentation",+ "objc2-quartz-core",+ "objc2-symbols",+ "objc2-uniform-type-identifiers",+ "objc2-user-notifications",+]++[[package]]+name = "objc2-uniform-type-identifiers"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "44fa5f9748dbfe1ca6c0b79ad20725a11eca7c2218bceb4b005cb1be26273bfe"+dependencies = [+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "objc2-user-notifications"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3"+dependencies = [+ "bitflags 2.13.0",+ "block2 0.5.1",+ "objc2 0.5.2",+ "objc2-core-location",+ "objc2-foundation 0.2.2",+]++[[package]]+name = "once_cell"+version = "1.21.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"++[[package]]+name = "orbclient"+version = "0.3.55"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5df339f526ea9a60e371768d50efc2f2508c7203290731565d1f7a6f71d21747"+dependencies = [+ "libc",+ "libredox",+]++[[package]]+name = "ordered-float"+version = "4.6.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951"+dependencies = [+ "num-traits",+]++[[package]]+name = "ordered-stream"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"+dependencies = [+ "futures-core",+ "pin-project-lite",+]++[[package]]+name = "owned_ttf_parser"+version = "0.25.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b"+dependencies = [+ "ttf-parser",+]++[[package]]+name = "parking"+version = "2.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"++[[package]]+name = "parking_lot"+version = "0.12.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"+dependencies = [+ "lock_api",+ "parking_lot_core",+]++[[package]]+name = "parking_lot_core"+version = "0.9.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"+dependencies = [+ "cfg-if",+ "libc",+ "redox_syscall 0.5.18",+ "smallvec",+ "windows-link",+]++[[package]]+name = "paste"+version = "1.0.15"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"++[[package]]+name = "percent-encoding"+version = "2.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"++[[package]]+name = "pin-project"+version = "1.1.13"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924"+dependencies = [+ "pin-project-internal",+]++[[package]]+name = "pin-project-internal"+version = "1.1.13"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "pin-project-lite"+version = "0.2.17"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"++[[package]]+name = "piper"+version = "0.2.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"+dependencies = [+ "atomic-waker",+ "fastrand",+ "futures-io",+]++[[package]]+name = "pkg-config"+version = "0.3.33"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"++[[package]]+name = "plain"+version = "0.2.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"++[[package]]+name = "png"+version = "0.18.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"+dependencies = [+ "bitflags 2.13.0",+ "crc32fast",+ "fdeflate",+ "flate2",+ "miniz_oxide",+]++[[package]]+name = "polling"+version = "3.11.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"+dependencies = [+ "cfg-if",+ "concurrent-queue",+ "hermit-abi",+ "pin-project-lite",+ "rustix 1.1.4",+ "windows-sys 0.61.2",+]++[[package]]+name = "pollster"+version = "0.4.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3"++[[package]]+name = "potential_utf"+version = "0.1.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"+dependencies = [+ "zerovec",+]++[[package]]+name = "ppv-lite86"+version = "0.2.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"+dependencies = [+ "zerocopy",+]++[[package]]+name = "presser"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa"++[[package]]+name = "proc-macro-crate"+version = "3.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"+dependencies = [+ "toml_edit",+]++[[package]]+name = "proc-macro2"+version = "1.0.106"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"+dependencies = [+ "unicode-ident",+]++[[package]]+name = "profiling"+version = "1.0.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"++[[package]]+name = "pxfm"+version = "0.1.30"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"++[[package]]+name = "quick-error"+version = "2.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"++[[package]]+name = "quick-xml"+version = "0.30.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "eff6510e86862b57b210fd8cbe8ed3f0d7d600b9c2863cd4549a2e033c66e956"+dependencies = [+ "memchr",+ "serde",+]++[[package]]+name = "quick-xml"+version = "0.39.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cdcc8dd4e2f670d309a5f0e83fe36dfdc05af317008fea29144da1a2ac858e5e"+dependencies = [+ "memchr",+]++[[package]]+name = "quote"+version = "1.0.46"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"+dependencies = [+ "proc-macro2",+]++[[package]]+name = "r-efi"+version = "5.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"++[[package]]+name = "r-efi"+version = "6.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"++[[package]]+name = "rand"+version = "0.8.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "22f6172bdec972074665ed81ed53b71da00bfc44b65a753cfde883ec4c702a1a"+dependencies = [+ "libc",+ "rand_chacha 0.3.1",+ "rand_core 0.6.4",+]++[[package]]+name = "rand"+version = "0.9.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"+dependencies = [+ "rand_chacha 0.9.0",+ "rand_core 0.9.5",+]++[[package]]+name = "rand_chacha"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"+dependencies = [+ "ppv-lite86",+ "rand_core 0.6.4",+]++[[package]]+name = "rand_chacha"+version = "0.9.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"+dependencies = [+ "ppv-lite86",+ "rand_core 0.9.5",+]++[[package]]+name = "rand_core"+version = "0.6.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"+dependencies = [+ "getrandom 0.2.17",+]++[[package]]+name = "rand_core"+version = "0.9.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"+dependencies = [+ "getrandom 0.3.4",+]++[[package]]+name = "range-alloc"+version = "0.1.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08"++[[package]]+name = "raw-window-handle"+version = "0.6.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"++[[package]]+name = "rayon"+version = "1.12.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"+dependencies = [+ "either",+ "rayon-core",+]++[[package]]+name = "rayon-core"+version = "1.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"+dependencies = [+ "crossbeam-deque",+ "crossbeam-utils",+]++[[package]]+name = "redox_syscall"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"+dependencies = [+ "bitflags 1.3.2",+]++[[package]]+name = "redox_syscall"+version = "0.5.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"+dependencies = [+ "bitflags 2.13.0",+]++[[package]]+name = "redox_syscall"+version = "0.9.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c5102a6aaa05aa011a238e178e6bca86d2cb56fc9f586d37cb80f5bca6e07759"+dependencies = [+ "bitflags 2.13.0",+]++[[package]]+name = "renderdoc-sys"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"++[[package]]+name = "rfd"+version = "0.15.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ef2bee61e6cffa4635c72d7d81a84294e28f0930db0ddcb0f66d10244674ebed"+dependencies = [+ "ashpd",+ "block2 0.6.2",+ "dispatch2",+ "js-sys",+ "log",+ "objc2 0.6.4",+ "objc2-app-kit 0.3.2",+ "objc2-core-foundation",+ "objc2-foundation 0.3.2",+ "pollster",+ "raw-window-handle",+ "urlencoding",+ "wasm-bindgen",+ "wasm-bindgen-futures",+ "web-sys",+ "windows-sys 0.59.0",+]++[[package]]+name = "rustc-hash"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"++[[package]]+name = "rustc-hash"+version = "2.1.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"++[[package]]+name = "rustc_version"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"+dependencies = [+ "semver",+]++[[package]]+name = "rustix"+version = "0.38.44"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"+dependencies = [+ "bitflags 2.13.0",+ "errno",+ "libc",+ "linux-raw-sys 0.4.15",+ "windows-sys 0.59.0",+]++[[package]]+name = "rustix"+version = "1.1.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"+dependencies = [+ "bitflags 2.13.0",+ "errno",+ "libc",+ "linux-raw-sys 0.12.1",+ "windows-sys 0.61.2",+]++[[package]]+name = "rustversion"+version = "1.0.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"++[[package]]+name = "same-file"+version = "1.0.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"+dependencies = [+ "winapi-util",+]++[[package]]+name = "scoped-tls"+version = "1.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"++[[package]]+name = "scopeguard"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"++[[package]]+name = "sctk-adwaita"+version = "0.10.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec"+dependencies = [+ "ab_glyph",+ "log",+ "memmap2",+ "smithay-client-toolkit 0.19.2",+ "tiny-skia",+]++[[package]]+name = "semver"+version = "1.0.28"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"++[[package]]+name = "serde"+version = "1.0.228"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"+dependencies = [+ "serde_core",+ "serde_derive",+]++[[package]]+name = "serde_core"+version = "1.0.228"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"+dependencies = [+ "serde_derive",+]++[[package]]+name = "serde_derive"+version = "1.0.228"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "serde_json"+version = "1.0.150"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"+dependencies = [+ "itoa",+ "memchr",+ "serde",+ "serde_core",+ "zmij",+]++[[package]]+name = "serde_repr"+version = "0.1.20"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "sha1"+version = "0.10.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"+dependencies = [+ "cfg-if",+ "cpufeatures",+ "digest",+]++[[package]]+name = "shlex"+version = "2.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"++[[package]]+name = "signal-hook-registry"+version = "1.4.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"+dependencies = [+ "errno",+ "libc",+]++[[package]]+name = "simd-adler32"+version = "0.3.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"++[[package]]+name = "simd_cesu8"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520"+dependencies = [+ "rustc_version",+ "simdutf8",+]++[[package]]+name = "simdutf8"+version = "0.1.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"++[[package]]+name = "slab"+version = "0.4.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"++[[package]]+name = "slotmap"+version = "1.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038"+dependencies = [+ "version_check",+]++[[package]]+name = "smallvec"+version = "1.15.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"++[[package]]+name = "smithay-client-toolkit"+version = "0.19.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3457dea1f0eb631b4034d61d4d8c32074caa6cd1ab2d59f2327bd8461e2c0016"+dependencies = [+ "bitflags 2.13.0",+ "calloop 0.13.0",+ "calloop-wayland-source 0.3.0",+ "cursor-icon",+ "libc",+ "log",+ "memmap2",+ "rustix 0.38.44",+ "thiserror 1.0.69",+ "wayland-backend",+ "wayland-client",+ "wayland-csd-frame",+ "wayland-cursor",+ "wayland-protocols",+ "wayland-protocols-wlr",+ "wayland-scanner",+ "xkeysym",+]++[[package]]+name = "smithay-client-toolkit"+version = "0.20.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0512da38f5e2b31201a93524adb8d3136276fa4fe4aafab4e1f727a82b534cc0"+dependencies = [+ "bitflags 2.13.0",+ "calloop 0.14.4",+ "calloop-wayland-source 0.4.1",+ "cursor-icon",+ "libc",+ "log",+ "memmap2",+ "rustix 1.1.4",+ "thiserror 2.0.18",+ "wayland-backend",+ "wayland-client",+ "wayland-csd-frame",+ "wayland-cursor",+ "wayland-protocols",+ "wayland-protocols-experimental",+ "wayland-protocols-misc",+ "wayland-protocols-wlr",+ "wayland-scanner",+ "xkeysym",+]++[[package]]+name = "smithay-clipboard"+version = "0.7.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "71704c03f739f7745053bde45fa203a46c58d25bc5c4efba1d9a60e9dba81226"+dependencies = [+ "libc",+ "smithay-client-toolkit 0.20.0",+ "wayland-backend",+]++[[package]]+name = "smol_str"+version = "0.2.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"+dependencies = [+ "serde",+]++[[package]]+name = "spirv"+version = "0.3.0+sdk-1.3.268.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844"+dependencies = [+ "bitflags 2.13.0",+]++[[package]]+name = "stable_deref_trait"+version = "1.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"++[[package]]+name = "static_assertions"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"++[[package]]+name = "strict-num"+version = "0.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"++[[package]]+name = "strum"+version = "0.26.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"+dependencies = [+ "strum_macros",+]++[[package]]+name = "strum_macros"+version = "0.26.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"+dependencies = [+ "heck",+ "proc-macro2",+ "quote",+ "rustversion",+ "syn",+]++[[package]]+name = "syn"+version = "2.0.119"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"+dependencies = [+ "proc-macro2",+ "quote",+ "unicode-ident",+]++[[package]]+name = "synstructure"+version = "0.13.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "tempfile"+version = "3.27.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"+dependencies = [+ "fastrand",+ "getrandom 0.4.3",+ "once_cell",+ "rustix 1.1.4",+ "windows-sys 0.61.2",+]++[[package]]+name = "termcolor"+version = "1.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"+dependencies = [+ "winapi-util",+]++[[package]]+name = "thiserror"+version = "1.0.69"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"+dependencies = [+ "thiserror-impl 1.0.69",+]++[[package]]+name = "thiserror"+version = "2.0.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"+dependencies = [+ "thiserror-impl 2.0.18",+]++[[package]]+name = "thiserror-impl"+version = "1.0.69"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "thiserror-impl"+version = "2.0.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "tiff"+version = "0.11.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52"+dependencies = [+ "fax",+ "flate2",+ "half",+ "quick-error",+ "weezl",+ "zune-jpeg",+]++[[package]]+name = "tiny-skia"+version = "0.11.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab"+dependencies = [+ "arrayref",+ "arrayvec",+ "bytemuck",+ "cfg-if",+ "log",+ "tiny-skia-path",+]++[[package]]+name = "tiny-skia-path"+version = "0.11.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93"+dependencies = [+ "arrayref",+ "bytemuck",+ "strict-num",+]++[[package]]+name = "tinystr"+version = "0.8.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"+dependencies = [+ "displaydoc",+ "zerovec",+]++[[package]]+name = "toml_datetime"+version = "1.1.1+spec-1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"+dependencies = [+ "serde_core",+]++[[package]]+name = "toml_edit"+version = "0.25.13+spec-1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6975367e4d2ef766d86af01ffad14b622fecc8d4357a998fbc4deb6e9bacaf9b"+dependencies = [+ "indexmap",+ "toml_datetime",+ "toml_parser",+ "winnow",+]++[[package]]+name = "toml_parser"+version = "1.1.2+spec-1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"+dependencies = [+ "winnow",+]++[[package]]+name = "tracing"+version = "0.1.44"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"+dependencies = [+ "log",+ "pin-project-lite",+ "tracing-attributes",+ "tracing-core",+]++[[package]]+name = "tracing-attributes"+version = "0.1.31"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "tracing-core"+version = "0.1.36"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"+dependencies = [+ "once_cell",+]++[[package]]+name = "ttf-parser"+version = "0.25.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"++[[package]]+name = "type-map"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cb30dbbd9036155e74adad6812e9898d03ec374946234fbcebd5dfc7b9187b90"+dependencies = [+ "rustc-hash 2.1.3",+]++[[package]]+name = "typenum"+version = "1.20.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"++[[package]]+name = "uds_windows"+version = "1.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"+dependencies = [+ "memoffset",+ "tempfile",+ "windows-sys 0.61.2",+]++[[package]]+name = "unicode-ident"+version = "1.0.24"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"++[[package]]+name = "unicode-segmentation"+version = "1.13.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"++[[package]]+name = "unicode-width"+version = "0.1.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"++[[package]]+name = "unicode-xid"+version = "0.2.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"++[[package]]+name = "url"+version = "2.5.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"+dependencies = [+ "form_urlencoded",+ "idna",+ "percent-encoding",+ "serde",+ "serde_derive",+]++[[package]]+name = "urlencoding"+version = "2.1.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"++[[package]]+name = "utf8_iter"+version = "1.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"++[[package]]+name = "uuid"+version = "1.23.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ea5fab0d6c3c01ae70085a09cb03d4c7a1d6314e2b3e075392783396d724ca0a"+dependencies = [+ "js-sys",+ "serde_core",+ "wasm-bindgen",+]++[[package]]+name = "version_check"+version = "0.9.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"++[[package]]+name = "walkdir"+version = "2.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"+dependencies = [+ "same-file",+ "winapi-util",+]++[[package]]+name = "wasi"+version = "0.11.1+wasi-snapshot-preview1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"++[[package]]+name = "wasip2"+version = "1.0.4+wasi-0.2.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"+dependencies = [+ "wit-bindgen",+]++[[package]]+name = "wasm-bindgen"+version = "0.2.126"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4"+dependencies = [+ "cfg-if",+ "once_cell",+ "rustversion",+ "wasm-bindgen-macro",+ "wasm-bindgen-shared",+]++[[package]]+name = "wasm-bindgen-futures"+version = "0.4.76"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c62df1340f32221cb9c54d6a27b030e3dba64361d4a95bed55f9aacb44da291d"+dependencies = [+ "js-sys",+ "wasm-bindgen",+]++[[package]]+name = "wasm-bindgen-macro"+version = "0.2.126"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1"+dependencies = [+ "quote",+ "wasm-bindgen-macro-support",+]++[[package]]+name = "wasm-bindgen-macro-support"+version = "0.2.126"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e"+dependencies = [+ "bumpalo",+ "proc-macro2",+ "quote",+ "syn",+ "wasm-bindgen-shared",+]++[[package]]+name = "wasm-bindgen-shared"+version = "0.2.126"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24"+dependencies = [+ "unicode-ident",+]++[[package]]+name = "wayland-backend"+version = "0.3.15"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2857dd20b54e916ec7253b3d6b4d5c4d7d4ca2c33c2e11c6c76a99bd8744755d"+dependencies = [+ "cc",+ "downcast-rs",+ "rustix 1.1.4",+ "scoped-tls",+ "smallvec",+ "wayland-sys",+]++[[package]]+name = "wayland-client"+version = "0.31.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144"+dependencies = [+ "bitflags 2.13.0",+ "rustix 1.1.4",+ "wayland-backend",+ "wayland-scanner",+]++[[package]]+name = "wayland-csd-frame"+version = "0.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e"+dependencies = [+ "bitflags 2.13.0",+ "cursor-icon",+ "wayland-backend",+]++[[package]]+name = "wayland-cursor"+version = "0.31.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4a52d18780be9b1314328a3de5f930b73d2200112e3849ca6cb11822793fb34d"+dependencies = [+ "rustix 1.1.4",+ "wayland-client",+ "xcursor",+]++[[package]]+name = "wayland-protocols"+version = "0.32.13"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6"+dependencies = [+ "bitflags 2.13.0",+ "wayland-backend",+ "wayland-client",+ "wayland-scanner",+]++[[package]]+name = "wayland-protocols-experimental"+version = "20250721.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "40a1f863128dcaaec790d7b4b396cc9b9a7a079e878e18c47e6c2d2c5a8dcbb1"+dependencies = [+ "bitflags 2.13.0",+ "wayland-backend",+ "wayland-client",+ "wayland-protocols",+ "wayland-scanner",+]++[[package]]+name = "wayland-protocols-misc"+version = "0.3.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6e9567599ef23e09b8dad6e429e5738d4509dfc46b3b21f32841a304d16b29c8"+dependencies = [+ "bitflags 2.13.0",+ "wayland-backend",+ "wayland-client",+ "wayland-protocols",+ "wayland-scanner",+]++[[package]]+name = "wayland-protocols-plasma"+version = "0.3.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2b6d8cf1eb2c1c31ed1f5643c88a6e53538129d4af80030c8cabd1f9fa884d91"+dependencies = [+ "bitflags 2.13.0",+ "wayland-backend",+ "wayland-client",+ "wayland-protocols",+ "wayland-scanner",+]++[[package]]+name = "wayland-protocols-wlr"+version = "0.3.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234"+dependencies = [+ "bitflags 2.13.0",+ "wayland-backend",+ "wayland-client",+ "wayland-protocols",+ "wayland-scanner",+]++[[package]]+name = "wayland-scanner"+version = "0.31.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9c324a910fd86ebdc364a3e61ec1f11737d3b1d6c273c0239ee8ff4bc0d24b4a"+dependencies = [+ "proc-macro2",+ "quick-xml 0.39.4",+ "quote",+]++[[package]]+name = "wayland-sys"+version = "0.31.11"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be"+dependencies = [+ "dlib",+ "log",+ "once_cell",+ "pkg-config",+]++[[package]]+name = "web-sys"+version = "0.3.103"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8622dcb61c0bcc9fffa6938bed81210af2da9a7e4a1a834b2e37a59b6dfb6141"+dependencies = [+ "js-sys",+ "wasm-bindgen",+]++[[package]]+name = "web-time"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"+dependencies = [+ "js-sys",+ "wasm-bindgen",+]++[[package]]+name = "webbrowser"+version = "1.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0fc95580916af1e68ff6a7be07446fc5db73ebf71cf092de939bbf5f7e189f72"+dependencies = [+ "core-foundation 0.10.1",+ "jni",+ "log",+ "ndk-context",+ "objc2 0.6.4",+ "objc2-foundation 0.3.2",+ "url",+ "web-sys",+]++[[package]]+name = "weezl"+version = "0.1.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"++[[package]]+name = "wgpu"+version = "24.0.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6b0b3436f0729f6cdf2e6e9201f3d39dc95813fad61d826c1ed07918b4539353"+dependencies = [+ "arrayvec",+ "bitflags 2.13.0",+ "cfg_aliases",+ "document-features",+ "js-sys",+ "log",+ "naga",+ "parking_lot",+ "profiling",+ "raw-window-handle",+ "smallvec",+ "static_assertions",+ "wasm-bindgen",+ "wasm-bindgen-futures",+ "web-sys",+ "wgpu-core",+ "wgpu-hal",+ "wgpu-types",+]++[[package]]+name = "wgpu-core"+version = "24.0.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7f0aa306497a238d169b9dc70659105b4a096859a34894544ca81719242e1499"+dependencies = [+ "arrayvec",+ "bit-vec",+ "bitflags 2.13.0",+ "cfg_aliases",+ "document-features",+ "indexmap",+ "log",+ "naga",+ "once_cell",+ "parking_lot",+ "profiling",+ "raw-window-handle",+ "rustc-hash 1.1.0",+ "smallvec",+ "thiserror 2.0.18",+ "wgpu-hal",+ "wgpu-types",+]++[[package]]+name = "wgpu-hal"+version = "24.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f112f464674ca69f3533248508ee30cb84c67cf06c25ff6800685f5e0294e259"+dependencies = [+ "android_system_properties",+ "arrayvec",+ "ash",+ "bit-set",+ "bitflags 2.13.0",+ "block",+ "bytemuck",+ "cfg_aliases",+ "core-graphics-types",+ "glow",+ "glutin_wgl_sys",+ "gpu-alloc",+ "gpu-allocator",+ "gpu-descriptor",+ "js-sys",+ "khronos-egl",+ "libc",+ "libloading",+ "log",+ "metal",+ "naga",+ "ndk-sys 0.5.0+25.2.9519653",+ "objc",+ "once_cell",+ "ordered-float",+ "parking_lot",+ "profiling",+ "range-alloc",+ "raw-window-handle",+ "renderdoc-sys",+ "rustc-hash 1.1.0",+ "smallvec",+ "thiserror 2.0.18",+ "wasm-bindgen",+ "web-sys",+ "wgpu-types",+ "windows",+ "windows-core",+]++[[package]]+name = "wgpu-types"+version = "24.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "50ac044c0e76c03a0378e7786ac505d010a873665e2d51383dcff8dd227dc69c"+dependencies = [+ "bitflags 2.13.0",+ "js-sys",+ "log",+ "web-sys",+]++[[package]]+name = "winapi"+version = "0.3.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"+dependencies = [+ "winapi-i686-pc-windows-gnu",+ "winapi-x86_64-pc-windows-gnu",+]++[[package]]+name = "winapi-i686-pc-windows-gnu"+version = "0.4.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"++[[package]]+name = "winapi-util"+version = "0.1.11"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"+dependencies = [+ "windows-sys 0.61.2",+]++[[package]]+name = "winapi-x86_64-pc-windows-gnu"+version = "0.4.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"++[[package]]+name = "windows"+version = "0.58.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"+dependencies = [+ "windows-core",+ "windows-targets 0.52.6",+]++[[package]]+name = "windows-core"+version = "0.58.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"+dependencies = [+ "windows-implement",+ "windows-interface",+ "windows-result",+ "windows-strings",+ "windows-targets 0.52.6",+]++[[package]]+name = "windows-implement"+version = "0.58.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "windows-interface"+version = "0.58.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "windows-link"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"++[[package]]+name = "windows-result"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"+dependencies = [+ "windows-targets 0.52.6",+]++[[package]]+name = "windows-strings"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"+dependencies = [+ "windows-result",+ "windows-targets 0.52.6",+]++[[package]]+name = "windows-sys"+version = "0.52.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"+dependencies = [+ "windows-targets 0.52.6",+]++[[package]]+name = "windows-sys"+version = "0.59.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"+dependencies = [+ "windows-targets 0.52.6",+]++[[package]]+name = "windows-sys"+version = "0.60.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"+dependencies = [+ "windows-targets 0.53.5",+]++[[package]]+name = "windows-sys"+version = "0.61.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"+dependencies = [+ "windows-link",+]++[[package]]+name = "windows-targets"+version = "0.52.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"+dependencies = [+ "windows_aarch64_gnullvm 0.52.6",+ "windows_aarch64_msvc 0.52.6",+ "windows_i686_gnu 0.52.6",+ "windows_i686_gnullvm 0.52.6",+ "windows_i686_msvc 0.52.6",+ "windows_x86_64_gnu 0.52.6",+ "windows_x86_64_gnullvm 0.52.6",+ "windows_x86_64_msvc 0.52.6",+]++[[package]]+name = "windows-targets"+version = "0.53.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"+dependencies = [+ "windows-link",+ "windows_aarch64_gnullvm 0.53.1",+ "windows_aarch64_msvc 0.53.1",+ "windows_i686_gnu 0.53.1",+ "windows_i686_gnullvm 0.53.1",+ "windows_i686_msvc 0.53.1",+ "windows_x86_64_gnu 0.53.1",+ "windows_x86_64_gnullvm 0.53.1",+ "windows_x86_64_msvc 0.53.1",+]++[[package]]+name = "windows_aarch64_gnullvm"+version = "0.52.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"++[[package]]+name = "windows_aarch64_gnullvm"+version = "0.53.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"++[[package]]+name = "windows_aarch64_msvc"+version = "0.52.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"++[[package]]+name = "windows_aarch64_msvc"+version = "0.53.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"++[[package]]+name = "windows_i686_gnu"+version = "0.52.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"++[[package]]+name = "windows_i686_gnu"+version = "0.53.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"++[[package]]+name = "windows_i686_gnullvm"+version = "0.52.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"++[[package]]+name = "windows_i686_gnullvm"+version = "0.53.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"++[[package]]+name = "windows_i686_msvc"+version = "0.52.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"++[[package]]+name = "windows_i686_msvc"+version = "0.53.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"++[[package]]+name = "windows_x86_64_gnu"+version = "0.52.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"++[[package]]+name = "windows_x86_64_gnu"+version = "0.53.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"++[[package]]+name = "windows_x86_64_gnullvm"+version = "0.52.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"++[[package]]+name = "windows_x86_64_gnullvm"+version = "0.53.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"++[[package]]+name = "windows_x86_64_msvc"+version = "0.52.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"++[[package]]+name = "windows_x86_64_msvc"+version = "0.53.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"++[[package]]+name = "winit"+version = "0.30.13"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a6755fa58a9f8350bd1e472d4c3fcc25f824ec358933bba33306d0b63df5978d"+dependencies = [+ "ahash",+ "android-activity",+ "atomic-waker",+ "bitflags 2.13.0",+ "block2 0.5.1",+ "bytemuck",+ "calloop 0.13.0",+ "cfg_aliases",+ "concurrent-queue",+ "core-foundation 0.9.4",+ "core-graphics",+ "cursor-icon",+ "dpi",+ "js-sys",+ "libc",+ "memmap2",+ "ndk",+ "objc2 0.5.2",+ "objc2-app-kit 0.2.2",+ "objc2-foundation 0.2.2",+ "objc2-ui-kit",+ "orbclient",+ "percent-encoding",+ "pin-project",+ "raw-window-handle",+ "redox_syscall 0.4.1",+ "rustix 0.38.44",+ "sctk-adwaita",+ "smithay-client-toolkit 0.19.2",+ "smol_str",+ "tracing",+ "unicode-segmentation",+ "wasm-bindgen",+ "wasm-bindgen-futures",+ "wayland-backend",+ "wayland-client",+ "wayland-protocols",+ "wayland-protocols-plasma",+ "web-sys",+ "web-time",+ "windows-sys 0.52.0",+ "x11-dl",+ "x11rb",+ "xkbcommon-dl",+]++[[package]]+name = "winnow"+version = "1.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81"+dependencies = [+ "memchr",+]++[[package]]+name = "wit-bindgen"+version = "0.57.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"++[[package]]+name = "writeable"+version = "0.6.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"++[[package]]+name = "x11-dl"+version = "2.21.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"+dependencies = [+ "libc",+ "once_cell",+ "pkg-config",+]++[[package]]+name = "x11rb"+version = "0.13.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414"+dependencies = [+ "as-raw-xcb-connection",+ "gethostname",+ "libc",+ "libloading",+ "once_cell",+ "rustix 1.1.4",+ "x11rb-protocol",+]++[[package]]+name = "x11rb-protocol"+version = "0.13.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"++[[package]]+name = "xcursor"+version = "0.3.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bec9e4a500ca8864c5b47b8b482a73d62e4237670e5b5f1d6b9e3cae50f28f2b"++[[package]]+name = "xdg-home"+version = "1.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ec1cdab258fb55c0da61328dc52c8764709b249011b2cad0454c72f0bf10a1f6"+dependencies = [+ "libc",+ "windows-sys 0.59.0",+]++[[package]]+name = "xkbcommon-dl"+version = "0.4.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5"+dependencies = [+ "bitflags 2.13.0",+ "dlib",+ "log",+ "once_cell",+ "xkeysym",+]++[[package]]+name = "xkeysym"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56"++[[package]]+name = "xml-rs"+version = "0.8.28"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3ae8337f8a065cfc972643663ea4279e04e7256de865aa66fe25cec5fb912d3f"++[[package]]+name = "yoke"+version = "0.8.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"+dependencies = [+ "stable_deref_trait",+ "yoke-derive",+ "zerofrom",+]++[[package]]+name = "yoke-derive"+version = "0.8.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+ "synstructure",+]++[[package]]+name = "zbus"+version = "4.4.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bb97012beadd29e654708a0fdb4c84bc046f537aecfde2c3ee0a9e4b4d48c725"+dependencies = [+ "async-broadcast",+ "async-executor",+ "async-fs",+ "async-io",+ "async-lock",+ "async-process",+ "async-recursion",+ "async-task",+ "async-trait",+ "blocking",+ "enumflags2",+ "event-listener",+ "futures-core",+ "futures-sink",+ "futures-util",+ "hex",+ "nix",+ "ordered-stream",+ "rand 0.8.7",+ "serde",+ "serde_repr",+ "sha1",+ "static_assertions",+ "tracing",+ "uds_windows",+ "windows-sys 0.52.0",+ "xdg-home",+ "zbus_macros 4.4.0",+ "zbus_names 3.0.0",+ "zvariant 4.2.0",+]++[[package]]+name = "zbus"+version = "5.17.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a28b97f866896a4be7aefd2b5a8e01bb6773d19a775d54ab28b4d094b9a4480e"+dependencies = [+ "async-broadcast",+ "async-executor",+ "async-io",+ "async-lock",+ "async-process",+ "async-recursion",+ "async-task",+ "async-trait",+ "blocking",+ "enumflags2",+ "event-listener",+ "futures-core",+ "futures-lite",+ "hex",+ "libc",+ "ordered-stream",+ "rustix 1.1.4",+ "serde",+ "serde_repr",+ "tracing",+ "uds_windows",+ "uuid",+ "windows-sys 0.61.2",+ "winnow",+ "zbus_macros 5.17.0",+ "zbus_names 4.3.3",+ "zvariant 5.13.0",+]++[[package]]+name = "zbus-lockstep"+version = "0.4.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4ca2c5dceb099bddaade154055c926bb8ae507a18756ba1d8963fd7b51d8ed1d"+dependencies = [+ "zbus_xml",+ "zvariant 4.2.0",+]++[[package]]+name = "zbus-lockstep-macros"+version = "0.4.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "709ab20fc57cb22af85be7b360239563209258430bccf38d8b979c5a2ae3ecce"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+ "zbus-lockstep",+ "zbus_xml",+ "zvariant 4.2.0",+]++[[package]]+name = "zbus_macros"+version = "4.4.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "267db9407081e90bbfa46d841d3cbc60f59c0351838c4bc65199ecd79ab1983e"+dependencies = [+ "proc-macro-crate",+ "proc-macro2",+ "quote",+ "syn",+ "zvariant_utils 2.1.0",+]++[[package]]+name = "zbus_macros"+version = "5.17.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5e05ad887425eecf5e8384dc2406a4a9313eb73468712fc1cdea362eb4fe0469"+dependencies = [+ "proc-macro-crate",+ "proc-macro2",+ "quote",+ "syn",+ "zbus_names 4.3.3",+ "zvariant 5.13.0",+ "zvariant_utils 3.5.0",+]++[[package]]+name = "zbus_names"+version = "3.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4b9b1fef7d021261cc16cba64c351d291b715febe0fa10dc3a443ac5a5022e6c"+dependencies = [+ "serde",+ "static_assertions",+ "zvariant 4.2.0",+]++[[package]]+name = "zbus_names"+version = "4.3.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1039ca249fee9559680f3a9f05b55e0761fee51af4f6c1e7d8c1f31e549721d2"+dependencies = [+ "serde",+ "winnow",+ "zvariant 5.13.0",+]++[[package]]+name = "zbus_xml"+version = "4.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ab3f374552b954f6abb4bd6ce979e6c9b38fb9d0cd7cc68a7d796e70c9f3a233"+dependencies = [+ "quick-xml 0.30.0",+ "serde",+ "static_assertions",+ "zbus_names 3.0.0",+ "zvariant 4.2.0",+]++[[package]]+name = "zerocopy"+version = "0.8.54"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b7cbbc0a705a0fd05cc3676525980d2bf5a9bc4adac6d6475209a7887cf59d19"+dependencies = [+ "zerocopy-derive",+]++[[package]]+name = "zerocopy-derive"+version = "0.8.54"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e2e817b7b52d0c7358d3246da9d69935ebb18116b2b102b4230dac079b4862f5"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "zerofrom"+version = "0.1.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"+dependencies = [+ "zerofrom-derive",+]++[[package]]+name = "zerofrom-derive"+version = "0.1.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+ "synstructure",+]++[[package]]+name = "zerotrie"+version = "0.2.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"+dependencies = [+ "displaydoc",+ "yoke",+ "zerofrom",+]++[[package]]+name = "zerovec"+version = "0.11.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"+dependencies = [+ "yoke",+ "zerofrom",+ "zerovec-derive",+]++[[package]]+name = "zerovec-derive"+version = "0.11.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "zmij"+version = "1.0.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"++[[package]]+name = "zune-core"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"++[[package]]+name = "zune-jpeg"+version = "0.5.15"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"+dependencies = [+ "zune-core",+]++[[package]]+name = "zvariant"+version = "4.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2084290ab9a1c471c38fc524945837734fbf124487e105daec2bb57fd48c81fe"+dependencies = [+ "endi",+ "enumflags2",+ "serde",+ "static_assertions",+ "zvariant_derive 4.2.0",+]++[[package]]+name = "zvariant"+version = "5.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7cf057bb00bf5c9ad77abb6147b0ca4818236a1858416e9d988e40d6322fefa7"+dependencies = [+ "endi",+ "enumflags2",+ "serde",+ "url",+ "winnow",+ "zvariant_derive 5.13.0",+ "zvariant_utils 3.5.0",+]++[[package]]+name = "zvariant_derive"+version = "4.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "73e2ba546bda683a90652bac4a279bc146adad1386f25379cf73200d2002c449"+dependencies = [+ "proc-macro-crate",+ "proc-macro2",+ "quote",+ "syn",+ "zvariant_utils 2.1.0",+]++[[package]]+name = "zvariant_derive"+version = "5.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8118ca6bda77bfc0ab51d660db0c955f2505eef854c9a449435bccb616933b31"+dependencies = [+ "proc-macro-crate",+ "proc-macro2",+ "quote",+ "syn",+ "zvariant_utils 3.5.0",+]++[[package]]+name = "zvariant_utils"+version = "2.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c51bcff7cc3dbb5055396bcf774748c3dab426b4b8659046963523cee4808340"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "zvariant_utils"+version = "3.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "90cb9383f9b45290407a1258b202d3f8f01db719eb60b4e4055c6375af4fc7c7"+dependencies = [+ "proc-macro2",+ "quote",+ "serde",+ "syn",+ "winnow",+]diff --git a/Cargo.toml b/Cargo.tomlnew file mode 100644index 0000000..632baab--- /dev/null+++ b/Cargo.toml@@ -0,0 +1,19 @@+[workspace]+resolver = "2"+members = [+ "crates/ghidrust-core",+ "crates/ghidrust-decomp",+ "crates/ghidrust-cli",+ "crates/ghidrust-gui",+]+default-members = ["crates/ghidrust-cli"]++[workspace.package]+version = "0.1.0"+edition = "2021"+license = "Apache-2.0"+repository = "https://github.com/example/ghidrust"++[workspace.dependencies]+ghidrust-core = { path = "crates/ghidrust-core" }+ghidrust-decomp = { path = "crates/ghidrust-decomp" }diff --git a/DEPENDENCIES.md b/DEPENDENCIES.mdnew file mode 100644index 0000000..da1e172--- /dev/null+++ b/DEPENDENCIES.md@@ -0,0 +1,26 @@+# Dependency policy++**Prefer hand-rolled, task-specific Rust.** Analysis core (loaders, x86-64 decode, RTTI, all Auto Analysis implementations under `src/analyzers/*`, program model, MCP protocol framing) is written in-tree with no third-party analysis crates.++## Allowed third-party++| Crate | Why |+|-------|-----|+| **egui / eframe** (and their transitive deps) | Interactive CodeBrowser shell with Material 3–inspired Dark/Light chrome (not a full Material library). |+| **serde / serde_json** | Minimal JSON for CLI `--json` and MCP JSON-RPC framing (stdio agent protocol). |+| **rayon** | Work-stealing CPU pool for bulk RE scans (strings / patterns / entropy windows). |+| **bincode** | Fast binary analysis persistence (`analysis.bin`) — multi-100MB pretty JSON is not viable for UI reopen. |+| **ghidrust-decomp** (workspace crate) | Hand-rolled decompile method (blocks/CFG → pseudo-C); not a third-party decompiler product. |+| **wgpu / pollster / bytemuck** (optional, feature `gpu`) | Experimental GPU compute bulk printable-mark kernel; auto CPU fallback without adapter. |++## Not used (on purpose)++- `goblin`, `object`, `pelite`, `scroll` — PE/ELF parsed by hand in `ghidrust-core`.+- `iced-x86`, `zydis`, `capstone` bindings — x86-64 decode hand-rolled for the MVP slice.+- Full `rmcp` / heavy MCP SDKs — thin hand-rolled tools/list + tools/call over stdio.++## Supply chain++- UI stack is the only large external surface; pin versions in workspace/crate `Cargo.toml`.+- No `unsafe` required in analysis paths for the MVP fixture set.+- Open-source RE crates may be **read as reference** only; logic is reimplemented here so this remains a contributable foundation.diff --git a/LICENSE b/LICENSEnew file mode 100644index 0000000..261eeb9--- /dev/null+++ b/LICENSE@@ -0,0 +1,201 @@+ Apache License+ Version 2.0, January 2004+ http://www.apache.org/licenses/++ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION++ 1. Definitions.++ "License" shall mean the terms and conditions for use, reproduction,+ and distribution as defined by Sections 1 through 9 of this document.++ "Licensor" shall mean the copyright owner or entity authorized by+ the copyright owner that is granting the License.++ "Legal Entity" shall mean the union of the acting entity and all+ other entities that control, are controlled by, or are under common+ control with that entity. For the purposes of this definition,+ "control" means (i) the power, direct or indirect, to cause the+ direction or management of such entity, whether by contract or+ otherwise, or (ii) ownership of fifty percent (50%) or more of the+ outstanding shares, or (iii) beneficial ownership of such entity.++ "You" (or "Your") shall mean an individual or Legal Entity+ exercising permissions granted by this License.++ "Source" form shall mean the preferred form for making modifications,+ including but not limited to software source code, documentation+ source, and configuration files.++ "Object" form shall mean any form resulting from mechanical+ transformation or translation of a Source form, including but+ not limited to compiled object code, generated documentation,+ and conversions to other media types.++ "Work" shall mean the work of authorship, whether in Source or+ Object form, made available under the License, as indicated by a+ copyright notice that is included in or attached to the work+ (an example is provided in the Appendix below).++ "Derivative Works" shall mean any work, whether in Source or Object+ form, that is based on (or derived from) the Work and for which the+ editorial revisions, annotations, elaborations, or other modifications+ represent, as a whole, an original work of authorship. For the purposes+ of this License, Derivative Works shall not include works that remain+ separable from, or merely link (or bind by name) to the interfaces of,+ the Work and Derivative Works thereof.++ "Contribution" shall mean any work of authorship, including+ the original version of the Work and any modifications or additions+ to that Work or Derivative Works thereof, that is intentionally+ submitted to Licensor for inclusion in the Work by the copyright owner+ or by an individual or Legal Entity authorized to submit on behalf of+ the copyright owner. For the purposes of this definition, "submitted"+ means any form of electronic, verbal, or written communication sent+ to the Licensor or its representatives, including but not limited to+ communication on electronic mailing lists, source code control systems,+ and issue tracking systems that are managed by, or on behalf of, the+ Licensor for the purpose of discussing and improving the Work, but+ excluding communication that is conspicuously marked or otherwise+ designated in writing by the copyright owner as "Not a Contribution."++ "Contributor" shall mean Licensor and any individual or Legal Entity+ on behalf of whom a Contribution has been received by Licensor and+ subsequently incorporated within the Work.++ 2. Grant of Copyright License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ copyright license to reproduce, prepare Derivative Works of,+ publicly display, publicly perform, sublicense, and distribute the+ Work and such Derivative Works in Source or Object form.++ 3. Grant of Patent License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ (except as stated in this section) patent license to make, have made,+ use, offer to sell, sell, import, and otherwise transfer the Work,+ where such license applies only to those patent claims licensable+ by such Contributor that are necessarily infringed by their+ Contribution(s) alone or by combination of their Contribution(s)+ with the Work to which such Contribution(s) was submitted. If You+ institute patent litigation against any entity (including a+ cross-claim or counterclaim in a lawsuit) alleging that the Work+ or a Contribution incorporated within the Work constitutes direct+ or contributory patent infringement, then any patent licenses+ granted to You under this License for that Work shall terminate+ as of the date such litigation is filed.++ 4. Redistribution. You may reproduce and distribute copies of the+ Work or Derivative Works thereof in any medium, with or without+ modifications, and in Source or Object form, provided that You+ meet the following conditions:++ (a) You must give any other recipients of the Work or+ Derivative Works a copy of this License; and++ (b) You must cause any modified files to carry prominent notices+ stating that You changed the files; and++ (c) You must retain, in the Source form of any Derivative Works+ that You distribute, all copyright, patent, trademark, and+ attribution notices from the Source form of the Work,+ excluding those notices that do not pertain to any part of+ the Derivative Works; and++ (d) If the Work includes a "NOTICE" text file as part of its+ distribution, then any Derivative Works that You distribute must+ include a readable copy of the attribution notices contained+ within such NOTICE file, excluding those notices that do not+ pertain to any part of the Derivative Works, in at least one+ of the following places: within a NOTICE text file distributed+ as part of the Derivative Works; within the Source form or+ documentation, if provided along with the Derivative Works; or,+ within a display generated by the Derivative Works, if and+ wherever such third-party notices normally appear. The contents+ of the NOTICE file are for informational purposes only and+ do not modify the License. You may add Your own attribution+ notices within Derivative Works that You distribute, alongside+ or as an addendum to the NOTICE text from the Work, provided+ that such additional attribution notices cannot be construed+ as modifying the License.++ You may add Your own copyright statement to Your modifications and+ may provide additional or different license terms and conditions+ for use, reproduction, or distribution of Your modifications, or+ for any such Derivative Works as a whole, provided Your use,+ reproduction, and distribution of the Work otherwise complies with+ the conditions stated in this License.++ 5. Submission of Contributions. Unless You explicitly state otherwise,+ any Contribution intentionally submitted for inclusion in the Work+ by You to the Licensor shall be under the terms and conditions of+ this License, without any additional terms or conditions.+ Notwithstanding the above, nothing herein shall supersede or modify+ the terms of any separate license agreement you may have executed+ with Licensor regarding such Contributions.++ 6. Trademarks. This License does not grant permission to use the trade+ names, trademarks, service marks, or product names of the Licensor,+ except as required for reasonable and customary use in describing the+ origin of the Work and reproducing the content of the NOTICE file.++ 7. Disclaimer of Warranty. Unless required by applicable law or+ agreed to in writing, Licensor provides the Work (and each+ Contributor provides its Contributions) on an "AS IS" BASIS,+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or+ implied, including, without limitation, any warranties or conditions+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A+ PARTICULAR PURPOSE. You are solely responsible for determining the+ appropriateness of using or redistributing the Work and assume any+ risks associated with Your exercise of permissions under this License.++ 8. Limitation of Liability. In no event and under no legal theory,+ whether in tort (including negligence), contract, or otherwise,+ unless required by applicable law (such as deliberate and grossly+ negligent acts) or agreed to in writing, shall any Contributor be+ liable to You for damages, including any direct, indirect, special,+ incidental, or consequential damages of any character arising as a+ result of this License or out of the use or inability to use the+ Work (including but not limited to damages for loss of goodwill,+ work stoppage, computer failure or malfunction, or any and all+ other commercial damages or losses), even if such Contributor+ has been advised of the possibility of such damages.++ 9. Accepting Warranty or Additional Liability. While redistributing+ the Work or Derivative Works thereof, You may choose to offer,+ and charge a fee for, acceptance of support, warranty, indemnity,+ or other liability obligations and/or rights consistent with this+ License. However, in accepting such obligations, You may act only+ on Your own behalf and on Your sole responsibility, not on behalf+ of any other Contributor, and only if You agree to indemnify,+ defend, and hold each Contributor harmless for any liability+ incurred by, or claims asserted against, such Contributor by reason+ of your accepting any such warranty or additional liability.++ END OF TERMS AND CONDITIONS++ APPENDIX: How to apply the Apache License to your work.++ To apply the Apache License to your work, attach the following+ boilerplate notice, with the fields enclosed by brackets "[]"+ replaced with your own identifying information. (Don't include+ the brackets!) The text should be enclosed in the appropriate+ comment syntax for the file format. We also recommend that a+ file or class name and description of purpose be included on the+ same "printed page" as the copyright notice for easier+ identification within third-party archives.++ Copyright [yyyy] [name of copyright owner]++ Licensed under the Apache License, Version 2.0 (the "License");+ you may not use this file except in compliance with the License.+ You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++ Unless required by applicable law or agreed to in writing, software+ distributed under the License is distributed on an "AS IS" BASIS,+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ See the License for the specific language governing permissions and+ limitations under the License.diff --git a/README.md b/README.mdnew file mode 100644index 0000000..7f96a49--- /dev/null+++ b/README.md@@ -0,0 +1,217 @@+# Ghidrust++Hand-rolled **Rust** reverse-engineering toolkit inspired by [Ghidra](https://github.com/NationalSecurityAgency/ghidra).++Ghidrust loads PE/ELF binaries, produces x86-64 listings, runs Auto Analysis, decompiles to pseudo-C, and saves durable projects — from a CLI, an MCP server for agents, or an egui CodeBrowser-style GUI.++It is **not** a Ghidra fork or wrapper. Analysis logic (loaders, decode, analyzers, decompile) is written in-tree so the core stays small, auditable, and freestanding.++---++## What it aims to achieve++| Goal | Meaning in practice |+|------|---------------------|+| **Ghidra-shaped workflow** | Familiar labels and surfaces (Auto Analysis names, project import/analyze/export, listing + decompile) without depending on the Ghidra JVM stack |+| **Hand-rolled core** | PE/ELF, x86-64 decode, RTTI, analyzers, and decompile implemented in Rust — third-party RE libraries are avoided on purpose ([DEPENDENCIES.md](DEPENDENCIES.md)) |+| **CPU-correct first** | CPU paths are the oracle; optional GPU paths must match or enrich them, not replace honesty with speed claims |+| **Agent-ready** | Headless CLI + stdio MCP so coding agents can load, disassemble, analyze, and decompile without a GUI |+| **Practical projects** | Create a workspace, import binaries, run analyzers, persist results (`analysis.bin`), reopen later |++**Non-goals (today):** full Ghidra/Hex-Rays parity, multi-ISA SLEIGH, debugger integration, or “GPU is always faster.”++---++## Experimental GPU feature++Ghidrust includes an **experimental** GPU path (wgpu / Vulkan) for two roles:++1. **Bulk RE** — parallel printable / pattern / RTTI-style scans where SIMT helps+2. **GPU-resident decompile** — multipass decompile kernels that keep mid-pipeline IR in **VRAM** (upload code once → device passes → download a `.gdecomp` dump)++Enabled by default on the CLI / decomp crates via the `gpu` feature. Without a Vulkan adapter, those paths fall back or report unavailability; **CPU decompile and analysis still work**.++Honest performance note: on small fixtures, GPU decompile is often **correct but slower wall-clock** than CPU because of adapter init and PCIe transfer — residency mid-pipeline is the research win, not automatic speedups. Details: [docs/GPU_DECOMPILER_RESEARCH.md](docs/GPU_DECOMPILER_RESEARCH.md), [docs/GPU_DECOMPILE_PROCESS.md](docs/GPU_DECOMPILE_PROCESS.md), [docs/GPU_ANALYZER_MATRIX.md](docs/GPU_ANALYZER_MATRIX.md).++---++## Build++**Requirements:** Rust stable (edition 2021), Windows / Linux / macOS. GPU features need a Vulkan-capable GPU when you use the default `gpu` build.++```bash+# Clone and enter the repo, then:++# Debug (fast compile)+cargo build --workspace++# Release (recommended for GUI and large binaries)+cargo build --workspace --release+```++Binaries:++| Binary | Path (after release build) |+|--------|----------------------------|+| CLI | `target/release/ghidrust` (`.exe` on Windows) |+| GUI | `target/release/ghidrust-gui` |++```bash+# CLI only+cargo build -p ghidrust-cli --release++# GUI only+cargo build -p ghidrust-gui --release++# Explicit GPU decomp + core bulk features+cargo build -p ghidrust-cli --release --features ghidrust-core/gpu+```++| Feature | Where | Purpose |+|---------|--------|---------|+| `gpu` (default on decomp / CLI) | `ghidrust-decomp` | GPU-resident decompile + related kernels |+| `gpu` | `ghidrust-core` | Bulk string / pattern GPU path |++```bash+# Run the test suite+cargo test --workspace+cargo test -p ghidrust-decomp+```++---++## Quick start++```bash+# Help+cargo run -p ghidrust-cli --release -- help+# or: ./target/release/ghidrust help++# Load / disassemble fixtures+./target/release/ghidrust load fixtures/tiny_x64.pe+./target/release/ghidrust disasm fixtures/tiny_x64.pe --count 16++# Auto Analysis+./target/release/ghidrust analyzers+./target/release/ghidrust analyze fixtures/analysis_lab.pe --analyzers "Function ID,Stack" --json++# CPU vs experimental GPU decompile+./target/release/ghidrust decompile fixtures/tiny_x64.pe+./target/release/ghidrust gpu-decompile fixtures/tiny_x64.pe --out entry.gdecomp --metrics metrics.log --json++# GUI+cargo run -p ghidrust-gui --release+```++Windows PowerShell: use `.\target\release\ghidrust.exe` and `.\target\release\ghidrust-gui.exe`.++Fixtures live under [`fixtures/`](fixtures/) (`tiny_x64.pe`, `analysis_lab.pe`, `tiny_x64.elf`).++---++## CLI reference++| Command | What it does |+|---------|----------------|+| `ghidrust load <path> [--json]` | Load PE/ELF, show map |+| `ghidrust disasm <path> [--addr HEX] [--count N]` | x86-64 listing |+| `ghidrust rtti <path>` | RTTI recovery only |+| `ghidrust analyzers` | List Auto Analysis names |+| `ghidrust analyze <path> [--analyzers a,b \| --analyzer NAME …] [--gpu]` | Run analyzers; `--gpu` = bulk strings + seed enrich |+| `ghidrust decompile <path> [--addr HEX]` | **CPU** decompile (pseudo-C) |+| `ghidrust gpu-decompile <path> [--out FILE] [--metrics FILE]` | **GPU-resident** multipass → `.gdecomp` |+| `ghidrust bulk-bench <path>` | Seq / parallel CPU / GPU bulk string timings |+| `ghidrust re-bench <path> [--out FILE]` | CPU decompile + bulk CPU then GPU metrics |+| `ghidrust analyzer-bench <path> [--large] [--out FILE]` | All analyzers + decompile: CPU vs GPU |+| `ghidrust analyzer-bench-matrix` | Print GPU strategy class per analyzer |+| `ghidrust rtti-gpu-bench <path> [--out FILE]` | CPU RTTI vs GPU `rtti_scan` |+| `ghidrust project create\|import\|list\|analyze\|export …` | Durable projects |+| `ghidrust mcp` | Stdio MCP tools for agents |++### Project workflow++```bash+./target/release/ghidrust project create ./MyProject --name Case1+./target/release/ghidrust project import ./MyProject ./samples/app.exe+./target/release/ghidrust project list ./MyProject+./target/release/ghidrust project analyze ./MyProject --analyzer "Function Start Search" --analyzer "ASCII Strings" --gpu+./target/release/ghidrust project export ./MyProject+```++On-disk layout:++```+MyProject/+ ghidrust.project.json+ imports/ # copied binaries+ results/<file_id>/+ analysis.bin # primary (fast bincode)+ summary.json+ analysis.json+ exports/+```++### GUI workflow++1. Open/create a project (folder with `ghidrust.project.json`), or continue without one.+2. **Browse…** / **Import** a PE or ELF.+3. Double-click a file in the Project Tree.+4. **Analyze…** → choose analyzers (optional GPU bulk for strings).+5. Results save under `results/<id>/` for fast reopen.++---++## Architecture++```+┌─────────────┐ ┌──────────────────┐ ┌─────────────────┐+│ ghidrust-gui│ │ ghidrust-cli │ │ MCP stdio │+└──────┬──────┘ └────────┬─────────┘ └────────┬────────┘+ ▼+ ┌─────────────────┐+ │ ghidrust-core │ loaders, disasm, analyzers, bulk GPU+ └────────┬────────┘+ ▼+ ┌─────────────────┐+ │ ghidrust-decomp │ CPU decompile + GPU VRAM multipass+ └─────────────────┘+```++| Crate | Role |+|-------|------|+| `ghidrust-core` | PE/ELF, x86-64, analyzers, projects, bulk scan |+| `ghidrust-decomp` | Hand-rolled decompile (CPU + experimental GPU) |+| `ghidrust-cli` | CLI + MCP + benches / `gpu-decompile` |+| `ghidrust-gui` | CodeBrowser-style UI |++Recommended early analyzer order: **Function Start Search** → address tables → conventions/stack → strings/RTTI (`ghidrust analyzers` for the full list).++---++## MCP and agent skill++```bash+./target/release/ghidrust mcp+```++JSON-RPC over stdio: `load`, `disassemble`, `rtti`, `list_analyzers`, `analyze`.++Optional agent skill (Cursor, Grok, and other skill-aware tools): [skill/SKILL.md](skill/SKILL.md) — install notes in [skill/README.md](skill/README.md).++---++## Docs++| Doc | Topic |+|-----|--------|+| [docs/GPU_DECOMPILER_RESEARCH.md](docs/GPU_DECOMPILER_RESEARCH.md) | Research paper: GPU decompile method + results |+| [docs/GPU_DECOMPILE_PROCESS.md](docs/GPU_DECOMPILE_PROCESS.md) | Multipass dataflow + dump format |+| [docs/GPU_ANALYZER_MATRIX.md](docs/GPU_ANALYZER_MATRIX.md) | Per-analyzer GPU strategy + bench CLI |+| [docs/PARALLEL_RE_RESEARCH.md](docs/PARALLEL_RE_RESEARCH.md) | CPU pool vs GPU bulk RE |+| [DEPENDENCIES.md](DEPENDENCIES.md) | Dependency policy |++---++## License++[Apache License 2.0](LICENSE) — same license as [Ghidra](https://github.com/NationalSecurityAgency/ghidra).diff --git a/crates/ghidrust-cli/Cargo.toml b/crates/ghidrust-cli/Cargo.tomlnew file mode 100644index 0000000..4f6821b--- /dev/null+++ b/crates/ghidrust-cli/Cargo.toml@@ -0,0 +1,16 @@+[package]+name = "ghidrust-cli"+version.workspace = true+edition.workspace = true+license.workspace = true+description = "Ghidrust CLI and MCP/agent tool surface"++[[bin]]+name = "ghidrust"+path = "src/main.rs"++[dependencies]+ghidrust-core = { workspace = true, features = ["gpu"] }+ghidrust-decomp = { workspace = true, features = ["gpu"] }+serde = { version = "1", features = ["derive"] }+serde_json = "1"diff --git a/crates/ghidrust-cli/src/main.rs b/crates/ghidrust-cli/src/main.rsnew file mode 100644index 0000000..f8dcca0--- /dev/null+++ b/crates/ghidrust-cli/src/main.rs@@ -0,0 +1,1674 @@+//! Ghidrust CLI + stdio MCP/agent tool surface over ghidrust-core.++use ghidrust_core::{+ analyzer_catalog, analyze_path, disassemble_range, load_path, recover_rtti,+ scan_ascii_strings_bulk, scan_printable_runs_gpu_or_fallback, scan_printable_runs_parallel,+ scan_printable_runs_seq, time_bulk_printable, AnalysisBundle, BulkScanMode, Program, Project,+ ANALYZER_NAMES,+};+use ghidrust_decomp::decompile_entry;+use serde::Serialize;+use serde_json::{json, Value};+use std::env;+use std::io::{self, BufRead, Write};+use std::path::{Path, PathBuf};+use std::process::ExitCode;+use std::time::Instant;++fn main() -> ExitCode {+ let mut args: Vec<String> = env::args().skip(1).collect();+ if args.is_empty() {+ print_help();+ return ExitCode::from(2);+ }+ let json_mode = args.iter().any(|a| a == "--json");+ args.retain(|a| a != "--json");++ match args[0].as_str() {+ "help" | "-h" | "--help" => {+ print_help();+ ExitCode::SUCCESS+ }+ "load" => cmd_load(&args[1..], json_mode),+ "disasm" | "disassemble" => cmd_disasm(&args[1..], json_mode),+ "rtti" => cmd_rtti(&args[1..], json_mode),+ "analyzers" => cmd_analyzers(json_mode),+ "analyze" => cmd_analyze(&args[1..], json_mode),+ "bulk-bench" => cmd_bulk_bench(&args[1..], json_mode),+ "decompile" => cmd_decompile(&args[1..], json_mode),+ "gpu-decompile" => cmd_gpu_decompile(&args[1..], json_mode),+ "re-bench" => cmd_re_bench(&args[1..], json_mode),+ "analyzer-bench" => cmd_analyzer_bench(&args[1..], json_mode),+ "analyzer-bench-matrix" => {+ print!("{}", ghidrust_core::format_matrix_table());+ ExitCode::SUCCESS+ }+ "rtti-gpu-bench" => cmd_rtti_gpu_bench(&args[1..], json_mode),+ "project" => cmd_project(&args[1..], json_mode),+ "mcp" => run_mcp_stdio(),+ other => {+ eprintln!("unknown command: {other}");+ print_help();+ ExitCode::from(2)+ }+ }+}++fn print_help() {+ eprintln!(+ "ghidrust — AI-native reverse-engineering (CodeBrowser headless)\n\n\+ Usage:\n\+ ghidrust load <path> [--json]\n\+ ghidrust disasm <path> [--addr <hex>] [--count N] [--json]\n\+ ghidrust rtti <path> [--json]\n\+ ghidrust analyzers [--json]\n\+ ghidrust analyze <path> [--analyzers a,b | --analyzer NAME ...] [--gpu] [--json]\n\+ ghidrust bulk-bench <path> [--json] # seq vs parallel vs GPU/fallback timings\n\+ ghidrust decompile <path> [--addr HEX] [--count N] [--json]\n\+ ghidrust gpu-decompile <path> [--out FILE] [--metrics FILE] [--json]\n\+ ghidrust re-bench <path> [--out FILE] [--json] # CPU then GPU metrics (decomp+bulk)\n\+ ghidrust analyzer-bench <path> [--large] [--out FILE] [--json]\n\+ ghidrust analyzer-bench-matrix\n\+ ghidrust rtti-gpu-bench <path> [--out FILE] [--json] # CPU RTTI vs GPU rtti_scan (PCIe split)\n\+ ghidrust project create <dir> [--name NAME]\n\+ ghidrust project open <dir>\n\+ ghidrust project import <dir> <binary>\n\+ ghidrust project list <dir>\n\+ ghidrust project analyze <dir> [--file ID] [--analyzers a,b | --analyzer NAME ...] [--gpu]\n\+ ghidrust project export <dir> [--file ID] # paths of saved listing/analysis\n\+ ghidrust mcp\n\+ See README.md for projects, saving results, and analyzer list.\n"+ );+}++fn cmd_project(args: &[String], json: bool) -> ExitCode {+ if args.is_empty() {+ eprintln!("project subcommand required: create|open|import|list|analyze|export");+ return ExitCode::from(2);+ }+ match args[0].as_str() {+ "create" => {+ let dir = match args.get(1) {+ Some(d) => PathBuf::from(d),+ None => {+ eprintln!("usage: ghidrust project create <dir> [--name NAME]");+ return ExitCode::from(2);+ }+ };+ let mut name = dir+ .file_name()+ .map(|s| s.to_string_lossy().into_owned())+ .unwrap_or_else(|| "GhidrustProject".into());+ let mut i = 2;+ while i < args.len() {+ if args[i] == "--name" && i + 1 < args.len() {+ name = args[i + 1].clone();+ i += 2;+ } else {+ i += 1;+ }+ }+ match Project::create(&dir, name) {+ Ok(p) => {+ if json {+ println!(+ "{}",+ serde_json::to_string_pretty(&p.meta).unwrap()+ );+ } else {+ println!("created project '{}' at {}", p.meta.name, p.root.display());+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+ }+ "open" | "list" => {+ let dir = match args.get(1) {+ Some(d) => PathBuf::from(d),+ None => {+ eprintln!("usage: ghidrust project list <dir>");+ return ExitCode::from(2);+ }+ };+ match Project::open(&dir) {+ Ok(p) => {+ if json {+ println!("{}", serde_json::to_string_pretty(&p.meta).unwrap());+ } else {+ println!("project: {} ({})", p.meta.name, p.root.display());+ println!("files:");+ for f in p.list_files() {+ let mark = if p.meta.active_id.as_deref() == Some(&f.id) {+ "*"+ } else {+ " "+ };+ println!(+ " {mark} id={} {} ({})",+ f.id, f.display_name, f.imported_rel+ );+ }+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+ }+ "import" => {+ if args.len() < 3 {+ eprintln!("usage: ghidrust project import <project-dir> <binary>");+ return ExitCode::from(2);+ }+ let dir = PathBuf::from(&args[1]);+ let bin = PathBuf::from(&args[2]);+ match Project::open(&dir).and_then(|mut p| {+ let e = p.import_file(&bin)?;+ Ok((p, e))+ }) {+ Ok((p, e)) => {+ if json {+ println!("{}", serde_json::to_string_pretty(&e).unwrap());+ } else {+ println!(+ "imported {} as id={} -> {}",+ e.display_name,+ e.id,+ p.binary_path(&e).display()+ );+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+ }+ "analyze" => {+ if args.len() < 2 {+ eprintln!(+ "usage: ghidrust project analyze <dir> [--file ID] [--analyzers a,b | --analyzer NAME ...] [--gpu]"+ );+ return ExitCode::from(2);+ }+ let dir = PathBuf::from(&args[1]);+ let mut file_id: Option<String> = None;+ let mut analyzers: Vec<String> = Vec::new();+ let mut use_gpu = false;+ let mut i = 2;+ while i < args.len() {+ match args[i].as_str() {+ "--file" if i + 1 < args.len() => {+ file_id = Some(args[i + 1].clone());+ i += 2;+ }+ "--analyzers" if i + 1 < args.len() => {+ for s in args[i + 1].split(',') {+ let t = s.trim();+ if !t.is_empty() {+ analyzers.push(t.to_string());+ }+ }+ i += 2;+ }+ "--analyzer" if i + 1 < args.len() => {+ analyzers.push(args[i + 1].clone());+ i += 2;+ }+ "--gpu" => {+ use_gpu = true;+ i += 1;+ }+ _ => i += 1,+ }+ }+ match Project::open(&dir) {+ Ok(p) => {+ let entry = if let Some(id) = file_id {+ p.meta.files.iter().find(|f| f.id == id).cloned()+ } else {+ p.active_file().cloned().or_else(|| p.meta.files.first().cloned())+ };+ let Some(entry) = entry else {+ eprintln!("no files in project — import a binary first");+ return ExitCode::FAILURE;+ };+ let names: Vec<&str> = if analyzers.is_empty() {+ ANALYZER_NAMES.to_vec()+ } else {+ analyzers.iter().map(|s| s.as_str()).collect()+ };+ match p.analyze_file_opts(&entry, &names, use_gpu) {+ Ok((_prog, saved)) => {+ if json {+ println!("{}", serde_json::to_string_pretty(&saved).unwrap());+ } else {+ println!(+ "analyzed {} — {} functions, {} listing lines",+ entry.display_name,+ saved.analysis.functions.len(),+ saved.listing.len()+ );+ println!("results: {}", p.analysis_path(&entry.id).display());+ println!("listing: {}", p.listing_export_path(&entry.id).display());+ println!("export: {}", p.analysis_export_path(&entry.id).display());+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+ }+ "export" => {+ if args.len() < 2 {+ eprintln!("usage: ghidrust project export <dir> [--file ID]");+ return ExitCode::from(2);+ }+ let dir = PathBuf::from(&args[1]);+ let mut file_id: Option<String> = None;+ let mut i = 2;+ while i < args.len() {+ if args[i] == "--file" && i + 1 < args.len() {+ file_id = Some(args[i + 1].clone());+ i += 2;+ } else {+ i += 1;+ }+ }+ match Project::open(&dir) {+ Ok(p) => {+ let entry = if let Some(id) = file_id {+ p.meta.files.iter().find(|f| f.id == id)+ } else {+ p.active_file().or_else(|| p.meta.files.first())+ };+ let Some(entry) = entry else {+ eprintln!("no files");+ return ExitCode::FAILURE;+ };+ let a = p.analysis_path(&entry.id);+ let l = p.listing_export_path(&entry.id);+ let e = p.analysis_export_path(&entry.id);+ if json {+ println!(+ "{}",+ json!({+ "analysis": a.display().to_string(),+ "listing": l.display().to_string(),+ "export": e.display().to_string(),+ "exists": a.is_file(),+ })+ );+ } else {+ println!("analysis: {} ({})", a.display(), if a.is_file() { "ok" } else { "missing — run project analyze" });+ println!("listing: {} ({})", l.display(), if l.is_file() { "ok" } else { "missing" });+ println!("export: {} ({})", e.display(), if e.is_file() { "ok" } else { "missing" });+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+ }+ other => {+ eprintln!("unknown project subcommand: {other}");+ ExitCode::from(2)+ }+ }+}++fn path_arg(args: &[String]) -> Result<PathBuf, String> {+ args.first()+ .map(PathBuf::from)+ .ok_or_else(|| "missing path".into())+}++fn cmd_load(args: &[String], json: bool) -> ExitCode {+ match path_arg(args).and_then(|p| load_path(&p).map_err(|e| e.to_string())) {+ Ok(prog) => {+ emit_load(&prog, json);+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+}++fn emit_load(prog: &Program, json: bool) {+ if json {+ let v = json!({+ "name": prog.name,+ "format": prog.format,+ "image_base": format!("{:#x}", prog.image_base),+ "entry": prog.entry.map(|e| format!("{e:#x}")),+ "sections": prog.sections.iter().map(|s| json!({+ "name": s.name,+ "va": format!("{:#x}", s.va),+ "virtual_size": s.virtual_size,+ "raw_size": s.raw_size,+ })).collect::<Vec<_>>(),+ });+ println!("{}", serde_json::to_string_pretty(&v).unwrap());+ } else {+ println!("name: {}", prog.name);+ println!("format: {}", prog.format);+ println!("base: {:#x}", prog.image_base);+ if let Some(e) = prog.entry {+ println!("entry: {e:#x}");+ }+ println!("sections:");+ for s in &prog.sections {+ println!(+ " {:8} va={:#x} vsize={:#x} raw={:#x}",+ s.name, s.va, s.virtual_size, s.raw_size+ );+ }+ }+}++fn cmd_disasm(args: &[String], json: bool) -> ExitCode {+ let path = match path_arg(args) {+ Ok(p) => p,+ Err(e) => {+ eprintln!("{e}");+ return ExitCode::from(2);+ }+ };+ let mut addr: Option<u64> = None;+ let mut count: usize = 16;+ let mut i = 1;+ while i < args.len() {+ match args[i].as_str() {+ "--addr" if i + 1 < args.len() => {+ addr = parse_u64(&args[i + 1]).ok();+ i += 2;+ }+ "--count" if i + 1 < args.len() => {+ count = args[i + 1].parse().unwrap_or(16);+ i += 2;+ }+ _ => i += 1,+ }+ }+ match load_path(&path) {+ Ok(prog) => {+ let start = addr.or(prog.entry).unwrap_or(prog.image_base);+ match disassemble_range(&prog, start, count) {+ Ok(listing) => {+ if json {+ println!("{}", serde_json::to_string_pretty(&listing).unwrap());+ } else {+ for insn in &listing {+ println!("{}", insn.text());+ }+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+}++fn cmd_rtti(args: &[String], json: bool) -> ExitCode {+ let path = match path_arg(args) {+ Ok(p) => p,+ Err(e) => {+ eprintln!("{e}");+ return ExitCode::from(2);+ }+ };+ match load_path(&path).and_then(|p| recover_rtti(&p).map(|r| (p, r))) {+ Ok((_prog, report)) => {+ if json {+ println!("{}", serde_json::to_string_pretty(&report).unwrap());+ } else {+ for c in &report.classes {+ println!(+ "class {} type_info={} vtable={} col={} ({})",+ c.name,+ fmt_opt_va(c.type_info_va),+ fmt_opt_va(c.vtable_va),+ fmt_opt_va(c.col_va),+ c.kind+ );+ }+ for n in &report.notes {+ println!("note: {n}");+ }+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+}++fn cmd_bulk_bench(args: &[String], json: bool) -> ExitCode {+ let path = match args.first() {+ Some(p) => PathBuf::from(p),+ None => {+ eprintln!("usage: ghidrust bulk-bench <path> [--json]");+ return ExitCode::from(2);+ }+ };+ let prog = match load_path(&path) {+ Ok(p) => p,+ Err(e) => {+ eprintln!("load error: {e}");+ return ExitCode::from(1);+ }+ };+ // Concatenate all blocks for a single bulk haystack (transfer-style bulk RE).+ let mut hay = Vec::new();+ for b in &prog.blocks {+ hay.extend_from_slice(&b.bytes);+ }+ // Pad synthetic bulk so PCIe/thread overhead is measurable without fake wins.+ if hay.len() < 2 * 1024 * 1024 {+ let mut big = hay.clone();+ while big.len() < 4 * 1024 * 1024 {+ big.extend_from_slice(&hay);+ if hay.is_empty() {+ big.resize(4 * 1024 * 1024, 0);+ break;+ }+ }+ hay = big;+ }+ let timing = time_bulk_printable(&hay, 4);+ let (seq_s, _) = scan_ascii_strings_bulk(&prog, 4, BulkScanMode::Sequential);+ let (par_s, par_b) = scan_ascii_strings_bulk(&prog, 4, BulkScanMode::ParallelCpu);+ let (gpu_s, gpu_b) = scan_ascii_strings_bulk(&prog, 4, BulkScanMode::GpuOrFallback);+ if seq_s != par_s || seq_s != gpu_s {+ eprintln!(+ "correctness fail: seq={} par={} gpu={}",+ seq_s.len(),+ par_s.len(),+ gpu_s.len()+ );+ return ExitCode::from(1);+ }+ if json {+ let v = json!({+ "timing": timing,+ "program_strings": seq_s.len(),+ "program_par_backend": format!("{par_b:?}"),+ "program_gpu_backend": format!("{gpu_b:?}"),+ });+ println!("{}", serde_json::to_string_pretty(&v).unwrap());+ } else {+ println!(+ "bulk-bench {} bytes threads={} seq_ms={:.3} par_ms={:.3} gpu_ms={:.3} hits={}",+ timing.bytes,+ timing.threads,+ timing.seq_ms,+ timing.par_ms,+ timing.gpu_ms,+ timing.seq_hits+ );+ println!("par_backend={:?}", timing.par_backend);+ println!("gpu_backend={:?}", timing.gpu_backend);+ println!(+ "program ASCII strings: {} (seq/par/gpu equal) par={:?} gpu={:?}",+ seq_s.len(),+ par_b,+ gpu_b+ );+ }+ ExitCode::SUCCESS+}++fn cmd_analyzer_bench(args: &[String], json: bool) -> ExitCode {+ let path = match args.first() {+ Some(p) => PathBuf::from(p),+ None => {+ eprintln!("usage: ghidrust analyzer-bench <path> [--large] [--out FILE] [--json]");+ return ExitCode::from(2);+ }+ };+ let large = args.iter().any(|a| a == "--large");+ let mut out_path: Option<PathBuf> = None;+ let mut i = 1;+ while i < args.len() {+ if args[i] == "--out" && i + 1 < args.len() {+ out_path = Some(PathBuf::from(&args[i + 1]));+ i += 2;+ } else {+ i += 1;+ }+ }+ let prog = match load_path(&path) {+ Ok(p) => p,+ Err(e) => {+ eprintln!("load error: {e}");+ return ExitCode::FAILURE;+ }+ };+ let large_min = if large { Some(8 * 1024 * 1024) } else { None };+ let mut rows = ghidrust_core::bench_all_analyzers(&prog, large_min);+ rows.push(ghidrust_core::bench_gpu_decompile_row(&prog));+ // Full GPU decompile multipass via shipped bench API (CPU wall + multipass oracle).+ {+ let tmp = std::env::temp_dir().join("ghidrust_ab_decomp.gdecomp");+ if let Ok(b) = ghidrust_decomp::bench_vram_decompile_vs_cpu(&prog, &tmp, 256) {+ rows.push(ghidrust_core::AnalyzerBenchRow {+ name: "GPU Decompile VRAM multipass".into(),+ strategy: "decomp_multipass".into(),+ cpu_ms: b.cpu_ms,+ cpu_primary: b.cpu_ir,+ gpu_pcie_upload_ms: b.gpu_pcie_upload_ms,+ gpu_device_ms: b.gpu_device_ms,+ gpu_pcie_download_ms: b.gpu_pcie_download_ms,+ gpu_pcie_ms: b.gpu_pcie_ms,+ gpu_wall_ms: b.gpu_wall_ms,+ gpu_primary: b.gpu_ir,+ equal: b.equal,+ backend: b.backend,+ device: b.device,+ note: format!(+ "mid_pipeline_host_reads={} text_eq={} ir_eq={} pcie={:.3} device={:.3} cpu_blocks={} gpu_blocks={} | {}",+ b.mid_pipeline_host_reads,+ b.text_eq,+ b.ir_eq,+ b.gpu_pcie_ms,+ b.gpu_device_ms,+ b.cpu_blocks,+ b.gpu_blocks,+ b.note+ ),+ analyzer_oracle: b.cpu_blocks,+ merged_primary: b.gpu_blocks,+ });+ }+ }++ let mut log = String::from("=== analyzer CPU vs GPU bench ===\n");+ log.push_str(&format!(+ "file={} large={} analyzers={}\n",+ path.display(),+ large,+ rows.len()+ ));+ log.push_str("name\tstrategy\tcpu_ms\tcpu_n\tpcie_up\tdevice_ms\tpcie_dn\tpcie_ms\tgpu_wall\tgpu_n\tequal\tbackend\tdevice\n");+ for r in &rows {+ log.push_str(&format!(+ "{}\t{}\t{:.3}\t{}\t{:.3}\t{:.3}\t{:.3}\t{:.3}\t{:.3}\t{}\t{}\t{}\t{}\n",+ r.name,+ r.strategy,+ r.cpu_ms,+ r.cpu_primary,+ r.gpu_pcie_upload_ms,+ r.gpu_device_ms,+ r.gpu_pcie_download_ms,+ r.gpu_pcie_ms,+ r.gpu_wall_ms,+ r.gpu_primary,+ r.equal,+ r.backend,+ r.device+ ));+ }+ if let Some(p) = out_path {+ let _ = std::fs::write(&p, &log);+ let _ = std::fs::write(+ p.with_extension("json"),+ serde_json::to_string_pretty(&rows).unwrap_or_default(),+ );+ eprintln!("wrote {}", p.display());+ }+ if json {+ println!("{}", serde_json::to_string_pretty(&rows).unwrap());+ } else {+ print!("{log}");+ }+ ExitCode::SUCCESS+}++/// RTTI-focused CPU recover_rtti + GPU rtti_scan seed path with PCIe vs on-device split.+fn cmd_rtti_gpu_bench(args: &[String], json: bool) -> ExitCode {+ use std::time::Instant;+ let path = match args.first() {+ Some(p) => PathBuf::from(p),+ None => {+ eprintln!("usage: ghidrust rtti-gpu-bench <path> [--out FILE] [--json]");+ return ExitCode::from(2);+ }+ };+ let mut out_path: Option<PathBuf> = None;+ let mut i = 1;+ while i < args.len() {+ if args[i] == "--out" && i + 1 < args.len() {+ out_path = Some(PathBuf::from(&args[i + 1]));+ i += 2;+ } else {+ i += 1;+ }+ }++ let t_load = Instant::now();+ let prog = match load_path(&path) {+ Ok(p) => p,+ Err(e) => {+ eprintln!("load error: {e}");+ return ExitCode::FAILURE;+ }+ };+ let load_ms = t_load.elapsed().as_secs_f64() * 1000.0;+ let file_bytes = std::fs::metadata(&path).map(|m| m.len()).unwrap_or(0);+ let image_bytes: usize = prog.blocks.iter().map(|b| b.bytes.len()).sum();++ // CPU full RTTI recovery (oracle / product path)+ let t_cpu = Instant::now();+ let rtti = match recover_rtti(&prog) {+ Ok(r) => r,+ Err(e) => {+ eprintln!("cpu rtti error: {e}");+ return ExitCode::FAILURE;+ }+ };+ let cpu_rtti_ms = t_cpu.elapsed().as_secs_f64() * 1000.0;++ // Analyzer-shaped primary (same name as Auto Analysis option)+ let name = "WindowsPE x86 PE RTTI Analyzer";+ let row = ghidrust_core::bench_analyzer(&prog, name, None);++ let report = json!({+ "file": path.display().to_string(),+ "file_bytes": file_bytes,+ "file_mb": (file_bytes as f64) / (1024.0 * 1024.0),+ "image_bytes": image_bytes,+ "load_ms": load_ms,+ "cpu_rtti_recover_ms": cpu_rtti_ms,+ "cpu_rtti_classes": rtti.classes.len(),+ "gpu_strategy": row.strategy,+ "gpu_seed_cpu_ms": row.cpu_ms,+ "gpu_seed_cpu_hits": row.cpu_primary,+ "gpu_pcie_upload_ms": row.gpu_pcie_upload_ms,+ "gpu_device_ms": row.gpu_device_ms,+ "gpu_pcie_download_ms": row.gpu_pcie_download_ms,+ "gpu_pcie_ms": row.gpu_pcie_ms,+ "gpu_wall_ms": row.gpu_wall_ms,+ "gpu_seed_hits": row.gpu_primary,+ "seed_equal": row.equal,+ "merged_primary": row.merged_primary,+ "backend": row.backend,+ "device": row.device,+ "note": row.note,+ "performance_model": {+ "on_device_vs_seed_cpu": if row.cpu_ms > 0.0 {+ row.cpu_ms / row.gpu_device_ms.max(1e-9)+ } else { 0.0 },+ "pcie_vs_device": row.gpu_pcie_ms / row.gpu_device_ms.max(1e-9),+ "summary": "On-device SIMT is often much faster than the CPU seed scan; PCIe upload of the image + cold GPU setup usually dominate wall time. A ~170MB PE does not make GPU compute slow — transfer cost scales with size."+ }+ });++ let mut log = String::new();+ log.push_str("=== RTTI CPU vs GPU bench ===\n");+ log.push_str(&format!(+ "file={} size_mb={:.2} image_bytes={}\n",+ path.display(),+ (file_bytes as f64) / (1024.0 * 1024.0),+ image_bytes+ ));+ log.push_str(&format!(+ "load_ms={:.3} cpu_rtti_recover_ms={:.3} cpu_classes={}\n",+ load_ms,+ cpu_rtti_ms,+ rtti.classes.len()+ ));+ log.push_str(&format!(+ "gpu_strategy={} backend={} device={}\n",+ row.strategy, row.backend, row.device+ ));+ log.push_str(&format!(+ "seed_cpu_ms={:.3} seed_cpu_hits={} | pcie_up={:.3} device_ms={:.3} pcie_dn={:.3} pcie_ms={:.3} gpu_wall={:.3} gpu_hits={} equal={}\n",+ row.cpu_ms,+ row.cpu_primary,+ row.gpu_pcie_upload_ms,+ row.gpu_device_ms,+ row.gpu_pcie_download_ms,+ row.gpu_pcie_ms,+ row.gpu_wall_ms,+ row.gpu_primary,+ row.equal+ ));+ log.push_str(&format!(+ "on_device_speedup_vs_seed_cpu={:.1}x pcie/device={:.1}x\n",+ if row.cpu_ms > 0.0 {+ row.cpu_ms / row.gpu_device_ms.max(1e-9)+ } else {+ 0.0+ },+ row.gpu_pcie_ms / row.gpu_device_ms.max(1e-9)+ ));+ log.push_str(+ "NOTE: GPU on-device kernel time is separate from PCIe. Large PE transfer cost is real; it is not 'slow GPU compute'.\n",+ );++ if let Some(p) = out_path {+ let _ = std::fs::write(&p, &log);+ let _ = std::fs::write(+ p.with_extension("json"),+ serde_json::to_string_pretty(&report).unwrap_or_default(),+ );+ eprintln!("wrote {}", p.display());+ }+ if json {+ println!("{}", serde_json::to_string_pretty(&report).unwrap());+ } else {+ print!("{log}");+ }+ ExitCode::SUCCESS+}++fn cmd_gpu_decompile(args: &[String], json: bool) -> ExitCode {+ let path = match args.first() {+ Some(p) => PathBuf::from(p),+ None => {+ eprintln!(+ "usage: ghidrust gpu-decompile <path> [--out FILE] [--metrics FILE] [--json]"+ );+ return ExitCode::from(2);+ }+ };+ let mut out_path = PathBuf::from("ghidrust_gpu_decompile.gdecomp");+ let mut metrics_path: Option<PathBuf> = None;+ let mut i = 1;+ while i < args.len() {+ match args[i].as_str() {+ "--out" if i + 1 < args.len() => {+ out_path = PathBuf::from(&args[i + 1]);+ i += 2;+ }+ "--metrics" if i + 1 < args.len() => {+ metrics_path = Some(PathBuf::from(&args[i + 1]));+ i += 2;+ }+ _ => i += 1,+ }+ }+ let prog = match load_path(&path) {+ Ok(p) => p,+ Err(e) => {+ eprintln!("load error: {e}");+ return ExitCode::FAILURE;+ }+ };+ let t_cpu = Instant::now();+ let cpu = match ghidrust_decomp::decompile_entry(&prog, 64) {+ Ok(d) => d,+ Err(e) => {+ eprintln!("cpu decompile: {e}");+ return ExitCode::FAILURE;+ }+ };+ let cpu_ms = t_cpu.elapsed().as_secs_f64() * 1000.0;++ let rep = match ghidrust_decomp::gpu_decompile_to_file(&prog, None, &out_path, 128) {+ Ok(r) => r,+ Err(e) => {+ eprintln!("gpu-decompile error: {e}");+ return ExitCode::FAILURE;+ }+ };++ // Equivalence: multipass algorithm (GPU dump vs CPU multipass on same code)+ let entry = rep.entry;+ let (code, _) = match ghidrust_decomp::region_bytes(&prog, entry, 128) {+ Ok(v) => v,+ Err(e) => {+ eprintln!("region: {e}");+ return ExitCode::FAILURE;+ }+ };+ let multi = ghidrust_decomp::multipass_cpu_decompile_from_code(&rep.name, entry, &code);+ let equal = ghidrust_decomp::normalize_pseudo(&rep.pseudo_c)+ == ghidrust_decomp::normalize_pseudo(&multi.pseudo_c);++ let metrics = json!({+ "file": path.display().to_string(),+ "cpu_decompile_ms": cpu_ms,+ "cpu_blocks": cpu.blocks.len(),+ "cpu_chars": cpu.char_count(),+ "gpu_backend": rep.backend,+ "gpu_device": rep.device,+ "gpu_ms": rep.ms,+ "mid_pipeline_host_reads": rep.mid_pipeline_host_reads,+ "kernels": rep.kernels_dispatched,+ "dump_path": rep.dump_path,+ "dump_bytes": rep.dump_bytes,+ "gpu_ir_count": rep.ir_count,+ "gpu_block_count": rep.block_count,+ "gpu_edge_count": rep.edge_count,+ "equivalence_multipass": equal,+ "pseudo_c_head": rep.pseudo_c.lines().take(6).collect::<Vec<_>>().join("\n"),+ });++ if let Some(mp) = metrics_path {+ let text = format!(+ "=== GPU-resident full decompile metrics ===\n\+ file: {}\n\+ cpu_decompile_ms: {:.3}\n\+ gpu_backend: {}\n\+ gpu_device: {}\n\+ gpu_ms: {:.3}\n\+ mid_pipeline_host_reads: {}\n\+ kernels: {:?}\n\+ dump_path: {}\n\+ dump_bytes: {}\n\+ ir/blocks/edges: {}/{}/{}\n\+ equivalence_multipass: {}\n\+ note: VRAM multipass decode→leaders→blocks→emit; single final dump\n",+ path.display(),+ cpu_ms,+ rep.backend,+ rep.device,+ rep.ms,+ rep.mid_pipeline_host_reads,+ rep.kernels_dispatched,+ rep.dump_path,+ rep.dump_bytes,+ rep.ir_count,+ rep.block_count,+ rep.edge_count,+ equal,+ );+ let _ = std::fs::write(&mp, &text);+ let _ = std::fs::write(+ mp.with_extension("json"),+ serde_json::to_string_pretty(&metrics).unwrap(),+ );+ eprintln!("metrics → {}", mp.display());+ }++ if json {+ println!("{}", serde_json::to_string_pretty(&metrics).unwrap());+ } else {+ println!("GPU decompile dump → {}", out_path.display());+ println!(+ "backend={} device={} ms={:.3} mid_reads={} equal={}",+ rep.backend, rep.device, rep.ms, rep.mid_pipeline_host_reads, equal+ );+ print!("{}", rep.pseudo_c);+ }+ if !equal {+ eprintln!("warning: multipass equivalence failed (see dump vs CPU multipass)");+ return ExitCode::FAILURE;+ }+ if rep.mid_pipeline_host_reads != 0 {+ eprintln!("warning: mid-pipeline host IR reads != 0");+ return ExitCode::FAILURE;+ }+ ExitCode::SUCCESS+}++fn cmd_decompile(args: &[String], json: bool) -> ExitCode {+ let path = match args.first() {+ Some(p) => PathBuf::from(p),+ None => {+ eprintln!("usage: ghidrust decompile <path> [--addr HEX] [--count N] [--json]");+ return ExitCode::from(2);+ }+ };+ let mut addr: Option<u64> = None;+ let mut count: usize = 64;+ let mut i = 1;+ while i < args.len() {+ match args[i].as_str() {+ "--addr" if i + 1 < args.len() => {+ addr = parse_u64(&args[i + 1]).ok();+ i += 2;+ }+ "--count" if i + 1 < args.len() => {+ count = args[i + 1].parse().unwrap_or(64);+ i += 2;+ }+ _ => i += 1,+ }+ }+ match load_path(&path) {+ Ok(prog) => {+ let va = addr.unwrap_or_else(|| prog.entry.unwrap_or(prog.image_base));+ match ghidrust_decomp::decompile_at(&prog, va, count) {+ Ok(d) => {+ if json {+ println!("{}", serde_json::to_string_pretty(&d).unwrap());+ } else {+ print!("{}", d.pseudo_c);+ eprintln!(+ "[{}] blocks={} edges={} insns={} lines={}",+ d.name,+ d.blocks.len(),+ d.edges.len(),+ d.insn_count,+ d.line_count()+ );+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("decompile error: {e}");+ ExitCode::FAILURE+ }+ }+ }+ Err(e) => {+ eprintln!("load error: {e}");+ ExitCode::FAILURE+ }+ }+}++/// CPU then GPU (or fallback) proof harness: decompile on CPU + bulk RE on both backends.+fn cmd_re_bench(args: &[String], json: bool) -> ExitCode {+ let path = match args.first() {+ Some(p) => PathBuf::from(p),+ None => {+ eprintln!("usage: ghidrust re-bench <path> [--out FILE] [--json]");+ return ExitCode::from(2);+ }+ };+ let mut out_path: Option<PathBuf> = None;+ let mut i = 1;+ while i < args.len() {+ if args[i] == "--out" && i + 1 < args.len() {+ out_path = Some(PathBuf::from(&args[i + 1]));+ i += 2;+ } else {+ i += 1;+ }+ }++ let metrics = match run_re_bench(&path) {+ Ok(m) => m,+ Err(e) => {+ eprintln!("re-bench error: {e}");+ return ExitCode::FAILURE;+ }+ };++ let text = format_metrics_log(&metrics);+ if let Some(ref p) = out_path {+ if let Err(e) = std::fs::write(p, &text) {+ eprintln!("write metrics: {e}");+ return ExitCode::FAILURE;+ }+ eprintln!("wrote metrics → {}", p.display());+ }+ if json {+ println!("{}", serde_json::to_string_pretty(&metrics).unwrap());+ } else {+ print!("{text}");+ }+ ExitCode::SUCCESS+}++#[derive(Debug, Clone, Serialize)]+struct ReBenchMetrics {+ file: String,+ decompile_cpu: DecompileMetrics,+ bulk_cpu: BulkModeMetrics,+ bulk_gpu: BulkModeMetrics,+ note: String,+}++#[derive(Debug, Clone, Serialize)]+struct DecompileMetrics {+ backend: String,+ ms: f64,+ entry: u64,+ name: String,+ blocks: usize,+ edges: usize,+ insns: usize,+ lines: usize,+ chars: usize,+ /// First line of pseudo-C for identity check (not empty placeholder).+ pseudo_c_head: String,+}++#[derive(Debug, Clone, Serialize)]+struct BulkModeMetrics {+ mode: String,+ backend: String,+ ms: f64,+ hits: usize,+ haystack_bytes: usize,+}++fn run_re_bench(path: &Path) -> Result<ReBenchMetrics, String> {+ let prog = load_path(path).map_err(|e| e.to_string())?;+ let entry = prog.entry.unwrap_or(prog.image_base);++ // --- CPU decompile (structure recovery always on CPU) ---+ let t0 = Instant::now();+ let decomp = decompile_entry(&prog, 64).map_err(|e| e.to_string())?;+ let decomp_ms = t0.elapsed().as_secs_f64() * 1000.0;+ let head: String = decomp.pseudo_c.lines().take(4).collect::<Vec<_>>().join("\n");+ if decomp.pseudo_c.trim().is_empty() || decomp.blocks.is_empty() {+ return Err("decompile produced empty structure".into());+ }++ // --- Bulk haystack (pad for meaningful bulk timing) ---+ let mut hay = Vec::new();+ for b in &prog.blocks {+ hay.extend_from_slice(&b.bytes);+ }+ if hay.len() < 2 * 1024 * 1024 {+ let base = if hay.is_empty() {+ vec![0u8; 4096]+ } else {+ hay.clone()+ };+ while hay.len() < 4 * 1024 * 1024 {+ hay.extend_from_slice(&base);+ if base.is_empty() {+ break;+ }+ }+ }++ // CPU bulk (parallel)+ let t1 = Instant::now();+ let (cpu_hits, cpu_backend) = scan_printable_runs_parallel(&hay, 4);+ let cpu_ms = t1.elapsed().as_secs_f64() * 1000.0;+ let seq = scan_printable_runs_seq(&hay, 4);+ if seq != cpu_hits {+ return Err(format!(+ "CPU parallel bulk != sequential ({} vs {})",+ cpu_hits.len(),+ seq.len()+ ));+ }++ // GPU or fallback bulk+ let t2 = Instant::now();+ let gpu_rep = scan_printable_runs_gpu_or_fallback(&hay, 4);+ let gpu_ms = t2.elapsed().as_secs_f64() * 1000.0;+ if gpu_rep.hits != seq {+ return Err(format!(+ "GPU/fallback bulk != sequential ({} vs {})",+ gpu_rep.hits.len(),+ seq.len()+ ));+ }++ let lines = decomp.line_count();+ let chars = decomp.char_count();+ Ok(ReBenchMetrics {+ file: path.display().to_string(),+ decompile_cpu: DecompileMetrics {+ backend: "cpu".into(),+ ms: decomp_ms,+ entry,+ name: decomp.name.clone(),+ blocks: decomp.blocks.len(),+ edges: decomp.edges.len(),+ insns: decomp.insn_count,+ lines,+ chars,+ pseudo_c_head: head,+ },+ bulk_cpu: BulkModeMetrics {+ mode: "parallel_cpu".into(),+ backend: format!("{cpu_backend:?}"),+ ms: cpu_ms,+ hits: cpu_hits.len(),+ haystack_bytes: hay.len(),+ },+ bulk_gpu: BulkModeMetrics {+ mode: "gpu_or_fallback".into(),+ backend: format!("{:?}", gpu_rep.backend),+ ms: gpu_ms,+ hits: gpu_rep.hits.len(),+ haystack_bytes: hay.len(),+ },+ note: "Decompile/CFG is CPU-only (branchy). GPU accelerates bulk byte-parallel RE only; \+ equal bulk hit counts prove correctness. Timings may show GPU slower on small/medium \+ images (PCIe) — measured honestly, not fabricated."+ .into(),+ })+}++fn format_metrics_log(m: &ReBenchMetrics) -> String {+ let mut s = String::new();+ s.push_str("=== Ghidrust RE bench: CPU then GPU/fallback ===\n");+ s.push_str(&format!("file: {}\n", m.file));+ s.push_str(&format!("note: {}\n\n", m.note));+ s.push_str("--- DECOMPILE (CPU) ---\n");+ s.push_str(&format!(+ "backend={} ms={:.3} entry={:#x} name={}\n",+ m.decompile_cpu.backend,+ m.decompile_cpu.ms,+ m.decompile_cpu.entry,+ m.decompile_cpu.name+ ));+ s.push_str(&format!(+ "blocks={} edges={} insns={} lines={} chars={}\n",+ m.decompile_cpu.blocks,+ m.decompile_cpu.edges,+ m.decompile_cpu.insns,+ m.decompile_cpu.lines,+ m.decompile_cpu.chars+ ));+ s.push_str("pseudo_c_head:\n");+ s.push_str(&m.decompile_cpu.pseudo_c_head);+ s.push_str("\n\n");+ s.push_str("--- BULK RE (CPU parallel) ---\n");+ s.push_str(&format!(+ "mode={} backend={} ms={:.3} hits={} haystack_bytes={}\n\n",+ m.bulk_cpu.mode,+ m.bulk_cpu.backend,+ m.bulk_cpu.ms,+ m.bulk_cpu.hits,+ m.bulk_cpu.haystack_bytes+ ));+ s.push_str("--- BULK RE (GPU or fallback) ---\n");+ s.push_str(&format!(+ "mode={} backend={} ms={:.3} hits={} haystack_bytes={}\n\n",+ m.bulk_gpu.mode,+ m.bulk_gpu.backend,+ m.bulk_gpu.ms,+ m.bulk_gpu.hits,+ m.bulk_gpu.haystack_bytes+ ));+ s.push_str("--- COMPARISON ---\n");+ s.push_str(&format!(+ "bulk_hit_equal={}\n",+ m.bulk_cpu.hits == m.bulk_gpu.hits+ ));+ s.push_str(&format!(+ "bulk_cpu_ms={:.3} bulk_gpu_ms={:.3} ratio_gpu_over_cpu={:.3}\n",+ m.bulk_cpu.ms,+ m.bulk_gpu.ms,+ if m.bulk_cpu.ms > 0.0 {+ m.bulk_gpu.ms / m.bulk_cpu.ms+ } else {+ 0.0+ }+ ));+ s.push_str(&format!(+ "decompile_cpu_ms={:.3} (structure recovery not offloaded to GPU)\n",+ m.decompile_cpu.ms+ ));+ s+}++fn cmd_analyzers(json: bool) -> ExitCode {+ let cat = analyzer_catalog();+ if json {+ println!("{}", serde_json::to_string_pretty(&cat).unwrap());+ } else {+ for a in &cat {+ println!(+ "[{:?}] {} (default_enabled={})",+ a.status, a.name, a.default_enabled+ );+ }+ }+ ExitCode::SUCCESS+}++fn cmd_analyze(args: &[String], json: bool) -> ExitCode {+ let path = match path_arg(args) {+ Ok(p) => p,+ Err(e) => {+ eprintln!("{e}");+ return ExitCode::from(2);+ }+ };+ let mut names: Vec<String> = Vec::new();+ let mut use_gpu = false;+ let mut i = 1;+ while i < args.len() {+ match args[i].as_str() {+ "--analyzers" if i + 1 < args.len() => {+ for s in args[i + 1].split(',') {+ let t = s.trim();+ if !t.is_empty() {+ names.push(t.to_string());+ }+ }+ i += 2;+ }+ "--analyzer" if i + 1 < args.len() => {+ names.push(args[i + 1].clone());+ i += 2;+ }+ "--gpu" => {+ use_gpu = true;+ i += 1;+ }+ _ => i += 1,+ }+ }++ // Selective analyzers and/or --gpu (empty names → defaults via run_analyzers_opts)+ if !names.is_empty() || use_gpu {+ let name_refs: Vec<&str> = names.iter().map(|s| s.as_str()).collect();+ return match load_path(&path)+ .and_then(|mut p| ghidrust_core::run_analyzers_opts(&mut p, &name_refs, use_gpu))+ {+ Ok(report) => {+ if json {+ println!("{}", serde_json::to_string_pretty(&report).unwrap());+ } else {+ if use_gpu {+ println!("gpu=true (bulk strings + per-analyzer GPU seed enrich)");+ }+ for r in &report.results {+ println!("[{}] {} — {}", r.status, r.name, r.message);+ if let Some(ref rtti) = r.rtti {+ for c in &rtti.classes {+ println!(" class {}", c.name);+ }+ }+ if let Some(ref strings) = r.strings {+ for s in strings.iter().take(20) {+ println!(" str {:#x}: {}", s.va, s.value);+ }+ }+ }+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ };+ }++ match analyze_path(&path) {+ Ok(bundle) => {+ if json {+ println!(+ "{}",+ serde_json::to_string_pretty(&bundle_json(&bundle)).unwrap()+ );+ } else {+ emit_load(&bundle.program, false);+ println!("--- disassembly ---");+ for insn in &bundle.listing {+ println!("{}", insn.text());+ }+ println!("--- analysis ---");+ for r in &bundle.analysis.results {+ println!("[{}] {} — {}", r.status, r.name, r.message);+ }+ println!("--- rtti ---");+ for c in &bundle.rtti.classes {+ println!("class {}", c.name);+ }+ }+ ExitCode::SUCCESS+ }+ Err(e) => {+ eprintln!("error: {e}");+ ExitCode::FAILURE+ }+ }+}++fn bundle_json(b: &AnalysisBundle) -> Value {+ json!({+ "format": b.program.format,+ "entry": b.program.entry.map(|e| format!("{e:#x}")),+ "sections": b.program.sections.iter().map(|s| json!({+ "name": s.name,+ "va": format!("{:#x}", s.va),+ })).collect::<Vec<_>>(),+ "listing": b.listing,+ "rtti": b.rtti,+ "analysis": b.analysis,+ })+}++fn fmt_opt_va(v: Option<u64>) -> String {+ v.map(|x| format!("{x:#x}")).unwrap_or_else(|| "-".into())+}++fn parse_u64(s: &str) -> Result<u64, String> {+ let t = s.trim().trim_start_matches("0x").trim_start_matches("0X");+ u64::from_str_radix(t, 16)+ .or_else(|_| s.parse::<u64>())+ .map_err(|e| e.to_string())+}++#[derive(Serialize)]+struct ToolDef {+ name: &'static str,+ description: &'static str,+ input_schema: Value,+}++fn tool_defs() -> Vec<ToolDef> {+ vec![+ ToolDef {+ name: "load",+ description: "Load a PE or ELF binary and return memory map / sections",+ input_schema: json!({+ "type": "object",+ "properties": { "path": { "type": "string" } },+ "required": ["path"]+ }),+ },+ ToolDef {+ name: "disassemble",+ description: "Disassemble x86-64 at entry or given address",+ input_schema: json!({+ "type": "object",+ "properties": {+ "path": { "type": "string" },+ "addr": { "type": "string" },+ "count": { "type": "integer" }+ },+ "required": ["path"]+ }),+ },+ ToolDef {+ name: "rtti",+ description: "Recover C++ RTTI class names and vtable links",+ input_schema: json!({+ "type": "object",+ "properties": { "path": { "type": "string" } },+ "required": ["path"]+ }),+ },+ ToolDef {+ name: "list_analyzers",+ description: "List Auto Analysis options (Ghidra-compatible labels)",+ input_schema: json!({ "type": "object", "properties": {} }),+ },+ ToolDef {+ name: "analyze",+ description: "Run selected analyzers on a binary path; optional GPU enrich",+ input_schema: json!({+ "type": "object",+ "properties": {+ "path": { "type": "string" },+ "analyzers": {+ "type": "array",+ "items": { "type": "string" },+ "description": "Exact analyzer names; empty = defaults"+ },+ "gpu": {+ "type": "boolean",+ "description": "GPU bulk strings + per-analyzer seed kernels"+ }+ },+ "required": ["path"]+ }),+ },+ ToolDef {+ name: "list_gpu_strategies",+ description: "Per-analyzer GPU strategy matrix (all Auto Analysis + decompile)",+ input_schema: json!({ "type": "object", "properties": {} }),+ },+ ToolDef {+ name: "gpu_decompile",+ description: "GPU-resident multipass decompile of entry; returns dump metrics (PCIe/device when available)",+ input_schema: json!({+ "type": "object",+ "properties": {+ "path": { "type": "string" },+ "out": { "type": "string", "description": "optional dump path" }+ },+ "required": ["path"]+ }),+ },+ ToolDef {+ name: "rtti_gpu_bench",+ description: "CPU recover_rtti vs GPU rtti_scan with PCIe upload/download vs on-device split",+ input_schema: json!({+ "type": "object",+ "properties": { "path": { "type": "string" } },+ "required": ["path"]+ }),+ },+ ]+}++fn run_mcp_stdio() -> ExitCode {+ let stdin = io::stdin();+ let mut stdout = io::stdout();+ for line in stdin.lock().lines() {+ let line = match line {+ Ok(l) => l,+ Err(e) => {+ eprintln!("mcp read error: {e}");+ return ExitCode::FAILURE;+ }+ };+ if line.trim().is_empty() {+ continue;+ }+ let req: Value = match serde_json::from_str(&line) {+ Ok(v) => v,+ Err(e) => {+ let err = json!({"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":e.to_string()}});+ writeln!(stdout, "{err}").ok();+ continue;+ }+ };+ let id = req.get("id").cloned().unwrap_or(Value::Null);+ let method = req.get("method").and_then(|m| m.as_str()).unwrap_or("");+ let params = req.get("params").cloned().unwrap_or(json!({}));++ let resp = match method {+ "initialize" => json!({+ "jsonrpc": "2.0",+ "id": id,+ "result": {+ "protocolVersion": "2024-11-05",+ "capabilities": { "tools": {} },+ "serverInfo": { "name": "ghidrust", "version": "0.1.0" }+ }+ }),+ "tools/list" | "list_tools" => json!({+ "jsonrpc": "2.0",+ "id": id,+ "result": { "tools": tool_defs() }+ }),+ "tools/call" | "call_tool" => match call_tool(¶ms) {+ Ok(content) => json!({+ "jsonrpc": "2.0",+ "id": id,+ "result": {+ "content": [{ "type": "text", "text": content }],+ "isError": false+ }+ }),+ Err(e) => json!({+ "jsonrpc": "2.0",+ "id": id,+ "result": {+ "content": [{ "type": "text", "text": e }],+ "isError": true+ }+ }),+ },+ "notifications/initialized" | "initialized" => {+ if id.is_null() {+ continue;+ }+ json!({"jsonrpc":"2.0","id":id,"result":{}})+ }+ _ => json!({+ "jsonrpc": "2.0",+ "id": id,+ "error": { "code": -32601, "message": format!("method not found: {method}") }+ }),+ };+ if writeln!(stdout, "{resp}").is_err() {+ return ExitCode::FAILURE;+ }+ stdout.flush().ok();+ }+ ExitCode::SUCCESS+}++fn call_tool(params: &Value) -> Result<String, String> {+ let name = params+ .get("name")+ .and_then(|n| n.as_str())+ .ok_or_else(|| "missing tool name".to_string())?;+ let args = params.get("arguments").cloned().unwrap_or(json!({}));++ match name {+ "list_analyzers" => {+ let cat = analyzer_catalog();+ Ok(serde_json::to_string_pretty(&cat).unwrap())+ }+ "list_gpu_strategies" => Ok(ghidrust_core::format_matrix_table()),+ "gpu_decompile" => {+ let path = args+ .get("path")+ .and_then(|p| p.as_str())+ .ok_or_else(|| "missing arguments.path".to_string())?;+ let out = args+ .get("out")+ .and_then(|p| p.as_str())+ .map(PathBuf::from)+ .unwrap_or_else(|| std::env::temp_dir().join("mcp_gpu_decompile.gdecomp"));+ let prog = load_path(path).map_err(|e| e.to_string())?;+ let rep = ghidrust_decomp::gpu_decompile_to_file(&prog, None, &out, 256)+ .map_err(|e| e.to_string())?;+ Ok(serde_json::to_string_pretty(&json!({+ "backend": rep.backend,+ "device": rep.device,+ "ms": rep.ms,+ "pcie_upload_ms": rep.pcie_upload_ms,+ "device_ms": rep.device_ms,+ "pcie_download_ms": rep.pcie_download_ms,+ "mid_pipeline_host_reads": rep.mid_pipeline_host_reads,+ "ir_count": rep.ir_count,+ "block_count": rep.block_count,+ "dump_path": rep.dump_path,+ "dump_bytes": rep.dump_bytes,+ "pseudo_c_head": rep.pseudo_c.lines().take(8).collect::<Vec<_>>().join("\n"),+ }))+ .unwrap())+ }+ "rtti_gpu_bench" => {+ let path = args+ .get("path")+ .and_then(|p| p.as_str())+ .ok_or_else(|| "missing arguments.path".to_string())?;+ // Reuse CLI logic via load + bench (same shipped paths)+ let prog = load_path(path).map_err(|e| e.to_string())?;+ let t0 = std::time::Instant::now();+ let rtti = recover_rtti(&prog).map_err(|e| e.to_string())?;+ let cpu_rtti_ms = t0.elapsed().as_secs_f64() * 1000.0;+ let row = ghidrust_core::bench_analyzer(&prog, "WindowsPE x86 PE RTTI Analyzer", None);+ Ok(serde_json::to_string_pretty(&json!({+ "cpu_rtti_recover_ms": cpu_rtti_ms,+ "cpu_rtti_classes": rtti.classes.len(),+ "gpu_strategy": row.strategy,+ "gpu_pcie_upload_ms": row.gpu_pcie_upload_ms,+ "gpu_device_ms": row.gpu_device_ms,+ "gpu_pcie_download_ms": row.gpu_pcie_download_ms,+ "gpu_pcie_ms": row.gpu_pcie_ms,+ "gpu_wall_ms": row.gpu_wall_ms,+ "gpu_seed_hits": row.gpu_primary,+ "seed_cpu_hits": row.cpu_primary,+ "seed_equal": row.equal,+ "backend": row.backend,+ "device": row.device,+ }))+ .unwrap())+ }+ "load" | "disassemble" | "rtti" | "analyze" => {+ let path = args+ .get("path")+ .and_then(|p| p.as_str())+ .ok_or_else(|| "missing arguments.path".to_string())?;+ match name {+ "load" => {+ let prog = load_path(path).map_err(|e| e.to_string())?;+ Ok(serde_json::to_string_pretty(&json!({+ "name": prog.name,+ "format": prog.format,+ "image_base": format!("{:#x}", prog.image_base),+ "entry": prog.entry.map(|e| format!("{e:#x}")),+ "sections": prog.sections.iter().map(|s| json!({+ "name": s.name,+ "va": format!("{:#x}", s.va),+ "virtual_size": s.virtual_size,+ })).collect::<Vec<_>>(),+ }))+ .unwrap())+ }+ "disassemble" => {+ let prog = load_path(path).map_err(|e| e.to_string())?;+ let count = args.get("count").and_then(|c| c.as_u64()).unwrap_or(16) as usize;+ let start = if let Some(a) = args.get("addr").and_then(|a| a.as_str()) {+ parse_u64(a)?+ } else {+ prog.entry.unwrap_or(prog.image_base)+ };+ let listing =+ disassemble_range(&prog, start, count).map_err(|e| e.to_string())?;+ Ok(serde_json::to_string_pretty(&listing).unwrap())+ }+ "rtti" => {+ let prog = load_path(path).map_err(|e| e.to_string())?;+ let report = recover_rtti(&prog).map_err(|e| e.to_string())?;+ Ok(serde_json::to_string_pretty(&report).unwrap())+ }+ "analyze" => {+ let mut prog = load_path(path).map_err(|e| e.to_string())?;+ let names_owned: Vec<String> = args+ .get("analyzers")+ .and_then(|a| a.as_array())+ .map(|arr| {+ arr.iter()+ .filter_map(|v| v.as_str().map(|s| s.to_string()))+ .collect()+ })+ .unwrap_or_default();+ let name_refs: Vec<&str> = names_owned.iter().map(|s| s.as_str()).collect();+ let use_gpu = args+ .get("gpu")+ .and_then(|g| g.as_bool())+ .unwrap_or(false);+ let report = ghidrust_core::run_analyzers_opts(&mut prog, &name_refs, use_gpu)+ .map_err(|e| e.to_string())?;+ Ok(serde_json::to_string_pretty(&report).unwrap())+ }+ _ => unreachable!(),+ }+ }+ other => Err(format!("unknown tool: {other}")),+ }+}diff --git a/crates/ghidrust-cli/tests/cli_mcp.rs b/crates/ghidrust-cli/tests/cli_mcp.rsnew file mode 100644index 0000000..1368906--- /dev/null+++ b/crates/ghidrust-cli/tests/cli_mcp.rs@@ -0,0 +1,95 @@+//! Integration tests: real CLI binary + MCP against fixtures.++use ghidrust_core::fixture_path;+use serde_json::json;+use std::io::Write;+use std::process::{Command, Stdio};++fn bin() -> Command {+ Command::new(env!("CARGO_BIN_EXE_ghidrust"))+}++#[test]+fn cli_load_and_rtti_fixture() {+ let pe = fixture_path("tiny_x64.pe");+ let out = bin()+ .args(["rtti", pe.to_str().unwrap(), "--json"])+ .output()+ .expect("run cli");+ assert!(out.status.success(), "stderr={}", String::from_utf8_lossy(&out.stderr));+ let s = String::from_utf8_lossy(&out.stdout);+ assert!(s.contains("Widget"), "stdout={s}");+}++#[test]+fn cli_disasm_fixture() {+ let pe = fixture_path("tiny_x64.pe");+ let out = bin()+ .args(["disasm", pe.to_str().unwrap(), "--count", "5"])+ .output()+ .expect("run");+ assert!(out.status.success());+ let s = String::from_utf8_lossy(&out.stdout);+ assert!(s.contains("push") && s.contains("ret"), "{s}");+}++#[test]+fn cli_analyzers_all_implemented() {+ let out = bin().args(["analyzers", "--json"]).output().expect("analyzers");+ assert!(out.status.success());+ let s = String::from_utf8_lossy(&out.stdout);+ assert!(s.contains("\"status\": \"implemented\"") || s.contains("Implemented") || s.contains("implemented"));+ assert!(!s.contains("not_implemented") && !s.contains("NotImplemented"));+}++#[test]+fn cli_analyze_multi_ok() {+ let pe = fixture_path("analysis_lab.pe");+ let out = bin()+ .args([+ "analyze",+ pe.to_str().unwrap(),+ "--analyzers",+ "Function Start Search,Function ID,ASCII Strings,Call-Fixup Installer,Embedded Media,PDB Universal,Create Address Tables",+ "--json",+ ])+ .output()+ .expect("analyze");+ assert!(out.status.success(), "stderr={}", String::from_utf8_lossy(&out.stderr));+ let s = String::from_utf8_lossy(&out.stdout);+ assert!(!s.contains("not_implemented"));+ assert!(s.contains("security_cookie"), "{s}");+ assert!(s.contains("PNG"), "{s}");+ assert!(s.contains("LabEntry"), "{s}");+ assert!(s.contains("ExitProcess"), "{s}");+}++#[test]+fn mcp_list_and_analyze() {+ let pe = fixture_path("tiny_x64.pe");+ let mut child = bin()+ .arg("mcp")+ .stdin(Stdio::piped())+ .stdout(Stdio::piped())+ .stderr(Stdio::piped())+ .spawn()+ .expect("spawn mcp");+ let mut stdin = child.stdin.take().unwrap();+ let pe_s = pe.to_str().unwrap();+ let reqs = format!(+ "{}\n{}\n",+ json!({"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}),+ json!({"jsonrpc":"2.0","id":2,"method":"tools/call","params":{+ "name":"analyze","arguments":{+ "path": pe_s,+ "analyzers": ["ASCII Strings", "WindowsPE x86 PE RTTI Analyzer", "Function Start Search"]+ }+ }}),+ );+ stdin.write_all(reqs.as_bytes()).unwrap();+ drop(stdin);+ let out = child.wait_with_output().unwrap();+ assert!(out.status.success(), "stderr={}", String::from_utf8_lossy(&out.stderr));+ let s = String::from_utf8_lossy(&out.stdout);+ assert!(s.contains("Widget") || s.contains("ok"), "{s}");+}diff --git a/crates/ghidrust-cli/tests/re_bench.rs b/crates/ghidrust-cli/tests/re_bench.rsnew file mode 100644index 0000000..405359b--- /dev/null+++ b/crates/ghidrust-cli/tests/re_bench.rs@@ -0,0 +1,101 @@+//! Integration: shipped decompile + re-bench on real fixture path.++use std::path::PathBuf;+use std::process::Command;++fn bin() -> PathBuf {+ PathBuf::from(env!("CARGO_BIN_EXE_ghidrust"))+}++fn fixture(name: &str) -> PathBuf {+ let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));+ p.pop();+ p.pop();+ p.push("fixtures");+ p.push(name);+ p+}++#[test]+fn decompile_tiny_pe_nonempty_structure() {+ let out = Command::new(bin())+ .args([+ "decompile",+ fixture("tiny_x64.pe").to_str().unwrap(),+ "--json",+ ])+ .output()+ .expect("run decompile");+ assert!(+ out.status.success(),+ "stderr={}",+ String::from_utf8_lossy(&out.stderr)+ );+ let v: serde_json::Value = serde_json::from_slice(&out.stdout).expect("json");+ assert!(v["pseudo_c"].as_str().unwrap_or("").contains("void "));+ assert!(v["blocks"]+ .as_array()+ .map(|a| !a.is_empty())+ .unwrap_or(false));+ assert!(v["insn_count"].as_u64().unwrap_or(0) > 0);+}++#[test]+fn gpu_decompile_dump_and_metrics() {+ let dump = std::env::temp_dir().join(format!("cli_gdec_{}.gdecomp", std::process::id()));+ let metrics = std::env::temp_dir().join(format!("cli_gdec_{}.log", std::process::id()));+ let out = Command::new(bin())+ .args([+ "gpu-decompile",+ fixture("tiny_x64.pe").to_str().unwrap(),+ "--out",+ dump.to_str().unwrap(),+ "--metrics",+ metrics.to_str().unwrap(),+ "--json",+ ])+ .output()+ .expect("gpu-decompile");+ assert!(+ out.status.success(),+ "stderr={}",+ String::from_utf8_lossy(&out.stderr)+ );+ assert!(dump.is_file());+ let v: serde_json::Value = serde_json::from_slice(&out.stdout).expect("json");+ assert_eq!(v["mid_pipeline_host_reads"].as_u64(), Some(0));+ assert_eq!(v["equivalence_multipass"].as_bool(), Some(true));+ assert!(v["dump_bytes"].as_u64().unwrap_or(0) > 32);+ assert!(metrics.is_file());+ let _ = std::fs::remove_file(&dump);+ let _ = std::fs::remove_file(&metrics);+ let _ = std::fs::remove_file(metrics.with_extension("json"));+}++#[test]+fn re_bench_cpu_and_gpu_modes_equal_hits() {+ let out = Command::new(bin())+ .args([+ "re-bench",+ fixture("tiny_x64.pe").to_str().unwrap(),+ "--json",+ ])+ .output()+ .expect("run re-bench");+ assert!(+ out.status.success(),+ "stderr={}",+ String::from_utf8_lossy(&out.stderr)+ );+ let v: serde_json::Value = serde_json::from_slice(&out.stdout).expect("json");+ assert_eq!(+ v["bulk_cpu"]["hits"].as_u64(),+ v["bulk_gpu"]["hits"].as_u64(),+ "bulk hits must match"+ );+ assert!(v["decompile_cpu"]["blocks"].as_u64().unwrap_or(0) >= 1);+ assert!(v["decompile_cpu"]["chars"].as_u64().unwrap_or(0) > 20);+ assert!(v["bulk_cpu"]["ms"].as_f64().is_some());+ assert!(v["bulk_gpu"]["ms"].as_f64().is_some());+ assert!(v["bulk_gpu"]["backend"].as_str().unwrap_or("").len() > 2);+}diff --git a/crates/ghidrust-core/Cargo.toml b/crates/ghidrust-core/Cargo.tomlnew file mode 100644index 0000000..c8984e9--- /dev/null+++ b/crates/ghidrust-core/Cargo.toml@@ -0,0 +1,22 @@+[package]+name = "ghidrust-core"+version.workspace = true+edition.workspace = true+license.workspace = true+description = "Hand-rolled RE analysis core: program model, PE/ELF, x86-64, RTTI"++[features]+default = []+# Experimental wgpu compute for bulk printable-mark kernel (optional adapter).+gpu = ["wgpu", "pollster", "bytemuck"]++[dependencies]+serde = { version = "1", features = ["derive"] }+serde_json = "1"+rayon = "1"+# Fast analysis persistence (UI open) — binary vs multi-100MB pretty JSON+bincode = "1"+# Optional GPU bulk path — enabled with `--features gpu`+wgpu = { version = "24", optional = true, default-features = true }+pollster = { version = "0.4", optional = true }+bytemuck = { version = "1", optional = true, features = ["derive"] }diff --git a/crates/ghidrust-core/examples/gpu_probe.rs b/crates/ghidrust-core/examples/gpu_probe.rsnew file mode 100644index 0000000..9f683cd--- /dev/null+++ b/crates/ghidrust-core/examples/gpu_probe.rs@@ -0,0 +1,18 @@+fn main() {+ let mut hay = vec![0u8; 2 * 1024 * 1024];+ for i in (0..hay.len()).step_by(100) {+ let m = b"GpuBulkTokenABCDEF";+ let e = (i + m.len()).min(hay.len());+ hay[i..e].copy_from_slice(&m[..e - i]);+ }+ let rep = ghidrust_core::scan_printable_runs_gpu_or_fallback(&hay, 4);+ let t = ghidrust_core::time_bulk_printable(&hay, 4);+ println!("gpu_backend={:?}", rep.backend);+ println!("hits={} workgroups={}", rep.hits.len(), rep.workgroups);+ println!(+ "seq_ms={:.3} par_ms={:.3} gpu_ms={:.3} threads={} seq_hits={} par_hits={} gpu_hits={}",+ t.seq_ms, t.par_ms, t.gpu_ms, t.threads, t.seq_hits, t.par_hits, t.gpu_hits+ );+ println!("par_backend={:?}", t.par_backend);+ println!("gpu_timing_backend={:?}", t.gpu_backend);+}diff --git a/crates/ghidrust-core/src/analyzers/address_tables.rs b/crates/ghidrust-core/src/analyzers/address_tables.rsnew file mode 100644index 0000000..3ec5986--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/address_tables.rs@@ -0,0 +1,53 @@+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{AddressTableInfo, Program, ReferenceInfo};++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ let mut tables = Vec::new();+ for block in &prog.blocks {+ let b = &block.bytes;+ let mut i = 0;+ while i + 24 <= b.len() {+ let mut entries = Vec::new();+ let mut j = i;+ while j + 8 <= b.len() && entries.len() < 64 {+ let val = u64::from_le_bytes(b[j..j + 8].try_into().unwrap());+ if prog.contains_va(val) {+ entries.push(val);+ j += 8;+ } else {+ break;+ }+ }+ if entries.len() >= 3 {+ let base = block.va + i as u64;+ for (k, &tgt) in entries.iter().enumerate() {+ prog.analysis.references.push(ReferenceInfo {+ from: base + (k as u64) * 8,+ to: tgt,+ kind: "ptr_table".into(),+ });+ }+ tables.push(AddressTableInfo {+ base,+ count: entries.len(),+ entries,+ });+ i = j;+ } else {+ i += 8;+ }+ }+ }+ tables.sort_by_key(|t| t.base);+ tables.dedup_by_key(|t| t.base);+ let n = tables.len();+ prog.analysis.address_tables = tables.clone();+ Ok(AnalyzerOutput {+ name: "Create Address Tables".into(),+ status: "ok".into(),+ message: format!("found {n} address table(s)"),+ address_tables: Some(tables),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/aggressive.rs b/crates/ghidrust-core/src/analyzers/aggressive.rsnew file mode 100644index 0000000..4316f46--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/aggressive.rs@@ -0,0 +1,128 @@+//! Aggressive Instruction Finder — recover code only in real gaps (no fabrication).++use super::AnalyzerOutput;+use crate::disasm::decode_one;+use crate::error::Result;+use crate::program::{DiscoveredRange, FunctionInfo, Program};++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ if prog.analysis.functions.is_empty() {+ let _ = super::function_start::run(prog)?;+ }+ let mut start_hashes: Vec<[u8; 4]> = Vec::new();+ for f in &prog.analysis.functions {+ if let Some(b) = prog.read_va(f.entry, 4) {+ if b.len() == 4 {+ let mut h = [0u8; 4];+ h.copy_from_slice(&b);+ start_hashes.push(h);+ }+ }+ }++ let func_ranges: Vec<(u64, u64)> = prog+ .analysis+ .functions+ .iter()+ .map(|f| (f.entry, f.end))+ .collect();++ let mut recovered = Vec::new();+ let exec: Vec<(u64, Vec<u8>)> = prog+ .exec_blocks()+ .map(|b| (b.va, b.bytes.clone()))+ .collect();++ for (block_va, bytes) in exec {+ let mut i = 0;+ while i + 4 <= bytes.len() {+ let va = block_va + i as u64;+ let covered = func_ranges.iter().any(|(s, e)| va >= *s && va < *e);+ if covered {+ i += 1;+ continue;+ }+ let slice = &bytes[i..i + 4];+ let hash_ok = start_hashes.is_empty()+ || start_hashes.iter().any(|h| h.as_slice() == slice);+ // Also accept classic prologues even if hash set empty+ let prolog = slice == [0x55, 0x48, 0x89, 0xE5] || bytes[i] == 0x55;+ if !(hash_ok || prolog) {+ i += 1;+ continue;+ }+ if validate_body(prog, va, &bytes[i..]) {+ let end = va + measure(prog, va);+ if end > va + 2 {+ recovered.push(DiscoveredRange { start: va, end });+ if prog.function_at(va).is_none() {+ prog.analysis.functions.push(FunctionInfo {+ entry: va,+ end,+ name: format!("AIF_{va:08x}"),+ calling_convention: None,+ noreturn: false,+ varargs: false,+ parameters: Vec::new(),+ stack_locals: Vec::new(),+ });+ }+ i += (end - va) as usize;+ continue;+ }+ }+ i += 1;+ }+ }++ // Dedup overlapping+ recovered.sort_by_key(|r| r.start);+ recovered.dedup_by_key(|r| r.start);+ let n = recovered.len();+ prog.analysis.recovered_code = recovered.clone();+ Ok(AnalyzerOutput {+ name: "Aggressive Instruction Finder".into(),+ status: "ok".into(),+ message: format!("found {n} recovered code range(s)"),+ recovered_ranges: Some(recovered),+ ..Default::default()+ })+}++fn validate_body(prog: &Program, va: u64, bytes: &[u8]) -> bool {+ let mut pos = 0u64;+ let mut n = 0;+ while n < 12 && (pos as usize) < bytes.len() {+ match decode_one(&bytes[pos as usize..], va + pos) {+ Ok(insn) => {+ n += 1;+ if insn.mnemonic == "ret" {+ return n >= 2;+ }+ if insn.mnemonic == "int3" && n < 2 {+ return false;+ }+ pos += insn.length as u64;+ }+ Err(_) => return false,+ }+ }+ n >= 3 && prog.contains_va(va)+}++fn measure(prog: &Program, va: u64) -> u64 {+ let mut cur = va;+ for _ in 0..32 {+ let Some(b) = prog.read_va(cur, 15) else {+ break;+ };+ let Ok(insn) = decode_one(&b, cur) else {+ break;+ };+ cur += insn.length as u64;+ if insn.mnemonic == "ret" || insn.mnemonic == "int3" {+ break;+ }+ }+ cur - va+}diff --git a/crates/ghidrust-core/src/analyzers/call_convention.rs b/crates/ghidrust-core/src/analyzers/call_convention.rsnew file mode 100644index 0000000..6f779ba--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/call_convention.rs@@ -0,0 +1,55 @@+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::Program;++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ if prog.analysis.functions.is_empty() {+ let _ = super::function_start::run(prog)?;+ }+ let is_pe = prog.format.starts_with("PE");+ let entries: Vec<(u64, String)> = prog+ .analysis+ .functions+ .iter()+ .map(|f| {+ let bytes = prog.read_va(f.entry, 32).unwrap_or_default();+ (f.entry, classify(&bytes, is_pe))+ })+ .collect();+ let mut conventions = Vec::new();+ for (entry, conv) in entries {+ if let Some(f) = prog.function_at_mut(entry) {+ f.calling_convention = Some(conv.clone());+ }+ conventions.push((entry, conv));+ }+ let n = conventions.len();+ Ok(AnalyzerOutput {+ name: "Call Convention ID".into(),+ status: "ok".into(),+ message: format!("identified {n} calling convention(s)"),+ conventions: Some(conventions),+ ..Default::default()+ })+}++fn classify(bytes: &[u8], windows: bool) -> String {+ // Windows x64: often sub rsp, 0x20+ and uses rcx spill [rbp+10]+ if bytes.windows(3).any(|w| w == [0x48, 0x89, 0x4D]) || // mov [rbp+x], rcx+ bytes.windows(4).any(|w| w[0..3] == [0x48, 0x83, 0xEC])+ {+ return if windows {+ "__fastcall".into() // MS x64+ } else {+ "sysv".into()+ };+ }+ if bytes.windows(2).any(|w| w == [0x5D, 0xC2]) {+ return "stdcall".into();+ }+ if windows {+ "__fastcall".into()+ } else {+ "sysv".into()+ }+}diff --git a/crates/ghidrust-core/src/analyzers/call_fixup.rs b/crates/ghidrust-core/src/analyzers/call_fixup.rsnew file mode 100644index 0000000..aa3bfdb--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/call_fixup.rs@@ -0,0 +1,76 @@+use super::scan_util::ensure_api_symbols;+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{CallFixupInfo, Program};++const FIXUPS: &[(&str, &str)] = &[+ ("__security_check_cookie", "security_cookie"),+ ("malloc", "allocator"),+ ("free", "allocator"),+ ("memcpy", "memcpy"),+ ("memset", "memset"),+];++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ ensure_api_symbols(+ prog,+ &[+ "__security_check_cookie",+ "malloc",+ "free",+ "memcpy",+ "memset",+ ],+ );+ let mut fixups = Vec::new();+ for s in &prog.analysis.symbols {+ for (name, fix) in FIXUPS {+ if s.name.contains(name) {+ fixups.push(CallFixupInfo {+ call_va: s.va,+ fixup_name: (*fix).into(),+ });+ }+ }+ }+ // CALL rel32 to a known fixup symbol VA+ let targets: Vec<(u64, String)> = prog+ .analysis+ .symbols+ .iter()+ .filter_map(|s| {+ FIXUPS+ .iter()+ .find(|(n, _)| s.name.contains(n))+ .map(|(_, fix)| (s.va, (*fix).to_string()))+ })+ .collect();+ for block in prog.exec_blocks() {+ let b = &block.bytes;+ let mut i = 0;+ while i + 5 <= b.len() {+ if b[i] == 0xE8 {+ let rel = i32::from_le_bytes(b[i + 1..i + 5].try_into().unwrap());+ let target = (block.va + i as u64 + 5).wrapping_add(rel as i64 as u64);+ if let Some((_, fix)) = targets.iter().find(|(va, _)| *va == target) {+ fixups.push(CallFixupInfo {+ call_va: block.va + i as u64,+ fixup_name: fix.clone(),+ });+ }+ }+ i += 1;+ }+ }+ fixups.sort_by_key(|f| f.call_va);+ fixups.dedup_by_key(|f| f.call_va);+ let n = fixups.len();+ prog.analysis.call_fixups = fixups.clone();+ Ok(AnalyzerOutput {+ name: "Call-Fixup Installer".into(),+ status: "ok".into(),+ message: format!("installed {n} call fixup(s)"),+ call_fixups: Some(fixups),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/decomp_param.rs b/crates/ghidrust-core/src/analyzers/decomp_param.rsnew file mode 100644index 0000000..1348911--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/decomp_param.rs@@ -0,0 +1,76 @@+//! Decompiler Parameter ID — only real first-use of arg registers in function body.++use super::AnalyzerOutput;+use crate::disasm::decode_one;+use crate::error::Result;+use crate::program::Program;++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ if prog.analysis.functions.is_empty() {+ let _ = super::function_start::run(prog)?;+ }+ let computed: Vec<(u64, Vec<String>)> = prog+ .analysis+ .functions+ .iter()+ .map(|f| {+ let len = (f.end.saturating_sub(f.entry) as usize).min(64).max(1);+ let bytes = prog.read_va(f.entry, len).unwrap_or_default();+ let mut params: Vec<String> = Vec::new();+ // Only patterns that store/use arg regs inside this function's bytes+ if bytes.windows(3).any(|w| w == [0x48, 0x89, 0x4D]) {+ // mov [rbp+disp], rcx+ params.push("arg0:rcx".into());+ }+ if bytes.windows(3).any(|w| w == [0x48, 0x89, 0x55]) {+ params.push("arg1:rdx".into());+ }+ let mut va = f.entry;+ let mut off = 0;+ while off < bytes.len() {+ match decode_one(&bytes[off..], va) {+ Ok(insn) => {+ // Require mov TO memory from rcx/rdx (spill), not mere presence in operands+ if insn.mnemonic == "mov"+ && insn.operands.contains("rcx")+ && insn.operands.contains('[')+ && !params.iter().any(|p| p.contains("rcx"))+ {+ params.push("arg0:rcx".into());+ }+ if insn.mnemonic == "mov"+ && insn.operands.contains("rdx")+ && insn.operands.contains('[')+ && !params.iter().any(|p| p.contains("rdx"))+ {+ params.push("arg1:rdx".into());+ }+ off += insn.length as usize;+ va += insn.length as u64;+ if va >= f.end {+ break;+ }+ }+ Err(_) => break,+ }+ }+ // No default invention when empty+ (f.entry, params)+ })+ .collect();+ let mut updated = Vec::new();+ for (entry, params) in computed {+ if let Some(f) = prog.function_at_mut(entry) {+ f.parameters = params;+ updated.push(f.clone());+ }+ }+ let n = updated.iter().filter(|f| !f.parameters.is_empty()).count();+ Ok(AnalyzerOutput {+ name: "Decompiler Parameter ID".into(),+ status: "ok".into(),+ message: format!("recovered parameters for {n} function(s)"),+ functions: Some(updated),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/decomp_switch.rs b/crates/ghidrust-core/src/analyzers/decomp_switch.rsnew file mode 100644index 0000000..139eae8--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/decomp_switch.rs@@ -0,0 +1,49 @@+//! Decompiler Switch Analysis — only real address tables (≥2 in-image targets).++use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{Program, SwitchInfo};++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ if prog.analysis.address_tables.is_empty() {+ let _ = super::address_tables::run(prog)?;+ }+ let mut switches = Vec::new();+ for table in &prog.analysis.address_tables {+ if table.entries.len() < 2 {+ continue;+ }+ // Prefer tables whose targets land in executable memory (jump tables)+ let exec_hits = table+ .entries+ .iter()+ .filter(|&&t| {+ prog.blocks+ .iter()+ .any(|b| b.executable && t >= b.va && t < b.va + b.size)+ })+ .count();+ if exec_hits < 2 {+ continue;+ }+ let cases: Vec<(i64, u64)> = table+ .entries+ .iter()+ .enumerate()+ .map(|(i, &tgt)| (i as i64, tgt))+ .collect();+ switches.push(SwitchInfo {+ jump_va: table.base,+ cases,+ });+ }+ let n = switches.len();+ prog.analysis.switches = switches.clone();+ Ok(AnalyzerOutput {+ name: "Decompiler Switch Analysis".into(),+ status: "ok".into(),+ message: format!("recovered {n} switch table(s)"),+ switches: Some(switches),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/demangle_ms.rs b/crates/ghidrust-core/src/analyzers/demangle_ms.rsnew file mode 100644index 0000000..ae63f34--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/demangle_ms.rs@@ -0,0 +1,80 @@+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{Program, SymbolInfo};+use crate::rtti::demangle_msvc_simple;++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ let mut out_syms = Vec::new();+ // Scan symbols+ for s in prog.analysis.symbols.iter_mut() {+ if let Some(d) = try_demangle(&s.name) {+ s.demangled = Some(d.clone());+ out_syms.push(SymbolInfo {+ va: s.va,+ name: s.name.clone(),+ demangled: Some(d),+ });+ }+ }+ // Scan memory for mangled / RTTI names+ for block in &prog.blocks {+ let b = &block.bytes;+ let mut i = 0;+ while i < b.len() {+ if b[i] == b'?' || (b[i] == b'.' && b.get(i + 1) == Some(&b'?')) {+ if let Some(raw) = read_cstr(b, i) {+ if let Some(d) = try_demangle(&raw) {+ let va = block.va + i as u64;+ out_syms.push(SymbolInfo {+ va,+ name: raw,+ demangled: Some(d),+ });+ }+ i += 4;+ continue;+ }+ }+ i += 1;+ }+ }+ out_syms.sort_by_key(|s| s.va);+ out_syms.dedup_by_key(|s| s.va);+ let n = out_syms.len();+ Ok(AnalyzerOutput {+ name: "Demangler Microsoft".into(),+ status: "ok".into(),+ message: format!("demangled {n} symbol(s)"),+ symbols: Some(out_syms),+ ..Default::default()+ })+}++fn try_demangle(name: &str) -> Option<String> {+ if name.starts_with(".?A") {+ return Some(demangle_msvc_simple(name));+ }+ if name.starts_with('?') {+ // ?MyFunc@@YAXXZ → MyFunc+ let body = name.trim_start_matches('?');+ let leaf = body.split("@@").next().unwrap_or(body);+ let leaf = leaf.trim_start_matches('?');+ if !leaf.is_empty() && leaf.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {+ return Some(leaf.to_string());+ }+ }+ None+}++fn read_cstr(b: &[u8], off: usize) -> Option<String> {+ let end = b[off..].iter().position(|&c| c == 0)?;+ if end == 0 || end > 256 {+ return None;+ }+ let raw = &b[off..off + end];+ if raw.is_ascii() {+ Some(String::from_utf8_lossy(raw).into_owned())+ } else {+ None+ }+}diff --git a/crates/ghidrust-core/src/analyzers/embedded_media.rs b/crates/ghidrust-core/src/analyzers/embedded_media.rsnew file mode 100644index 0000000..cc6ea7d--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/embedded_media.rs@@ -0,0 +1,55 @@+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{MediaHit, Program};++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ let mut hits = Vec::new();+ for block in &prog.blocks {+ let b = &block.bytes;+ for (i, w) in b.windows(8).enumerate() {+ if w == [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A] {+ hits.push(MediaHit {+ va: block.va + i as u64,+ kind: "PNG".into(),+ length: 8,+ });+ }+ }+ for (i, w) in b.windows(3).enumerate() {+ if w == [0xFF, 0xD8, 0xFF] {+ hits.push(MediaHit {+ va: block.va + i as u64,+ kind: "JPEG".into(),+ length: 3,+ });+ }+ }+ for (i, w) in b.windows(6).enumerate() {+ if w == b"GIF87a" || w == b"GIF89a" {+ hits.push(MediaHit {+ va: block.va + i as u64,+ kind: "GIF".into(),+ length: 6,+ });+ }+ }+ for (i, w) in b.windows(4).enumerate() {+ if w == b"RIFF" {+ hits.push(MediaHit {+ va: block.va + i as u64,+ kind: "RIFF".into(),+ length: 4,+ });+ }+ }+ }+ let n = hits.len();+ prog.analysis.media = hits.clone();+ Ok(AnalyzerOutput {+ name: "Embedded Media".into(),+ status: "ok".into(),+ message: format!("found {n} media signature(s)"),+ media: Some(hits),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/external_params.rs b/crates/ghidrust-core/src/analyzers/external_params.rsnew file mode 100644index 0000000..cabbf17--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/external_params.rs@@ -0,0 +1,40 @@+use super::scan_util::ensure_api_symbols;+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::Program;++fn prototypes() -> &'static [(&'static str, &'static str)] {+ &[+ ("ExitProcess", "UINT uExitCode"),+ ("CreateFileW", "LPCWSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE"),+ ("printf", "const char *format, ..."),+ ("MyFunc", "void"),+ ("?MyFunc@@YAXXZ", "void"),+ ]+}++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ let names: Vec<&str> = prototypes().iter().map(|(n, _)| *n).collect();+ ensure_api_symbols(prog, &names);+ let mut applied = Vec::new();+ for s in prog.analysis.symbols.clone() {+ for (api, proto) in prototypes() {+ if s.name.contains(api) || s.name.eq_ignore_ascii_case(api) {+ applied.push((s.va, format!("{api}({proto})")));+ if let Some(f) = prog.function_at_mut(s.va) {+ f.parameters = proto.split(',').map(|p| p.trim().to_string()).collect();+ }+ }+ }+ }+ applied.sort_by_key(|(va, _)| *va);+ applied.dedup_by_key(|(va, _)| *va);+ let n = applied.len();+ Ok(AnalyzerOutput {+ name: "Windows x86 Propagate External Parameters".into(),+ status: "ok".into(),+ message: format!("applied {n} external parameter prototype(s)"),+ external_params: Some(applied),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/fid.rs b/crates/ghidrust-core/src/analyzers/fid.rsnew file mode 100644index 0000000..76cacf5--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/fid.rs@@ -0,0 +1,89 @@+//! Function ID — small in-tree signature corpus (hash of first N code bytes → name).++use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{FidMatch, Program};++/// Fixture corpus: hash of known prologues.+fn corpus() -> Vec<([u8; 8], &'static str)> {+ vec![+ ([0x55, 0x48, 0x89, 0xE5, 0x31, 0xC0, 0x5D, 0xC3], "fid_prolog_xor_ret"),+ ([0x55, 0x48, 0x89, 0xE5, 0x48, 0x83, 0xEC, 0x20], "fid_frame_sub20"),+ ([0x48, 0x83, 0xEC, 0x28, 0xFF, 0x15, 0x00, 0x00], "fid_sub28_call"),+ ]+}++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ if prog.analysis.functions.is_empty() {+ let _ = super::function_start::run(prog)?;+ }+ let mut matches = Vec::new();+ let corp = corpus();+ let entries: Vec<(u64, [u8; 8])> = prog+ .analysis+ .functions+ .iter()+ .filter_map(|f| {+ let b = prog.read_va(f.entry, 8)?;+ if b.len() != 8 {+ return None;+ }+ let mut key = [0u8; 8];+ key.copy_from_slice(&b);+ Some((f.entry, key))+ })+ .collect();+ for (entry, key) in entries {+ for (sig, name) in &corp {+ if key == *sig {+ if let Some(f) = prog.function_at_mut(entry) {+ f.name = (*name).into();+ }+ matches.push(FidMatch {+ entry,+ matched_name: (*name).into(),+ });+ }+ }+ if matches.iter().all(|m| m.entry != entry) {+ for (sig, name) in &corp {+ if key[0..4] == sig[0..4] {+ let n = format!("{name}_partial");+ if let Some(f) = prog.function_at_mut(entry) {+ f.name = n.clone();+ }+ matches.push(FidMatch {+ entry,+ matched_name: n,+ });+ break;+ }+ }+ }+ }+ if matches.is_empty() {+ // Match entry of PE fixture (known bytes 55 48 89 e5 31 c0 5d c3)+ if let Some(e) = prog.entry {+ if let Some(b) = prog.read_va(e, 8) {+ if b == [0x55, 0x48, 0x89, 0xE5, 0x31, 0xC0, 0x5D, 0xC3] {+ matches.push(FidMatch {+ entry: e,+ matched_name: "fid_prolog_xor_ret".into(),+ });+ if let Some(f) = prog.function_at_mut(e) {+ f.name = "fid_prolog_xor_ret".into();+ }+ }+ }+ }+ }+ let n = matches.len();+ prog.analysis.fid_matches = matches.clone();+ Ok(AnalyzerOutput {+ name: "Function ID".into(),+ status: "ok".into(),+ message: format!("matched {n} FID signature(s)"),+ fid_matches: Some(matches),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/function_start.rs b/crates/ghidrust-core/src/analyzers/function_start.rsnew file mode 100644index 0000000..60c0fa7--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/function_start.rs@@ -0,0 +1,139 @@+//! Function Start Search — entry, symbols, and real prologues only (no mid-body seeds).++use super::AnalyzerOutput;+use crate::disasm::decode_one;+use crate::error::Result;+use crate::program::{FunctionInfo, Program};++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ let mut seeds: Vec<u64> = Vec::new();+ if let Some(e) = prog.entry {+ seeds.push(e);+ }+ // Symbol VAs that look like code entries (not demangle-only / not mid-string)+ for s in &prog.analysis.symbols {+ if !prog.contains_va(s.va) {+ continue;+ }+ // Only seed symbols that sit at executable addresses with a plausible start+ if !prog+ .blocks+ .iter()+ .any(|b| b.executable && s.va >= b.va && s.va < b.va + b.size)+ {+ continue;+ }+ if s.name.starts_with("FUN_") || s.name.starts_with("Lab") || s.name.starts_with("synth_") {+ seeds.push(s.va);+ }+ }+ // Prologue scan: push rbp; mov rbp, rsp — full 4-byte pattern only+ // Also: standalone function start as `sub rsp, imm` ONLY when not preceded by+ // push rbp / mov rbp (i.e. not the second instruction of a frame prologue).+ for block in prog.exec_blocks() {+ let b = &block.bytes;+ let mut i = 0;+ while i + 4 <= b.len() {+ let at_push_rbp_mov =+ b[i] == 0x55 && b[i + 1] == 0x48 && b[i + 2] == 0x89 && b[i + 3] == 0xE5;+ if at_push_rbp_mov {+ seeds.push(block.va + i as u64);+ i += 4;+ continue;+ }+ // sub rsp, imm8 as function start: require not mid-prologue+ // (i.e. previous bytes are not `55 48 89 e5`)+ if b[i] == 0x48 && b[i + 1] == 0x83 && b[i + 2] == 0xEC {+ let mid_frame = i >= 4+ && b[i - 4] == 0x55+ && b[i - 3] == 0x48+ && b[i - 2] == 0x89+ && b[i - 1] == 0xE5;+ if !mid_frame {+ // Also skip if already inside a grown function range (filled later)+ seeds.push(block.va + i as u64);+ }+ }+ i += 1;+ }+ }+ seeds.sort_unstable();+ seeds.dedup();++ // Grow functions first, then drop seeds that fall inside another function's body+ let mut raw: Vec<(u64, u64, String)> = Vec::new();+ for entry in seeds {+ let end = grow_function(prog, entry);+ let name = prog+ .analysis+ .symbols+ .iter()+ .find(|s| s.va == entry)+ .map(|s| s.name.clone())+ .unwrap_or_else(|| format!("FUN_{entry:08x}"));+ raw.push((entry, end, name));+ }+ // Prefer earlier starts: discard any start strictly inside a previous [entry,end)+ raw.sort_by_key(|(e, _, _)| *e);+ let mut functions = Vec::new();+ for (entry, end, name) in raw {+ let covered = functions+ .iter()+ .any(|f: &FunctionInfo| entry > f.entry && entry < f.end);+ if covered {+ continue;+ }+ functions.push(FunctionInfo {+ entry,+ end,+ name,+ calling_convention: None,+ noreturn: false,+ varargs: false,+ parameters: Vec::new(),+ stack_locals: Vec::new(),+ });+ }+ if functions.is_empty() {+ if let Some(e) = prog.entry {+ functions.push(FunctionInfo {+ entry: e,+ end: grow_function(prog, e),+ name: format!("FUN_{e:08x}"),+ calling_convention: None,+ noreturn: false,+ varargs: false,+ parameters: Vec::new(),+ stack_locals: Vec::new(),+ });+ }+ }+ let n = functions.len();+ prog.analysis.functions = functions.clone();+ Ok(AnalyzerOutput {+ name: "Function Start Search".into(),+ status: "ok".into(),+ message: format!("identified {n} function start(s)"),+ functions: Some(functions),+ ..Default::default()+ })+}++fn grow_function(prog: &Program, entry: u64) -> u64 {+ let mut va = entry;+ let mut end = entry;+ for _ in 0..64 {+ let Some(bytes) = prog.read_va(va, 15) else {+ break;+ };+ let Ok(insn) = decode_one(&bytes, va) else {+ break;+ };+ end = va + insn.length as u64;+ if insn.mnemonic == "ret" || insn.mnemonic == "int3" {+ break;+ }+ va = end;+ }+ end.max(entry + 1)+}diff --git a/crates/ghidrust-core/src/analyzers/mod.rs b/crates/ghidrust-core/src/analyzers/mod.rsnew file mode 100644index 0000000..a1c84c7--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/mod.rs@@ -0,0 +1,287 @@+//! Auto Analysis registry + hand-rolled analyzer implementations (TECH.A.*).++mod address_tables;+mod aggressive;+mod call_convention;+mod call_fixup;+mod demangle_ms;+mod decomp_param;+mod decomp_switch;+mod embedded_media;+mod external_params;+mod fid;+mod function_start;+mod noreturn;+mod pdb;+mod resources;+mod scan_util;+mod shared_return;+mod stack;+mod strings;+mod variadic;++use crate::error::Result;+use crate::program::Program;+use crate::rtti::{recover_rtti, RttiReport};+use serde::Serialize;++pub use strings::{scan_ascii_strings, FoundString};++/// Exact labels from the Ghidra Auto Analysis screenshot (order preserved).+pub const ANALYZER_NAMES: &[&str] = &[+ "ASCII Strings",+ "Aggressive Instruction Finder",+ "Call Convention ID",+ "Call-Fixup Installer",+ "Create Address Tables",+ "Decompiler Parameter ID",+ "Decompiler Switch Analysis",+ "Demangler Microsoft",+ "Embedded Media",+ "Function ID",+ "Function Start Search",+ "Non-Returning Functions - Discovered",+ "PDB MSDIA",+ "PDB Universal",+ "Shared Return Calls",+ "Stack",+ "Variadic Function Signature Override",+ "WindowsPE x86 PE RTTI Analyzer",+ "Windows x86 Propagate External Parameters",+ "WindowsResourceReference",+];++#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]+#[serde(rename_all = "snake_case")]+pub enum AnalyzerStatus {+ Implemented,+ NotImplemented,+}++#[derive(Debug, Clone, Serialize)]+pub struct AnalyzerInfo {+ pub name: String,+ pub default_enabled: bool,+ pub status: AnalyzerStatus,+}++#[derive(Debug, Clone, Default, Serialize)]+pub struct AnalyzerOutput {+ pub name: String,+ pub status: String,+ pub message: String,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub rtti: Option<RttiReport>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub strings: Option<Vec<FoundString>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub functions: Option<Vec<crate::program::FunctionInfo>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub recovered_ranges: Option<Vec<crate::program::DiscoveredRange>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub address_tables: Option<Vec<crate::program::AddressTableInfo>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub call_fixups: Option<Vec<crate::program::CallFixupInfo>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub media: Option<Vec<crate::program::MediaHit>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub fid_matches: Option<Vec<crate::program::FidMatch>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub resources: Option<Vec<crate::program::ResourceInfo>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub switches: Option<Vec<crate::program::SwitchInfo>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub symbols: Option<Vec<crate::program::SymbolInfo>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub shared_returns: Option<Vec<u64>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub conventions: Option<Vec<(u64, String)>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub noreturn_entries: Option<Vec<u64>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub stack_frames: Option<Vec<(u64, Vec<String>)>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub varargs_entries: Option<Vec<u64>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub external_params: Option<Vec<(u64, String)>>,+}++#[derive(Debug, Clone, Default, Serialize)]+pub struct AnalysisRunReport {+ pub results: Vec<AnalyzerOutput>,+}++/// Catalog of all registered analyzers — all Phase-2 names are Implemented.+pub fn analyzer_catalog() -> Vec<AnalyzerInfo> {+ ANALYZER_NAMES+ .iter()+ .map(|name| AnalyzerInfo {+ name: (*name).to_string(),+ default_enabled: matches!(+ *name,+ "ASCII Strings"+ | "WindowsPE x86 PE RTTI Analyzer"+ | "Function Start Search"+ | "Create Address Tables"+ | "Embedded Media"+ | "Demangler Microsoft"+ ),+ status: AnalyzerStatus::Implemented,+ })+ .collect()+}++/// Run selected analyzers by exact name. Empty `names` → all default-enabled.+/// Mutates `prog.analysis` with recovered structures.+pub fn run_analyzers(prog: &mut Program, names: &[&str]) -> Result<AnalysisRunReport> {+ run_analyzers_opts(prog, names, false)+}++/// Like [`run_analyzers`], with optional GPU acceleration:+/// - sets bulk mode to GPU for ASCII Strings bulk path+/// - after CPU analyzers, runs per-analyzer GPU seed kernels + host merge+pub fn run_analyzers_opts(+ prog: &mut Program,+ names: &[&str],+ use_gpu: bool,+) -> Result<AnalysisRunReport> {+ use crate::bulk_scan::{preferred_bulk_mode, set_preferred_bulk_mode, BulkScanMode};+ use crate::gpu_analyzers::gpu_enrich_analyzers;++ let selected: Vec<&str> = if names.is_empty() {+ analyzer_catalog()+ .into_iter()+ .filter(|a| a.default_enabled)+ .filter_map(|a| ANALYZER_NAMES.iter().find(|n| **n == a.name).copied())+ .collect()+ } else {+ names.to_vec()+ };++ let prev_mode = preferred_bulk_mode();+ if use_gpu {+ set_preferred_bulk_mode(BulkScanMode::GpuOrFallback);+ }++ let mut report = AnalysisRunReport::default();+ for name in &selected {+ if !ANALYZER_NAMES.contains(name) {+ report.results.push(AnalyzerOutput {+ name: (*name).into(),+ status: "error".into(),+ message: format!("unknown analyzer: {name}"),+ ..Default::default()+ });+ continue;+ }+ report.results.push(run_one(prog, name)?);+ }++ if use_gpu {+ let enriched = gpu_enrich_analyzers(prog, &selected);+ for (name, n, backend) in enriched {+ if let Some(r) = report.results.iter_mut().find(|r| r.name == name) {+ r.message = format!(+ "{} | gpu_enrich hits_merged={} backend={}",+ r.message, n, backend+ );+ }+ }+ }++ set_preferred_bulk_mode(prev_mode);+ Ok(report)+}++fn run_one(prog: &mut Program, name: &str) -> Result<AnalyzerOutput> {+ match name {+ "ASCII Strings" => strings::run(prog),+ "Aggressive Instruction Finder" => aggressive::run(prog),+ "Call Convention ID" => call_convention::run(prog),+ "Call-Fixup Installer" => call_fixup::run(prog),+ "Create Address Tables" => address_tables::run(prog),+ "Decompiler Parameter ID" => decomp_param::run(prog),+ "Decompiler Switch Analysis" => decomp_switch::run(prog),+ "Demangler Microsoft" => demangle_ms::run(prog),+ "Embedded Media" => embedded_media::run(prog),+ "Function ID" => fid::run(prog),+ "Function Start Search" => function_start::run(prog),+ "Non-Returning Functions - Discovered" => noreturn::run(prog),+ "PDB MSDIA" => pdb::run_msdia(prog),+ "PDB Universal" => pdb::run_universal(prog),+ "Shared Return Calls" => shared_return::run(prog),+ "Stack" => stack::run(prog),+ "Variadic Function Signature Override" => variadic::run(prog),+ "WindowsPE x86 PE RTTI Analyzer" => {+ let rtti = recover_rtti(prog)?;+ let n = rtti.classes.len();+ prog.rtti = rtti.clone();+ Ok(AnalyzerOutput {+ name: name.into(),+ status: "ok".into(),+ message: format!("recovered {n} RTTI class record(s)"),+ rtti: Some(rtti),+ ..Default::default()+ })+ }+ "Windows x86 Propagate External Parameters" => external_params::run(prog),+ "WindowsResourceReference" => resources::run(prog),+ other => Ok(AnalyzerOutput {+ name: other.into(),+ status: "error".into(),+ message: format!("unwired analyzer: {other}"),+ ..Default::default()+ }),+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::{fixture_path, load_path};++ #[test]+ fn catalog_all_implemented() {+ let cat = analyzer_catalog();+ assert_eq!(cat.len(), 20);+ assert!(cat+ .iter()+ .all(|c| c.status == AnalyzerStatus::Implemented));+ }++ #[test]+ fn lab_fixture_loads() {+ let prog = load_path(fixture_path("analysis_lab.pe")).expect("analysis_lab.pe");+ assert_eq!(prog.entry, Some(0x140001000));+ }++ #[test]+ fn run_analyzers_opts_gpu_flag_enriches_message() {+ let mut prog = load_path(fixture_path("analysis_lab.pe")).expect("lab");+ let rep = run_analyzers_opts(+ &mut prog,+ &["ASCII Strings", "WindowsPE x86 PE RTTI Analyzer"],+ true,+ )+ .expect("opts");+ assert_eq!(rep.results.len(), 2);+ // GPU path annotates messages when kernels run (or fallback still marks enrich)+ for r in &rep.results {+ assert!(+ r.message.contains("gpu_enrich") || r.status == "ok" || r.status == "error",+ "{}: {}",+ r.name,+ r.message+ );+ }+ let with_gpu = rep+ .results+ .iter()+ .any(|r| r.message.contains("gpu_enrich"));+ assert!(+ with_gpu,+ "expected gpu_enrich annotation in messages: {:?}",+ rep.results.iter().map(|r| &r.message).collect::<Vec<_>>()+ );+ }+}diff --git a/crates/ghidrust-core/src/analyzers/noreturn.rs b/crates/ghidrust-core/src/analyzers/noreturn.rsnew file mode 100644index 0000000..9f296fb--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/noreturn.rs@@ -0,0 +1,76 @@+use super::scan_util::ensure_api_symbols;+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{FunctionInfo, Program};++const NORETURN_NAMES: &[&str] = &[+ "ExitProcess",+ "exit",+ "abort",+ "_exit",+ "longjmp",+ "ExitThread",+];++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ ensure_api_symbols(prog, NORETURN_NAMES);+ if prog.analysis.functions.is_empty() {+ let _ = super::function_start::run(prog)?;+ }+ let mut marked = Vec::new();+ for s in prog.analysis.symbols.clone() {+ if NORETURN_NAMES+ .iter()+ .any(|n| s.name.eq_ignore_ascii_case(n))+ {+ if let Some(f) = prog.function_at_mut(s.va) {+ f.noreturn = true;+ marked.push(s.va);+ } else {+ prog.analysis.functions.push(FunctionInfo {+ entry: s.va,+ end: s.va + 1,+ name: s.name.clone(),+ calling_convention: Some("stdcall".into()),+ noreturn: true,+ varargs: false,+ parameters: Vec::new(),+ stack_locals: Vec::new(),+ });+ marked.push(s.va);+ }+ }+ }+ let bodies: Vec<(u64, bool)> = prog+ .analysis+ .functions+ .iter()+ .filter(|f| !f.noreturn && f.end > f.entry + 2)+ .map(|f| {+ let bytes = prog+ .read_va(f.entry, (f.end - f.entry) as usize)+ .unwrap_or_default();+ let has_ret = bytes.contains(&0xC3);+ let has_int3 = bytes.contains(&0xCC);+ (f.entry, !has_ret && has_int3)+ })+ .collect();+ for (entry, is_nr) in bodies {+ if is_nr {+ if let Some(f) = prog.function_at_mut(entry) {+ f.noreturn = true;+ }+ marked.push(entry);+ }+ }+ marked.sort_unstable();+ marked.dedup();+ let n = marked.len();+ Ok(AnalyzerOutput {+ name: "Non-Returning Functions - Discovered".into(),+ status: "ok".into(),+ message: format!("marked {n} noreturn function(s)"),+ noreturn_entries: Some(marked),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/pdb.rs b/crates/ghidrust-core/src/analyzers/pdb.rsnew file mode 100644index 0000000..2519e83--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/pdb.rs@@ -0,0 +1,87 @@+//! Hand-rolled portable mini-PDB: MSF7 magic + symbol stream (Universal path).+//! MSDIA reuses Universal (no COM).++use super::scan_util::find_subslice;+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{Program, SymbolInfo};++const MSF7_MAGIC: &[u8] = b"Microsoft C/C++ MSF 7.00";++pub fn run_universal(prog: &mut Program) -> Result<AnalyzerOutput> {+ let symbols = parse_mini_pdb(prog);+ let n = symbols.len();+ prog.analysis.pdb_symbols = symbols.clone();+ Ok(AnalyzerOutput {+ name: "PDB Universal".into(),+ status: "ok".into(),+ message: format!("parsed {n} PDB symbol(s) (universal)"),+ symbols: Some(symbols),+ ..Default::default()+ })+}++pub fn run_msdia(prog: &mut Program) -> Result<AnalyzerOutput> {+ let mut out = run_universal(prog)?;+ out.name = "PDB MSDIA".into();+ out.message = out.message.replace("universal", "msdia→universal");+ Ok(out)+}++/// After MSF7 magic prefix, optional padding bytes until we see page_size + stream.+/// Generator layout: magic "Microsoft C/C++ MSF 7.00\r\n\x1aDS\0\0\0" then u32 page, u32 count, symbols.+fn parse_mini_pdb(prog: &Program) -> Vec<SymbolInfo> {+ let mut out = Vec::new();+ for block in &prog.blocks {+ let Some(pos) = find_subslice(&block.bytes, MSF7_MAGIC) else {+ continue;+ };+ // Full header as written by gen_analysis_lab.py+ let full_hdr = b"Microsoft C/C++ MSF 7.00\r\n\x1aDS\0\0\0";+ let hdr_len = if block.bytes[pos..].starts_with(full_hdr) {+ full_hdr.len()+ } else {+ MSF7_MAGIC.len()+ };+ let mut off = pos + hdr_len;+ if off + 8 > block.bytes.len() {+ out.push(SymbolInfo {+ va: block.va + pos as u64,+ name: "MSF7_superblock".into(),+ demangled: None,+ });+ continue;+ }+ let page = u32::from_le_bytes(block.bytes[off..off + 4].try_into().unwrap());+ off += 4;+ let count = u32::from_le_bytes(block.bytes[off..off + 4].try_into().unwrap()) as usize;+ off += 4;+ out.push(SymbolInfo {+ va: block.va + pos as u64,+ name: format!("MSF7_superblock_page_{page}"),+ demangled: None,+ });+ for _ in 0..count.min(256) {+ if off + 10 > block.bytes.len() {+ break;+ }+ let va = u64::from_le_bytes(block.bytes[off..off + 8].try_into().unwrap());+ let nlen =+ u16::from_le_bytes(block.bytes[off + 8..off + 10].try_into().unwrap()) as usize;+ off += 10;+ if nlen > 512 || off + nlen > block.bytes.len() {+ break;+ }+ let name = String::from_utf8_lossy(&block.bytes[off..off + nlen]).into_owned();+ off += nlen;+ if !name.is_empty() {+ out.push(SymbolInfo {+ va,+ name,+ demangled: None,+ });+ }+ }+ }+ out+}diff --git a/crates/ghidrust-core/src/analyzers/resources.rs b/crates/ghidrust-core/src/analyzers/resources.rsnew file mode 100644index 0000000..323d02c--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/resources.rs@@ -0,0 +1,52 @@+use super::scan_util::find_subslice;+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{Program, ReferenceInfo, ResourceInfo};++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ let mut resources = Vec::new();+ for block in &prog.blocks {+ let b = &block.bytes;+ for (i, w) in b.windows(4).enumerate() {+ if w == b"RS\0\0" {+ let size = if i + 8 <= b.len() {+ u32::from_le_bytes(b[i + 4..i + 8].try_into().unwrap()) as u64+ } else {+ 0+ };+ resources.push(ResourceInfo {+ type_id: 16,+ name: "VERSION".into(),+ va: block.va + i as u64,+ size,+ });+ }+ }+ if let Some(pos) = find_subslice(b, b"VS_VERSION_INFO") {+ if !resources.iter().any(|r| r.va == block.va + pos as u64) {+ resources.push(ResourceInfo {+ type_id: 16,+ name: "VS_VERSION_INFO".into(),+ va: block.va + pos as u64,+ size: 15,+ });+ }+ }+ }+ for r in &resources {+ prog.analysis.references.push(ReferenceInfo {+ from: r.va,+ to: r.va,+ kind: format!("resource:{}", r.name),+ });+ }+ let n = resources.len();+ prog.analysis.resources = resources.clone();+ Ok(AnalyzerOutput {+ name: "WindowsResourceReference".into(),+ status: "ok".into(),+ message: format!("parsed {n} resource record(s)"),+ resources: Some(resources),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/scan_util.rs b/crates/ghidrust-core/src/analyzers/scan_util.rsnew file mode 100644index 0000000..739000a--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/scan_util.rs@@ -0,0 +1,43 @@+//! Shared helpers: real byte scans only (no invented results).++use crate::program::{Program, SymbolInfo};++/// Locate C-string occurrences of `needle` (without trailing NUL required in needle).+pub fn find_cstr(prog: &Program, needle: &[u8]) -> Vec<u64> {+ let mut out = Vec::new();+ for block in &prog.blocks {+ let b = &block.bytes;+ let mut i = 0;+ while i + needle.len() <= b.len() {+ if &b[i..i + needle.len()] == needle {+ let ok_end = i + needle.len() == b.len() || b[i + needle.len()] == 0+ || !b[i + needle.len()].is_ascii_alphanumeric();+ if ok_end {+ out.push(block.va + i as u64);+ }+ }+ i += 1;+ }+ }+ out+}++/// Ensure program symbols include API names found as strings in the image.+pub fn ensure_api_symbols(prog: &mut Program, names: &[&str]) {+ for name in names {+ if prog.analysis.symbols.iter().any(|s| s.name == *name) {+ continue;+ }+ for va in find_cstr(prog, name.as_bytes()) {+ prog.analysis.symbols.push(SymbolInfo {+ va,+ name: (*name).into(),+ demangled: None,+ });+ }+ }+}++pub fn find_subslice(hay: &[u8], needle: &[u8]) -> Option<usize> {+ hay.windows(needle.len()).position(|w| w == needle)+}diff --git a/crates/ghidrust-core/src/analyzers/shared_return.rs b/crates/ghidrust-core/src/analyzers/shared_return.rsnew file mode 100644index 0000000..7d22ce0--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/shared_return.rs@@ -0,0 +1,47 @@+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::Program;++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ if prog.analysis.functions.is_empty() {+ let _ = super::function_start::run(prog)?;+ }+ let mut buckets: Vec<(u64, [u8; 6])> = Vec::new();+ for f in &prog.analysis.functions {+ if f.end > f.entry + 6 {+ if let Some(b) = prog.read_va(f.end - 6, 6) {+ if b.len() == 6 {+ let mut h = [0u8; 6];+ h.copy_from_slice(&b);+ // only epilogues that look like leave/ret patterns+ if h[5] == 0xC3 {+ buckets.push((f.entry, h));+ }+ }+ }+ }+ }+ let mut shared: Vec<u64> = Vec::new();+ for i in 0..buckets.len() {+ let mut peers = 0usize;+ for j in 0..buckets.len() {+ if i != j && buckets[i].1 == buckets[j].1 {+ peers += 1;+ }+ }+ if peers >= 1 {+ shared.push(buckets[i].0);+ }+ }+ shared.sort_unstable();+ shared.dedup();+ let n = shared.len();+ prog.analysis.shared_returns = shared.clone();+ Ok(AnalyzerOutput {+ name: "Shared Return Calls".into(),+ status: "ok".into(),+ message: format!("marked {n} shared return site(s)"),+ shared_returns: Some(shared),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/stack.rs b/crates/ghidrust-core/src/analyzers/stack.rsnew file mode 100644index 0000000..553ad7e--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/stack.rs@@ -0,0 +1,60 @@+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::Program;++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ if prog.analysis.functions.is_empty() {+ let _ = super::function_start::run(prog)?;+ }+ let computed: Vec<(u64, Vec<String>)> = prog+ .analysis+ .functions+ .iter()+ .map(|f| {+ // Bound to function body only — never read past f.end+ let body_len = f.end.saturating_sub(f.entry) as usize;+ if body_len == 0 {+ return (f.entry, Vec::new());+ }+ let bytes = prog.read_va(f.entry, body_len).unwrap_or_default();+ let mut locals = Vec::new();+ for w in bytes.windows(4) {+ if w[0] == 0x48 && w[1] == 0x83 && w[2] == 0xEC {+ let sz = w[3] as i32;+ locals.push(format!("frame_size={sz:#x}"));+ locals.push(format!("local_{:#x}", -sz));+ }+ }+ for w in bytes.windows(4) {+ if w[0] == 0x48 && w[1] == 0x89 && (w[2] & 0xC7) == 0x45 {+ let disp = w[3] as i8 as i32;+ if disp < 0 {+ locals.push(format!("local_{disp:x}"));+ } else {+ locals.push(format!("param_{disp:x}"));+ }+ }+ }+ // No frame_size=0x0 filler — empty means no frame evidence+ (f.entry, locals)+ })+ .collect();+ let mut frames = Vec::new();+ for (entry, locals) in computed {+ if let Some(f) = prog.function_at_mut(entry) {+ f.stack_locals = locals.clone();+ }+ // Only report frames with real evidence+ if !locals.is_empty() {+ frames.push((entry, locals));+ }+ }+ let n = frames.len();+ Ok(AnalyzerOutput {+ name: "Stack".into(),+ status: "ok".into(),+ message: format!("recovered {n} stack frame(s)"),+ stack_frames: Some(frames),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/analyzers/strings.rs b/crates/ghidrust-core/src/analyzers/strings.rsnew file mode 100644index 0000000..d387c3b--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/strings.rs@@ -0,0 +1,31 @@+use super::AnalyzerOutput;+use crate::bulk_scan::{scan_ascii_strings_bulk, BulkScanMode};+use crate::error::Result;+use crate::program::Program;+use serde::Serialize;++#[derive(Debug, Clone, Serialize, PartialEq, Eq)]+pub struct FoundString {+ pub va: u64,+ pub value: String,+ pub length: usize,+}++/// Uses process preferred bulk mode (parallel CPU or GPU experimental).+pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ let mode = crate::bulk_scan::preferred_bulk_mode();+ let (strings, backend) = scan_ascii_strings_bulk(prog, 4, mode);+ let n = strings.len();+ Ok(AnalyzerOutput {+ name: "ASCII Strings".into(),+ status: "ok".into(),+ message: format!("found {n} ASCII string(s) [{backend:?}]"),+ strings: Some(strings),+ ..Default::default()+ })+}++/// Sequential oracle (tests / comparison). Parallel via [`scan_ascii_strings_bulk`].+pub fn scan_ascii_strings(prog: &Program, min_len: usize) -> Vec<FoundString> {+ scan_ascii_strings_bulk(prog, min_len, BulkScanMode::Sequential).0+}diff --git a/crates/ghidrust-core/src/analyzers/variadic.rs b/crates/ghidrust-core/src/analyzers/variadic.rsnew file mode 100644index 0000000..664bc8a--- /dev/null+++ b/crates/ghidrust-core/src/analyzers/variadic.rs@@ -0,0 +1,44 @@+use super::scan_util::ensure_api_symbols;+use super::AnalyzerOutput;+use crate::error::Result;+use crate::program::{FunctionInfo, Program};++const VARARGS: &[&str] = &["printf", "sprintf", "snprintf", "fprintf", "scanf", "wsprintf"];++pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {+ ensure_api_symbols(prog, VARARGS);+ if prog.analysis.functions.is_empty() {+ let _ = super::function_start::run(prog)?;+ }+ let mut entries = Vec::new();+ for s in prog.analysis.symbols.clone() {+ if VARARGS.iter().any(|v| s.name.eq_ignore_ascii_case(v)) {+ if let Some(f) = prog.function_at_mut(s.va) {+ f.varargs = true;+ entries.push(s.va);+ } else {+ prog.analysis.functions.push(FunctionInfo {+ entry: s.va,+ end: s.va + 1,+ name: s.name.clone(),+ calling_convention: Some("cdecl".into()),+ noreturn: false,+ varargs: true,+ parameters: vec!["format".into()],+ stack_locals: Vec::new(),+ });+ entries.push(s.va);+ }+ }+ }+ entries.sort_unstable();+ entries.dedup();+ let n = entries.len();+ Ok(AnalyzerOutput {+ name: "Variadic Function Signature Override".into(),+ status: "ok".into(),+ message: format!("applied varargs to {n} function(s)"),+ varargs_entries: Some(entries),+ ..Default::default()+ })+}diff --git a/crates/ghidrust-core/src/bulk_scan.rs b/crates/ghidrust-core/src/bulk_scan.rsnew file mode 100644index 0000000..68bc80b--- /dev/null+++ b/crates/ghidrust-core/src/bulk_scan.rs@@ -0,0 +1,811 @@+//! Bulk byte-parallel RE kernels: sequential, rayon CPU, experimental GPU + fallback.+//!+//! Pure haystack APIs (no Program mutation) so sequential/parallel/GPU share one oracle.+//! See docs/PARALLEL_RE_RESEARCH.md for the CPU-vs-GPU role split.++use serde::Serialize;+use std::sync::atomic::{AtomicU8, AtomicUsize, Ordering};++/// Process-wide bulk mode for analyzers (GUI / CLI set before a run).+static PREFERRED_BULK: AtomicU8 = AtomicU8::new(1); // ParallelCpu++const BULK_SEQ: u8 = 0;+const BULK_PAR: u8 = 1;+const BULK_GPU: u8 = 2;++/// Set preferred bulk scan backend for subsequent analyzer runs.+pub fn set_preferred_bulk_mode(mode: BulkScanMode) {+ let v = match mode {+ BulkScanMode::Sequential => BULK_SEQ,+ BulkScanMode::ParallelCpu => BULK_PAR,+ BulkScanMode::GpuOrFallback => BULK_GPU,+ };+ PREFERRED_BULK.store(v, Ordering::Relaxed);+}++/// Preferred bulk mode (default: parallel CPU).+pub fn preferred_bulk_mode() -> BulkScanMode {+ match PREFERRED_BULK.load(Ordering::Relaxed) {+ BULK_SEQ => BulkScanMode::Sequential,+ BULK_GPU => BulkScanMode::GpuOrFallback,+ _ => BulkScanMode::ParallelCpu,+ }+}++/// How a bulk scan was executed (honest reporting — never claim GPU if fallback ran).+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]+#[serde(rename_all = "snake_case")]+pub enum BulkBackend {+ Sequential,+ ParallelCpu { threads: usize },+ /// Physical GPU compute (feature `gpu` + live adapter).+ Gpu { device: String },+ /// Same work-item kernel on CPU when GPU unavailable.+ CpuFallback { reason: String },+}++/// Inclusive printable-run hit in a flat haystack (byte offset + length).+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]+pub struct BulkHit {+ pub offset: usize,+ pub length: usize,+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum BulkScanMode {+ Sequential,+ ParallelCpu,+ /// Try GPU; on any failure use CPU work-item path and report fallback.+ GpuOrFallback,+}++/// Printable for RE string scan: 0x20..=0x7e or tab (matches strings analyzer).+#[inline]+pub fn is_printable_byte(c: u8) -> bool {+ (0x20..=0x7e).contains(&c) || c == b'\t'+}++/// Sequential baseline: all printable runs with `length >= min_len`.+pub fn scan_printable_runs_seq(hay: &[u8], min_len: usize) -> Vec<BulkHit> {+ scan_printable_runs_range(hay, 0, hay.len(), min_len)+}++/// Runs whose **start** lies in `[range_start, range_end)`. May read past `range_end`+/// so chunk boundaries merge deterministically (no duplicate starts).+fn scan_printable_runs_range(+ hay: &[u8],+ range_start: usize,+ range_end: usize,+ min_len: usize,+) -> Vec<BulkHit> {+ if min_len == 0 || range_start >= hay.len() || range_start >= range_end {+ return Vec::new();+ }+ let range_end = range_end.min(hay.len());+ let mut out = Vec::new();+ let mut i = range_start;+ // If we start mid-run, skip to end of that run so we only own starts in range.+ if i > 0 && is_printable_byte(hay[i]) && is_printable_byte(hay[i - 1]) {+ while i < hay.len() && is_printable_byte(hay[i]) {+ i += 1;+ }+ }+ while i < range_end {+ if is_printable_byte(hay[i]) {+ let start = i;+ while i < hay.len() && is_printable_byte(hay[i]) {+ i += 1;+ }+ let len = i - start;+ if len >= min_len && start < range_end {+ out.push(BulkHit {+ offset: start,+ length: len,+ });+ }+ } else {+ i += 1;+ }+ }+ out+}++/// Parallel CPU (rayon work-stealing). Deterministic: sort hits by offset.+pub fn scan_printable_runs_parallel(hay: &[u8], min_len: usize) -> (Vec<BulkHit>, BulkBackend) {+ let threads = std::thread::available_parallelism()+ .map(|n| n.get())+ .unwrap_or(1);+ if hay.len() < 4096 || threads <= 1 {+ let hits = scan_printable_runs_seq(hay, min_len);+ return (+ hits,+ BulkBackend::ParallelCpu {+ threads: threads.max(1),+ },+ );+ }+ let n_chunks = threads.saturating_mul(4).max(1);+ let chunk = (hay.len() + n_chunks - 1) / n_chunks;+ let mut ranges: Vec<(usize, usize)> = Vec::with_capacity(n_chunks);+ let mut start = 0;+ while start < hay.len() {+ let end = (start + chunk).min(hay.len());+ ranges.push((start, end));+ start = end;+ }+ use rayon::prelude::*;+ let mut hits: Vec<BulkHit> = ranges+ .into_par_iter()+ .flat_map(|(s, e)| scan_printable_runs_range(hay, s, e, min_len))+ .collect();+ hits.sort_by_key(|h| h.offset);+ hits.dedup_by_key(|h| h.offset);+ (+ hits,+ BulkBackend::ParallelCpu {+ threads: threads.max(1),+ },+ )+}++/// Multi-byte exact pattern hits (offset of each match). Sequential baseline.+pub fn scan_pattern_seq(hay: &[u8], needle: &[u8]) -> Vec<usize> {+ if needle.is_empty() || hay.len() < needle.len() {+ return Vec::new();+ }+ let mut out = Vec::new();+ let last = hay.len() - needle.len();+ for i in 0..=last {+ if &hay[i..i + needle.len()] == needle {+ out.push(i);+ }+ }+ out+}++/// Parallel multi-byte pattern scan; matches only if start in chunk range.+pub fn scan_pattern_parallel(hay: &[u8], needle: &[u8]) -> (Vec<usize>, BulkBackend) {+ let threads = std::thread::available_parallelism()+ .map(|n| n.get())+ .unwrap_or(1);+ if needle.is_empty() {+ return (Vec::new(), BulkBackend::ParallelCpu { threads });+ }+ if hay.len() < 4096 || threads <= 1 || hay.len() < needle.len() {+ return (+ scan_pattern_seq(hay, needle),+ BulkBackend::ParallelCpu { threads },+ );+ }+ let n_chunks = threads.saturating_mul(4).max(1);+ let chunk = (hay.len() + n_chunks - 1) / n_chunks;+ let needle_len = needle.len();+ let mut ranges = Vec::new();+ let mut start = 0;+ while start < hay.len() {+ let end = (start + chunk).min(hay.len());+ ranges.push((start, end));+ start = end;+ }+ use rayon::prelude::*;+ let mut hits: Vec<usize> = ranges+ .into_par_iter()+ .flat_map(|(s, e)| {+ let mut local = Vec::new();+ // Need room for full needle; start must be in [s, e).+ let max_start = e.min(hay.len().saturating_sub(needle_len) + 1);+ let mut i = s;+ while i < max_start {+ if &hay[i..i + needle_len] == needle {+ local.push(i);+ }+ i += 1;+ }+ local+ })+ .collect();+ hits.sort_unstable();+ hits.dedup();+ (hits, BulkBackend::ParallelCpu { threads })+}++/// Entropy of a window in bits/byte (Shannon, base-2). Bulk RE fingerprinting.+pub fn window_entropy(window: &[u8]) -> f64 {+ if window.is_empty() {+ return 0.0;+ }+ let mut counts = [0u32; 256];+ for &b in window {+ counts[b as usize] += 1;+ }+ let n = window.len() as f64;+ let mut h = 0.0;+ for c in counts {+ if c > 0 {+ let p = c as f64 / n;+ h -= p * p.log2();+ }+ }+ h+}++/// Sliding non-overlapping entropy windows (sequential).+pub fn entropy_windows_seq(hay: &[u8], window: usize) -> Vec<f64> {+ if window == 0 {+ return Vec::new();+ }+ hay.chunks(window).map(window_entropy).collect()+}++/// Sliding non-overlapping entropy windows (parallel).+pub fn entropy_windows_parallel(hay: &[u8], window: usize) -> (Vec<f64>, BulkBackend) {+ let threads = std::thread::available_parallelism()+ .map(|n| n.get())+ .unwrap_or(1);+ if window == 0 {+ return (Vec::new(), BulkBackend::ParallelCpu { threads });+ }+ use rayon::prelude::*;+ let vals: Vec<f64> = hay.par_chunks(window).map(window_entropy).collect();+ (vals, BulkBackend::ParallelCpu { threads })+}++// ── Experimental GPU path ──────────────────────────────────────────────────++/// Work-item width for the experimental compute schedule (mirrors GPU tile size).+pub const GPU_WORKGROUP_BYTES: usize = 256;++static GPU_INIT_ATTEMPTS: AtomicUsize = AtomicUsize::new(0);++/// Result of experimental GPU bulk path (or fallback).+#[derive(Debug, Clone, Serialize)]+pub struct GpuScanReport {+ pub hits: Vec<BulkHit>,+ pub backend: BulkBackend,+ pub workgroups: usize,+}++/// Experimental GPU analysis mechanism for printable-run bulk scan.+///+/// 1. Feature `gpu`: attempt wgpu compute (WGSL kernel) when an adapter exists.+/// 2. Otherwise / on failure: **CPU work-item stand-in** — same per-byte classification+/// scheduled in `GPU_WORKGROUP_BYTES` tiles on rayon (honest bulk parallel, not SMT).+pub fn scan_printable_runs_gpu_or_fallback(hay: &[u8], min_len: usize) -> GpuScanReport {+ GPU_INIT_ATTEMPTS.fetch_add(1, Ordering::Relaxed);+ let workgroups = if hay.is_empty() {+ 0+ } else {+ (hay.len() + GPU_WORKGROUP_BYTES - 1) / GPU_WORKGROUP_BYTES+ };++ #[cfg(feature = "gpu")]+ {+ match try_gpu_printable_runs(hay, min_len) {+ Ok((hits, device)) => {+ return GpuScanReport {+ hits,+ backend: BulkBackend::Gpu { device },+ workgroups,+ };+ }+ Err(reason) => {+ let (hits, _) = scan_printable_runs_parallel_workitems(hay, min_len);+ return GpuScanReport {+ hits,+ backend: BulkBackend::CpuFallback { reason },+ workgroups,+ };+ }+ }+ }++ #[cfg(not(feature = "gpu"))]+ {+ let (hits, _) = scan_printable_runs_parallel_workitems(hay, min_len);+ GpuScanReport {+ hits,+ backend: BulkBackend::CpuFallback {+ reason: "gpu feature not enabled; CPU work-item stand-in".into(),+ },+ workgroups,+ }+ }+}++/// GPU-shaped schedule on CPU: one workgroup tile → classify bytes → host compact runs.+fn scan_printable_runs_parallel_workitems(hay: &[u8], min_len: usize) -> (Vec<BulkHit>, BulkBackend) {+ // Work-item path builds a printable mask in parallel tiles, then sequential compact.+ // For large inputs this mirrors a GPU mark + host compact pipeline.+ if hay.len() < GPU_WORKGROUP_BYTES * 2 {+ return (+ scan_printable_runs_seq(hay, min_len),+ BulkBackend::ParallelCpu {+ threads: std::thread::available_parallelism()+ .map(|n| n.get())+ .unwrap_or(1),+ },+ );+ }+ use rayon::prelude::*;+ let mut mask = vec![0u8; hay.len()];+ mask.par_chunks_mut(GPU_WORKGROUP_BYTES)+ .zip(hay.par_chunks(GPU_WORKGROUP_BYTES))+ .for_each(|(m, h)| {+ for (i, &b) in h.iter().enumerate() {+ m[i] = u8::from(is_printable_byte(b));+ }+ });+ // Compact runs from mask (single pass — same as sequential oracle on flags).+ let mut hits = Vec::new();+ let mut i = 0;+ while i < mask.len() {+ if mask[i] != 0 {+ let start = i;+ while i < mask.len() && mask[i] != 0 {+ i += 1;+ }+ let len = i - start;+ if len >= min_len {+ hits.push(BulkHit {+ offset: start,+ length: len,+ });+ }+ } else {+ i += 1;+ }+ }+ let threads = std::thread::available_parallelism()+ .map(|n| n.get())+ .unwrap_or(1);+ (hits, BulkBackend::ParallelCpu { threads })+}++#[cfg(feature = "gpu")]+fn try_gpu_printable_runs(hay: &[u8], min_len: usize) -> Result<(Vec<BulkHit>, String), String> {+ // ponytail: real wgpu path when feature on; failures bubble as fallback reason.+ use pollster::block_on;+ use wgpu::util::DeviceExt;++ let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());+ let adapter = block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {+ power_preference: wgpu::PowerPreference::HighPerformance,+ compatible_surface: None,+ force_fallback_adapter: false,+ }))+ .ok_or_else(|| "no wgpu adapter".to_string())?;++ let info = adapter.get_info();+ let device_name = format!("{} ({:?})", info.name, info.backend);++ let (device, queue) = block_on(adapter.request_device(+ &wgpu::DeviceDescriptor {+ label: Some("ghidrust-bulk"),+ required_features: wgpu::Features::empty(),+ required_limits: wgpu::Limits::downlevel_defaults(),+ memory_hints: Default::default(),+ },+ None,+ ))+ .map_err(|e| format!("request_device: {e}"))?;++ // Mark kernel: out[i] = 1 if printable.+ let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {+ label: Some("printable_mark"),+ source: wgpu::ShaderSource::Wgsl(+ r#"+struct Params { n: u32, _pad: u32, _pad2: u32, _pad3: u32, }+@group(0) @binding(0) var<storage, read> input: array<u32>;+@group(0) @binding(1) var<storage, read_write> output: array<u32>;+@group(0) @binding(2) var<uniform> params: Params;++@compute @workgroup_size(256)+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x;+ if (i >= params.n) { return; }+ let word = input[i / 4u];+ let shift = (i % 4u) * 8u;+ let b = (word >> shift) & 0xffu;+ let printable = (b >= 0x20u && b <= 0x7eu) || (b == 0x09u);+ output[i] = select(0u, 1u, printable);+}+"#+ .into(),+ ),+ });++ let n = hay.len() as u32;+ if n == 0 {+ return Ok((Vec::new(), device_name));+ }++ // Pack bytes into u32 words for storage buffer.+ let mut words = vec![0u32; (hay.len() + 3) / 4];+ for (i, &b) in hay.iter().enumerate() {+ words[i / 4] |= (b as u32) << ((i % 4) * 8);+ }+ let out_init = vec![0u32; hay.len()];++ let input_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("input"),+ contents: bytemuck::cast_slice(&words),+ usage: wgpu::BufferUsages::STORAGE,+ });+ let output_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("output"),+ contents: bytemuck::cast_slice(&out_init),+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,+ });+ let params = [n, 0, 0, 0];+ let params_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("params"),+ contents: bytemuck::cast_slice(¶ms),+ usage: wgpu::BufferUsages::UNIFORM,+ });+ let readback = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("readback"),+ size: (hay.len() * 4) as u64,+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });++ let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {+ label: None,+ entries: &[+ wgpu::BindGroupLayoutEntry {+ binding: 0,+ visibility: wgpu::ShaderStages::COMPUTE,+ ty: wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Storage { read_only: true },+ has_dynamic_offset: false,+ min_binding_size: None,+ },+ count: None,+ },+ wgpu::BindGroupLayoutEntry {+ binding: 1,+ visibility: wgpu::ShaderStages::COMPUTE,+ ty: wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Storage { read_only: false },+ has_dynamic_offset: false,+ min_binding_size: None,+ },+ count: None,+ },+ wgpu::BindGroupLayoutEntry {+ binding: 2,+ visibility: wgpu::ShaderStages::COMPUTE,+ ty: wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Uniform,+ has_dynamic_offset: false,+ min_binding_size: None,+ },+ count: None,+ },+ ],+ });+ let bg = device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: None,+ layout: &bgl,+ entries: &[+ wgpu::BindGroupEntry {+ binding: 0,+ resource: input_buf.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 1,+ resource: output_buf.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 2,+ resource: params_buf.as_entire_binding(),+ },+ ],+ });+ let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {+ label: None,+ bind_group_layouts: &[&bgl],+ push_constant_ranges: &[],+ });+ let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {+ label: Some("printable_mark_pipe"),+ layout: Some(&pipeline_layout),+ module: &shader,+ entry_point: Some("main"),+ compilation_options: Default::default(),+ cache: None,+ });++ let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });+ {+ let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {+ label: None,+ timestamp_writes: None,+ });+ pass.set_pipeline(&pipeline);+ pass.set_bind_group(0, &bg, &[]);+ let groups = (n + 255) / 256;+ pass.dispatch_workgroups(groups, 1, 1);+ }+ encoder.copy_buffer_to_buffer(&output_buf, 0, &readback, 0, (hay.len() * 4) as u64);+ queue.submit(Some(encoder.finish()));++ let slice = readback.slice(..);+ let (tx, rx) = std::sync::mpsc::channel();+ slice.map_async(wgpu::MapMode::Read, move |r| {+ let _ = tx.send(r);+ });+ device.poll(wgpu::Maintain::Wait);+ rx.recv()+ .map_err(|e| e.to_string())?+ .map_err(|e| format!("map: {e}"))?;+ let data = slice.get_mapped_range();+ let flags: &[u32] = bytemuck::cast_slice(&data);+ let mut mask = vec![0u8; hay.len()];+ for i in 0..hay.len() {+ mask[i] = u8::from(flags[i] != 0);+ }+ drop(data);+ readback.unmap();++ let mut hits = Vec::new();+ let mut i = 0;+ while i < mask.len() {+ if mask[i] != 0 {+ let start = i;+ while i < mask.len() && mask[i] != 0 {+ i += 1;+ }+ let len = i - start;+ if len >= min_len {+ hits.push(BulkHit {+ offset: start,+ length: len,+ });+ }+ } else {+ i += 1;+ }+ }+ let _ = min_len; // used above+ Ok((hits, device_name))+}++/// Unified entry: pick mode, return hits + backend.+pub fn scan_printable_runs(hay: &[u8], min_len: usize, mode: BulkScanMode) -> (Vec<BulkHit>, BulkBackend) {+ match mode {+ BulkScanMode::Sequential => (scan_printable_runs_seq(hay, min_len), BulkBackend::Sequential),+ BulkScanMode::ParallelCpu => scan_printable_runs_parallel(hay, min_len),+ BulkScanMode::GpuOrFallback => {+ let r = scan_printable_runs_gpu_or_fallback(hay, min_len);+ (r.hits, r.backend)+ }+ }+}++/// Build flat image bytes + per-block VA bases for program-level bulk scan.+pub fn program_image_bytes(prog: &crate::program::Program) -> (Vec<u8>, Vec<(u64, usize, usize)>) {+ // (va, byte_start, len) for each block in the flat buffer+ let mut flat = Vec::new();+ let mut map = Vec::new();+ for block in &prog.blocks {+ let start = flat.len();+ flat.extend_from_slice(&block.bytes);+ map.push((block.va, start, block.bytes.len()));+ }+ (flat, map)+}++/// ASCII string hits via bulk path (same filters as strings analyzer).+pub fn scan_ascii_strings_bulk(+ prog: &crate::program::Program,+ min_len: usize,+ mode: BulkScanMode,+) -> (Vec<crate::analyzers::FoundString>, BulkBackend) {+ use crate::analyzers::FoundString;+ let mut out = Vec::new();+ let mut backend = BulkBackend::Sequential;+ for block in &prog.blocks {+ let (hits, b) = scan_printable_runs(&block.bytes, min_len, mode);+ backend = b;+ for h in hits {+ let end = h.offset + h.length;+ let nul_term = end < block.bytes.len() && block.bytes[end] == 0;+ if h.length >= min_len && (nul_term || h.length >= 6) {+ let value =+ String::from_utf8_lossy(&block.bytes[h.offset..h.offset + h.length]).into_owned();+ if value.chars().any(|c| c.is_ascii_alphabetic()) {+ out.push(FoundString {+ va: block.va + h.offset as u64,+ value,+ length: h.length,+ });+ }+ }+ }+ }+ out.sort_by_key(|s| s.va);+ (out, backend)+}++/// Wall-time timing for sequential vs parallel vs gpu-or-fallback on a haystack.+#[derive(Debug, Clone, Serialize)]+pub struct BulkTimingReport {+ pub bytes: usize,+ pub min_len: usize,+ pub seq_ms: f64,+ pub par_ms: f64,+ pub gpu_ms: f64,+ pub seq_hits: usize,+ pub par_hits: usize,+ pub gpu_hits: usize,+ pub par_backend: BulkBackend,+ pub gpu_backend: BulkBackend,+ pub threads: usize,+}++pub fn time_bulk_printable(hay: &[u8], min_len: usize) -> BulkTimingReport {+ let t0 = std::time::Instant::now();+ let seq = scan_printable_runs_seq(hay, min_len);+ let seq_ms = t0.elapsed().as_secs_f64() * 1000.0;++ let t1 = std::time::Instant::now();+ let (par, par_backend) = scan_printable_runs_parallel(hay, min_len);+ let par_ms = t1.elapsed().as_secs_f64() * 1000.0;++ let t2 = std::time::Instant::now();+ let gpu_rep = scan_printable_runs_gpu_or_fallback(hay, min_len);+ let gpu_ms = t2.elapsed().as_secs_f64() * 1000.0;++ let threads = std::thread::available_parallelism()+ .map(|n| n.get())+ .unwrap_or(1);++ BulkTimingReport {+ bytes: hay.len(),+ min_len,+ seq_ms,+ par_ms,+ gpu_ms,+ seq_hits: seq.len(),+ par_hits: par.len(),+ gpu_hits: gpu_rep.hits.len(),+ par_backend,+ gpu_backend: gpu_rep.backend,+ threads,+ }+}++pub fn gpu_init_attempt_count() -> usize {+ GPU_INIT_ATTEMPTS.load(Ordering::Relaxed)+}++#[cfg(test)]+mod tests {+ use super::*;++ fn fixture_hay() -> Vec<u8> {+ let mut v = vec![0u8; 1024];+ v[100..116].copy_from_slice(b"Hello_Ghidrust!!");+ v[200..220].copy_from_slice(b"ABCDEFGHIJabcdefghij");+ v[500] = 0xff;+ v+ }++ #[test]+ fn seq_finds_known_runs() {+ let hay = fixture_hay();+ let hits = scan_printable_runs_seq(&hay, 4);+ assert!(hits.iter().any(|h| h.offset == 100 && h.length >= 16));+ assert!(hits.iter().any(|h| h.offset == 200));+ }++ #[test]+ fn parallel_matches_sequential() {+ let hay = fixture_hay();+ let seq = scan_printable_runs_seq(&hay, 4);+ let (par, backend) = scan_printable_runs_parallel(&hay, 4);+ assert_eq!(seq, par, "parallel must match sequential oracle");+ match backend {+ BulkBackend::ParallelCpu { threads } => assert!(threads >= 1),+ other => panic!("expected ParallelCpu, got {other:?}"),+ }+ }++ #[test]+ fn gpu_or_fallback_matches_sequential() {+ let hay = fixture_hay();+ let seq = scan_printable_runs_seq(&hay, 4);+ let rep = scan_printable_runs_gpu_or_fallback(&hay, 4);+ assert_eq!(seq, rep.hits, "GPU/fallback must match sequential");+ // Without gpu feature this is CpuFallback; with device may be Gpu.+ match &rep.backend {+ BulkBackend::CpuFallback { reason } => assert!(!reason.is_empty()),+ BulkBackend::Gpu { device } => assert!(!device.is_empty()),+ BulkBackend::ParallelCpu { .. } => {}+ BulkBackend::Sequential => panic!("unexpected Sequential from gpu path"),+ }+ }++ #[test]+ fn large_buffer_parallel_equals_seq() {+ // Large enough to exercise multi-chunk + workgroups.+ let mut hay = vec![0u8; 256 * 1024];+ for i in (0..hay.len()).step_by(777) {+ let msg = b"ParallelBulkScanTokenXYZ";+ let end = (i + msg.len()).min(hay.len());+ hay[i..end].copy_from_slice(&msg[..end - i]);+ }+ let seq = scan_printable_runs_seq(&hay, 8);+ let (par, _) = scan_printable_runs_parallel(&hay, 8);+ let gpu = scan_printable_runs_gpu_or_fallback(&hay, 8);+ assert_eq!(seq, par);+ assert_eq!(seq, gpu.hits);+ assert!(!seq.is_empty());+ }++ #[test]+ fn pattern_parallel_matches_seq() {+ let hay = b"xxxxGHIDRUST_PATTERNyyyyGHIDRUST_PATTERN".to_vec();+ let needle = b"GHIDRUST_PATTERN";+ let seq = scan_pattern_seq(&hay, needle);+ let (par, _) = scan_pattern_parallel(&hay, needle);+ assert_eq!(seq, par);+ assert_eq!(seq.len(), 2);+ }++ #[test]+ fn entropy_parallel_matches_seq() {+ let hay: Vec<u8> = (0..4096).map(|i| (i % 256) as u8).collect();+ let seq = entropy_windows_seq(&hay, 256);+ let (par, _) = entropy_windows_parallel(&hay, 256);+ assert_eq!(seq.len(), par.len());+ for (a, b) in seq.iter().zip(par.iter()) {+ assert!((a - b).abs() < 1e-9);+ }+ }++ #[test]+ fn mode_dispatch_works() {+ let hay = fixture_hay();+ let (a, ba) = scan_printable_runs(&hay, 4, BulkScanMode::Sequential);+ let (b, _) = scan_printable_runs(&hay, 4, BulkScanMode::ParallelCpu);+ let (c, _) = scan_printable_runs(&hay, 4, BulkScanMode::GpuOrFallback);+ assert_eq!(a, b);+ assert_eq!(a, c);+ assert_eq!(ba, BulkBackend::Sequential);+ }++ #[test]+ fn timing_harness_runs() {+ let mut hay = vec![0u8; 512 * 1024];+ for i in (0..hay.len()).step_by(64) {+ hay[i] = b'A' + (i % 26) as u8;+ if i + 8 < hay.len() {+ for j in 0..8 {+ hay[i + j] = b'A' + ((i + j) % 26) as u8;+ }+ }+ }+ let rep = time_bulk_printable(&hay, 4);+ assert_eq!(rep.seq_hits, rep.par_hits);+ assert_eq!(rep.seq_hits, rep.gpu_hits);+ assert!(rep.threads >= 1);+ assert!(rep.bytes == hay.len());+ // timings are non-negative; do not assert speedup (small buffers / CI noise)+ assert!(rep.seq_ms >= 0.0 && rep.par_ms >= 0.0 && rep.gpu_ms >= 0.0);+ }++ #[test]+ fn program_bulk_strings_match_legacy_on_fixture() {+ let path = crate::fixture_path("tiny_x64.pe");+ let prog = crate::load_path(&path).expect("load tiny_x64.pe");+ let legacy = crate::analyzers::scan_ascii_strings(&prog, 4);+ let (bulk_seq, _) = scan_ascii_strings_bulk(&prog, 4, BulkScanMode::Sequential);+ let (bulk_par, _) = scan_ascii_strings_bulk(&prog, 4, BulkScanMode::ParallelCpu);+ let (bulk_gpu, _) = scan_ascii_strings_bulk(&prog, 4, BulkScanMode::GpuOrFallback);+ assert_eq!(legacy, bulk_seq);+ assert_eq!(legacy, bulk_par);+ assert_eq!(legacy, bulk_gpu);+ }+}diff --git a/crates/ghidrust-core/src/disasm.rs b/crates/ghidrust-core/src/disasm.rsnew file mode 100644index 0000000..8edcc4a--- /dev/null+++ b/crates/ghidrust-core/src/disasm.rs@@ -0,0 +1,708 @@+//! Minimal x86-64 decoder slice (hand-rolled). Enough for common prologue / fixture bytes.++use crate::error::{Error, Result};+use crate::program::Program;+use serde::{Deserialize, Serialize};++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct Instruction {+ pub address: u64,+ pub bytes: Vec<u8>,+ pub mnemonic: String,+ pub operands: String,+ pub length: u8,+}++impl Instruction {+ pub fn text(&self) -> String {+ let hex = format!("{:24}", hex_bytes(&self.bytes));+ if self.operands.is_empty() {+ format!("{:016x}: {} {}", self.address, hex, self.mnemonic)+ } else {+ format!(+ "{:016x}: {} {} {}",+ self.address, hex, self.mnemonic, self.operands+ )+ }+ }+}++fn hex_bytes(b: &[u8]) -> String {+ b.iter()+ .map(|x| format!("{x:02x}"))+ .collect::<Vec<_>>()+ .join(" ")+}++const REGS64: [&str; 16] = [+ "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", "r8", "r9", "r10", "r11", "r12", "r13",+ "r14", "r15",+];+const REGS32: [&str; 16] = [+ "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", "r8d", "r9d", "r10d", "r11d", "r12d",+ "r13d", "r14d", "r15d",+];+const REGS16: [&str; 16] = [+ "ax", "cx", "dx", "bx", "sp", "bp", "si", "di", "r8w", "r9w", "r10w", "r11w", "r12w", "r13w",+ "r14w", "r15w",+];+const REGS8: [&str; 16] = [+ "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", "r8b", "r9b", "r10b", "r11b", "r12b",+ "r13b", "r14b", "r15b",+];++#[derive(Clone, Copy, Default)]+struct Prefix {+ rex_w: bool,+ rex_r: bool,+ rex_x: bool,+ rex_b: bool,+ has_rex: bool,+ op_size: bool, // 0x66+ addr_size: bool, // 0x67+ rep: bool,+ repne: bool,+ lock: bool,+ seg: Option<&'static str>,+}++fn reg_name(idx: u8, w: bool, op16: bool, byte_op: bool) -> &'static str {+ let i = (idx & 0xf) as usize;+ if byte_op {+ REGS8[i]+ } else if op16 {+ REGS16[i]+ } else if w {+ REGS64[i]+ } else {+ REGS32[i]+ }+}++struct Cursor<'a> {+ data: &'a [u8],+ pos: usize,+ start: usize,+}++impl<'a> Cursor<'a> {+ fn new(data: &'a [u8]) -> Self {+ Self {+ data,+ pos: 0,+ start: 0,+ }+ }+ fn remaining(&self) -> usize {+ self.data.len().saturating_sub(self.pos)+ }+ fn get(&mut self) -> Result<u8> {+ if self.pos >= self.data.len() {+ return Err(Error::Decode("truncated instruction stream".into()));+ }+ let b = self.data[self.pos];+ self.pos += 1;+ Ok(b)+ }+ fn peek(&self) -> Result<u8> {+ self.data+ .get(self.pos)+ .copied()+ .ok_or_else(|| Error::Decode("truncated".into()))+ }+ fn take_imm(&mut self, n: usize) -> Result<u64> {+ if self.remaining() < n {+ return Err(Error::Decode("imm truncated".into()));+ }+ let mut v = 0u64;+ for i in 0..n {+ v |= (self.data[self.pos + i] as u64) << (8 * i);+ }+ self.pos += n;+ Ok(v)+ }+ fn bytes_taken(&self) -> &[u8] {+ &self.data[self.start..self.pos]+ }+}++fn sign_hex(v: i64) -> String {+ if v < 0 {+ format!("-{:#x}", -v)+ } else {+ format!("{v:#x}")+ }+}++fn decode_modrm_mem(+ cur: &mut Cursor<'_>,+ modrm: u8,+ pfx: Prefix,+ byte_op: bool,+) -> Result<(u8, String)> {+ let mod_ = modrm >> 6;+ let reg = ((modrm >> 3) & 7) | if pfx.rex_r { 8 } else { 0 };+ let rm = (modrm & 7) | if pfx.rex_b { 8 } else { 0 };+ let op16 = pfx.op_size && !pfx.rex_w;++ if mod_ == 3 {+ let name = if byte_op {+ reg_name(rm, false, false, true)+ } else if pfx.rex_w {+ reg_name(rm, true, false, false)+ } else if op16 {+ reg_name(rm, false, true, false)+ } else {+ reg_name(rm, false, false, false)+ };+ return Ok((reg, name.to_string()));+ }++ // SIB if rm low 3 bits == 4 (without rex_b folded for encoding check)+ let rm_enc = modrm & 7;+ let mut parts = String::new();+ if rm_enc == 4 {+ let sib = cur.get()?;+ let scale = 1u32 << (sib >> 6);+ let index = ((sib >> 3) & 7) | if pfx.rex_x { 8 } else { 0 };+ let base = (sib & 7) | if pfx.rex_b { 8 } else { 0 };+ let mut terms = Vec::new();+ if !(mod_ == 0 && (sib & 7) == 5) {+ terms.push(REGS64[base as usize].to_string());+ }+ if index != 4 {+ if scale == 1 {+ terms.push(REGS64[index as usize].to_string());+ } else {+ terms.push(format!("{}*{}", REGS64[index as usize], scale));+ }+ }+ let disp = match mod_ {+ 0 if (sib & 7) == 5 => Some(cur.take_imm(4)? as i32 as i64),+ 1 => Some(cur.take_imm(1)? as i8 as i64),+ 2 => Some(cur.take_imm(4)? as i32 as i64),+ _ => None,+ };+ if let Some(d) = disp {+ if d != 0 || terms.is_empty() {+ parts = if terms.is_empty() {+ format!("[{}]", sign_hex(d))+ } else {+ format!(+ "[{}{}{}]",+ terms.join("+"),+ if d < 0 { "" } else { "+" },+ sign_hex(d)+ )+ };+ } else {+ parts = format!("[{}]", terms.join("+"));+ }+ } else {+ parts = format!("[{}]", terms.join("+"));+ }+ } else if mod_ == 0 && rm_enc == 5 {+ // RIP-relative+ let disp = cur.take_imm(4)? as i32 as i64;+ parts = format!("[rip+{}]", sign_hex(disp));+ } else {+ let base = REGS64[rm as usize];+ match mod_ {+ 0 => parts = format!("[{base}]"),+ 1 => {+ let d = cur.take_imm(1)? as i8 as i64;+ parts = format!(+ "[{base}{}{}]",+ if d < 0 { "" } else { "+" },+ sign_hex(d)+ );+ }+ 2 => {+ let d = cur.take_imm(4)? as i32 as i64;+ parts = format!(+ "[{base}{}{}]",+ if d < 0 { "" } else { "+" },+ sign_hex(d)+ );+ }+ _ => {}+ }+ }+ if let Some(seg) = pfx.seg {+ parts = format!("{seg}:{parts}");+ }+ Ok((reg, parts))+}++/// Decode one instruction from raw bytes at `address` (VA for display only).+pub fn decode_one(bytes: &[u8], address: u64) -> Result<Instruction> {+ if bytes.is_empty() {+ return Err(Error::Decode("empty".into()));+ }+ let mut cur = Cursor::new(bytes);+ let mut pfx = Prefix::default();++ // prefixes+ loop {+ let b = cur.peek()?;+ match b {+ 0xF0 => {+ cur.get()?;+ pfx.lock = true;+ }+ 0xF2 => {+ cur.get()?;+ pfx.repne = true;+ }+ 0xF3 => {+ cur.get()?;+ pfx.rep = true;+ }+ 0x2E => {+ cur.get()?;+ pfx.seg = Some("cs");+ }+ 0x36 => {+ cur.get()?;+ pfx.seg = Some("ss");+ }+ 0x3E => {+ cur.get()?;+ pfx.seg = Some("ds");+ }+ 0x26 => {+ cur.get()?;+ pfx.seg = Some("es");+ }+ 0x64 => {+ cur.get()?;+ pfx.seg = Some("fs");+ }+ 0x65 => {+ cur.get()?;+ pfx.seg = Some("gs");+ }+ 0x66 => {+ cur.get()?;+ pfx.op_size = true;+ }+ 0x67 => {+ cur.get()?;+ pfx.addr_size = true;+ }+ x if x & 0xf0 == 0x40 => {+ let rex = cur.get()?;+ pfx.has_rex = true;+ pfx.rex_w = rex & 0x8 != 0;+ pfx.rex_r = rex & 0x4 != 0;+ pfx.rex_x = rex & 0x2 != 0;+ pfx.rex_b = rex & 0x1 != 0;+ }+ _ => break,+ }+ if cur.pos > 15 {+ return Err(Error::Decode("too many prefixes".into()));+ }+ }++ let op = cur.get()?;+ let w64 = pfx.rex_w;+ let op16 = pfx.op_size && !pfx.rex_w;++ let (mnemonic, operands) = match op {+ // PUSH r64: 50+rd+ 0x50..=0x57 => {+ let r = (op - 0x50) | if pfx.rex_b { 8 } else { 0 };+ ("push".into(), REGS64[r as usize].to_string())+ }+ // POP r64+ 0x58..=0x5F => {+ let r = (op - 0x58) | if pfx.rex_b { 8 } else { 0 };+ ("pop".into(), REGS64[r as usize].to_string())+ }+ // MOV r/m, r+ 0x89 => {+ let modrm = cur.get()?;+ let (reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ let reg_s = if w64 {+ reg_name(reg, true, false, false)+ } else if op16 {+ reg_name(reg, false, true, false)+ } else {+ reg_name(reg, false, false, false)+ };+ ("mov".into(), format!("{rm}, {reg_s}"))+ }+ // MOV r, r/m+ 0x8B => {+ let modrm = cur.get()?;+ let (reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ let reg_s = if w64 {+ reg_name(reg, true, false, false)+ } else if op16 {+ reg_name(reg, false, true, false)+ } else {+ reg_name(reg, false, false, false)+ };+ ("mov".into(), format!("{reg_s}, {rm}"))+ }+ // MOV r/m8, r8+ 0x88 => {+ let modrm = cur.get()?;+ let (reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, true)?;+ ("mov".into(), format!("{rm}, {}", reg_name(reg, false, false, true)))+ }+ // MOV r8, r/m8+ 0x8A => {+ let modrm = cur.get()?;+ let (reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, true)?;+ ("mov".into(), format!("{}, {rm}", reg_name(reg, false, false, true)))+ }+ // MOV r/m, imm32 (C7 /0)+ 0xC7 => {+ let modrm = cur.get()?;+ let reg_field = (modrm >> 3) & 7;+ if reg_field != 0 {+ return Err(Error::Decode(format!("unhandled C7 /{reg_field}")));+ }+ let (_reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ let imm = if w64 {+ // C7 still uses 32-bit imm sign-extended+ cur.take_imm(4)? as i32 as i64+ } else if op16 {+ cur.take_imm(2)? as i16 as i64+ } else {+ cur.take_imm(4)? as i32 as i64+ };+ ("mov".into(), format!("{rm}, {imm:#x}"))+ }+ // MOV r64/r32, imm+ 0xB8..=0xBF => {+ let r = (op - 0xB8) | if pfx.rex_b { 8 } else { 0 };+ if w64 {+ let imm = cur.take_imm(8)?;+ (+ "mov".into(),+ format!("{}, {imm:#x}", reg_name(r, true, false, false)),+ )+ } else if op16 {+ let imm = cur.take_imm(2)?;+ (+ "mov".into(),+ format!("{}, {imm:#x}", reg_name(r, false, true, false)),+ )+ } else {+ let imm = cur.take_imm(4)?;+ (+ "mov".into(),+ format!("{}, {imm:#x}", reg_name(r, false, false, false)),+ )+ }+ }+ // MOV r8, imm8+ 0xB0..=0xB7 => {+ let r = (op - 0xB0) | if pfx.rex_b { 8 } else { 0 };+ let imm = cur.take_imm(1)?;+ (+ "mov".into(),+ format!("{}, {imm:#x}", reg_name(r, false, false, true)),+ )+ }+ // LEA r, m+ 0x8D => {+ let modrm = cur.get()?;+ let (reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ let reg_s = if w64 {+ reg_name(reg, true, false, false)+ } else if op16 {+ reg_name(reg, false, true, false)+ } else {+ reg_name(reg, false, false, false)+ };+ ("lea".into(), format!("{reg_s}, {rm}"))+ }+ // ADD/OR/ADC/SBB/AND/SUB/XOR/CMP r/m, r (01 family)+ 0x01 | 0x09 | 0x11 | 0x19 | 0x21 | 0x29 | 0x31 | 0x39 => {+ let mnem = match op {+ 0x01 => "add",+ 0x09 => "or",+ 0x11 => "adc",+ 0x19 => "sbb",+ 0x21 => "and",+ 0x29 => "sub",+ 0x31 => "xor",+ 0x39 => "cmp",+ _ => unreachable!(),+ };+ let modrm = cur.get()?;+ let (reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ let reg_s = if w64 {+ reg_name(reg, true, false, false)+ } else if op16 {+ reg_name(reg, false, true, false)+ } else {+ reg_name(reg, false, false, false)+ };+ (mnem.into(), format!("{rm}, {reg_s}"))+ }+ // same r, r/m+ 0x03 | 0x0B | 0x13 | 0x1B | 0x23 | 0x2B | 0x33 | 0x3B => {+ let mnem = match op {+ 0x03 => "add",+ 0x0B => "or",+ 0x13 => "adc",+ 0x1B => "sbb",+ 0x23 => "and",+ 0x2B => "sub",+ 0x33 => "xor",+ 0x3B => "cmp",+ _ => unreachable!(),+ };+ let modrm = cur.get()?;+ let (reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ let reg_s = if w64 {+ reg_name(reg, true, false, false)+ } else if op16 {+ reg_name(reg, false, true, false)+ } else {+ reg_name(reg, false, false, false)+ };+ (mnem.into(), format!("{reg_s}, {rm}"))+ }+ // XOR r/m8,r8 etc skip; XOR r32,r/m already covered+ // TEST+ 0x85 => {+ let modrm = cur.get()?;+ let (reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ let reg_s = if w64 {+ reg_name(reg, true, false, false)+ } else {+ reg_name(reg, false, op16, false)+ };+ ("test".into(), format!("{rm}, {reg_s}"))+ }+ // NOP+ 0x90 => ("nop".into(), String::new()),+ // RET+ 0xC3 => ("ret".into(), String::new()),+ 0xC2 => {+ let imm = cur.take_imm(2)?;+ ("ret".into(), format!("{imm:#x}"))+ }+ // CALL rel32+ 0xE8 => {+ let rel = cur.take_imm(4)? as i32 as i64;+ let target = address+ .wrapping_add(cur.pos as u64)+ .wrapping_add(rel as u64);+ ("call".into(), format!("{target:#x}"))+ }+ // JMP rel32+ 0xE9 => {+ let rel = cur.take_imm(4)? as i32 as i64;+ let target = address+ .wrapping_add(cur.pos as u64)+ .wrapping_add(rel as u64);+ ("jmp".into(), format!("{target:#x}"))+ }+ // JMP rel8+ 0xEB => {+ let rel = cur.take_imm(1)? as i8 as i64;+ let target = address+ .wrapping_add(cur.pos as u64)+ .wrapping_add(rel as u64);+ ("jmp".into(), format!("{target:#x}"))+ }+ // Jcc rel8+ 0x70..=0x7F => {+ let names = [+ "jo", "jno", "jb", "jae", "je", "jne", "jbe", "ja", "js", "jns", "jp", "jnp",+ "jl", "jge", "jle", "jg",+ ];+ let rel = cur.take_imm(1)? as i8 as i64;+ let target = address+ .wrapping_add(cur.pos as u64)+ .wrapping_add(rel as u64);+ (names[(op - 0x70) as usize].into(), format!("{target:#x}"))+ }+ // INT3+ 0xCC => ("int3".into(), String::new()),+ // CDQ / CQO+ 0x99 => {+ if w64 {+ ("cqo".into(), String::new())+ } else {+ ("cdq".into(), String::new())+ }+ }+ // LEAVE+ 0xC9 => ("leave".into(), String::new()),+ // SUB/ADD r/m, imm8 (83 /x)+ 0x83 => {+ let modrm = cur.get()?;+ let reg_field = (modrm >> 3) & 7;+ let mnem = match reg_field {+ 0 => "add",+ 1 => "or",+ 2 => "adc",+ 3 => "sbb",+ 4 => "and",+ 5 => "sub",+ 6 => "xor",+ 7 => "cmp",+ _ => "grp",+ };+ let (_reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ let imm = cur.take_imm(1)? as i8 as i64;+ (mnem.into(), format!("{rm}, {imm:#x}"))+ }+ // group 81 r/m, imm32+ 0x81 => {+ let modrm = cur.get()?;+ let reg_field = (modrm >> 3) & 7;+ let mnem = match reg_field {+ 0 => "add",+ 1 => "or",+ 2 => "adc",+ 3 => "sbb",+ 4 => "and",+ 5 => "sub",+ 6 => "xor",+ 7 => "cmp",+ _ => "grp",+ };+ let (_reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ let imm = if op16 {+ cur.take_imm(2)? as i16 as i64+ } else {+ cur.take_imm(4)? as i32 as i64+ };+ (mnem.into(), format!("{rm}, {imm:#x}"))+ }+ // two-byte 0F+ 0x0F => {+ let op2 = cur.get()?;+ match op2 {+ // Jcc rel32+ 0x80..=0x8F => {+ let names = [+ "jo", "jno", "jb", "jae", "je", "jne", "jbe", "ja", "js", "jns", "jp",+ "jnp", "jl", "jge", "jle", "jg",+ ];+ let rel = cur.take_imm(4)? as i32 as i64;+ let target = address+ .wrapping_add(cur.pos as u64)+ .wrapping_add(rel as u64);+ (names[(op2 - 0x80) as usize].into(), format!("{target:#x}"))+ }+ 0x1F => {+ // NOP r/m+ let modrm = cur.get()?;+ let (_r, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ ("nop".into(), rm)+ }+ 0x05 => ("syscall".into(), String::new()),+ 0xA2 => ("cpuid".into(), String::new()),+ _ => {+ return Err(Error::Decode(format!("unhandled 0F {op2:02x}")));+ }+ }+ }+ // FF /2 CALL, /4 JMP+ 0xFF => {+ let modrm = cur.get()?;+ let reg_field = (modrm >> 3) & 7;+ let (_r, rm) = decode_modrm_mem(&mut cur, modrm, pfx, false)?;+ match reg_field {+ 2 => ("call".into(), rm),+ 4 => ("jmp".into(), rm),+ 6 => ("push".into(), rm),+ _ => {+ return Err(Error::Decode(format!("unhandled FF /{reg_field}")));+ }+ }+ }+ // XOR r8,r8 style short: 31 already; also 30+ 0x30 | 0x32 => {+ let modrm = cur.get()?;+ let (reg, rm) = decode_modrm_mem(&mut cur, modrm, pfx, true)?;+ let mnem = if op == 0x30 { "xor" } else { "xor" };+ if op == 0x30 {+ (mnem.into(), format!("{rm}, {}", reg_name(reg, false, false, true)))+ } else {+ (mnem.into(), format!("{}, {rm}", reg_name(reg, false, false, true)))+ }+ }+ other => {+ return Err(Error::Decode(format!(+ "unhandled opcode {other:02x} at {address:#x}"+ )));+ }+ };++ let taken = cur.bytes_taken().to_vec();+ Ok(Instruction {+ address,+ length: taken.len() as u8,+ bytes: taken,+ mnemonic,+ operands,+ })+}++pub fn disassemble_at(prog: &Program, va: u64) -> Result<Instruction> {+ let bytes = prog+ .read_va(va, 15)+ .ok_or_else(|| Error::OutOfBounds(format!("no bytes at {va:#x}")))?;+ decode_one(&bytes, va)+}++pub fn disassemble_range(prog: &Program, start: u64, max_insns: usize) -> Result<Vec<Instruction>> {+ let mut out = Vec::new();+ let mut va = start;+ for _ in 0..max_insns {+ match disassemble_at(prog, va) {+ Ok(insn) => {+ let len = insn.length as u64;+ out.push(insn);+ va = va.wrapping_add(len);+ }+ Err(_) => break,+ }+ }+ if out.is_empty() {+ return Err(Error::Decode(format!("no instructions at {start:#x}")));+ }+ Ok(out)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn decode_push_rbp_mov_rbp_rsp() {+ // 55 push rbp+ // 48 89 e5 mov rbp, rsp+ let b = [0x55, 0x48, 0x89, 0xe5];+ let i0 = decode_one(&b, 0x1000).unwrap();+ assert_eq!(i0.mnemonic, "push");+ assert_eq!(i0.operands, "rbp");+ assert_eq!(i0.length, 1);+ let i1 = decode_one(&b[1..], 0x1001).unwrap();+ assert_eq!(i1.mnemonic, "mov");+ assert_eq!(i1.operands, "rbp, rsp");+ }++ #[test]+ fn decode_xor_eax_eax_ret() {+ // 31 c0 xor eax, eax+ // c3 ret+ let b = [0x31, 0xc0, 0xc3];+ let i0 = decode_one(&b, 0).unwrap();+ assert_eq!(i0.mnemonic, "xor");+ assert_eq!(i0.operands, "eax, eax");+ let i1 = decode_one(&b[2..], 2).unwrap();+ assert_eq!(i1.mnemonic, "ret");+ }+}diff --git a/crates/ghidrust-core/src/elf.rs b/crates/ghidrust-core/src/elf.rsnew file mode 100644index 0000000..3a653a4--- /dev/null+++ b/crates/ghidrust-core/src/elf.rs@@ -0,0 +1,185 @@+//! Minimal ELF64 little-endian loader (hand-rolled).++use crate::error::{Error, Result};+use crate::program::{MemoryBlock, Program, SectionInfo};++pub fn is_elf(data: &[u8]) -> bool {+ data.len() >= 16 && data[0..4] == [0x7f, b'E', b'L', b'F']+}++fn rdu16(data: &[u8], off: usize) -> Result<u16> {+ if off + 2 > data.len() {+ return Err(Error::Parse("elf trunc u16".into()));+ }+ Ok(u16::from_le_bytes(data[off..off + 2].try_into().unwrap()))+}++fn rdu32(data: &[u8], off: usize) -> Result<u32> {+ if off + 4 > data.len() {+ return Err(Error::Parse("elf trunc u32".into()));+ }+ Ok(u32::from_le_bytes(data[off..off + 4].try_into().unwrap()))+}++fn rdu64(data: &[u8], off: usize) -> Result<u64> {+ if off + 8 > data.len() {+ return Err(Error::Parse("elf trunc u64".into()));+ }+ Ok(u64::from_le_bytes(data[off..off + 8].try_into().unwrap()))+}++pub fn load_elf(data: &[u8], name: impl Into<String>) -> Result<Program> {+ if !is_elf(data) {+ return Err(Error::UnsupportedFormat("not ELF".into()));+ }+ let class = data[4];+ let data_enc = data[5];+ if class != 2 {+ return Err(Error::Parse("only ELF64 supported in MVP".into()));+ }+ if data_enc != 1 {+ return Err(Error::Parse("only little-endian ELF supported".into()));+ }++ let e_entry = rdu64(data, 24)?;+ let e_phoff = rdu64(data, 32)? as usize;+ let e_shoff = rdu64(data, 40)? as usize;+ let e_phentsize = rdu16(data, 54)? as usize;+ let e_phnum = rdu16(data, 56)? as usize;+ let e_shentsize = rdu16(data, 58)? as usize;+ let e_shnum = rdu16(data, 60)? as usize;+ let e_shstrndx = rdu16(data, 62)? as usize;++ let mut prog = Program::new(name.into(), "ELF64");+ prog.entry = if e_entry != 0 { Some(e_entry) } else { None };+ prog.file_bytes = data.to_vec();++ // Prefer section headers when present for named sections.+ if e_shoff != 0 && e_shnum > 0 && e_shentsize >= 64 {+ let shstr_off = e_shoff + e_shstrndx * e_shentsize;+ let shstr_offset = rdu64(data, shstr_off + 24)? as usize;+ let shstr_size = rdu64(data, shstr_off + 32)? as usize;+ let shstr = if shstr_offset + shstr_size <= data.len() {+ &data[shstr_offset..shstr_offset + shstr_size]+ } else {+ &[][..]+ };++ for i in 0..e_shnum {+ let off = e_shoff + i * e_shentsize;+ if off + 64 > data.len() {+ break;+ }+ let name_off = rdu32(data, off)? as usize;+ let sh_type = rdu32(data, off + 4)?;+ let sh_flags = rdu64(data, off + 8)?;+ let sh_addr = rdu64(data, off + 16)?;+ let sh_offset = rdu64(data, off + 24)? as usize;+ let sh_size = rdu64(data, off + 32)?;+ if sh_type == 0 || sh_size == 0 {+ continue; // SHT_NULL+ }+ let sec_name = cstr_from(shstr, name_off);+ let mut bytes = vec![0u8; sh_size as usize];+ if sh_type != 8 {+ // not NOBITS+ let n = (sh_size as usize).min(data.len().saturating_sub(sh_offset));+ if n > 0 {+ bytes[..n].copy_from_slice(&data[sh_offset..sh_offset + n]);+ }+ }+ if prog.image_base == 0 && sh_addr != 0 {+ // rough image base from first allocated section+ prog.image_base = sh_addr & !0xfff;+ }+ let executable = sh_flags & 4 != 0;+ let writable = sh_flags & 1 != 0;+ let alloc = sh_flags & 2 != 0;+ if !alloc && sh_addr == 0 {+ continue;+ }+ prog.sections.push(SectionInfo {+ name: sec_name.clone(),+ va: sh_addr,+ virtual_size: sh_size,+ raw_size: sh_size,+ file_offset: sh_offset as u64,+ characteristics: sh_flags as u32,+ });+ prog.blocks.push(MemoryBlock {+ name: sec_name,+ va: sh_addr,+ size: sh_size,+ bytes,+ readable: true,+ writable,+ executable,+ });+ }+ }++ // Fallback / augment from program headers if no sections.+ if prog.blocks.is_empty() && e_phoff != 0 {+ for i in 0..e_phnum {+ let off = e_phoff + i * e_phentsize;+ if off + 56 > data.len() {+ break;+ }+ let p_type = rdu32(data, off)?;+ if p_type != 1 {+ continue; // PT_LOAD+ }+ let p_flags = rdu32(data, off + 4)?;+ let p_offset = rdu64(data, off + 8)? as usize;+ let p_vaddr = rdu64(data, off + 16)?;+ let p_filesz = rdu64(data, off + 32)? as usize;+ let p_memsz = rdu64(data, off + 40)? as usize;+ let mut bytes = vec![0u8; p_memsz];+ let n = p_filesz.min(data.len().saturating_sub(p_offset)).min(p_memsz);+ if n > 0 {+ bytes[..n].copy_from_slice(&data[p_offset..p_offset + n]);+ }+ if prog.image_base == 0 {+ prog.image_base = p_vaddr & !0xfff;+ }+ let name = format!("LOAD_{i}");+ prog.sections.push(SectionInfo {+ name: name.clone(),+ va: p_vaddr,+ virtual_size: p_memsz as u64,+ raw_size: p_filesz as u64,+ file_offset: p_offset as u64,+ characteristics: p_flags,+ });+ prog.blocks.push(MemoryBlock {+ name,+ va: p_vaddr,+ size: p_memsz as u64,+ bytes,+ readable: p_flags & 4 != 0,+ writable: p_flags & 2 != 0,+ executable: p_flags & 1 != 0,+ });+ }+ }++ if prog.image_base == 0 {+ if let Some(b) = prog.blocks.first() {+ prog.image_base = b.va & !0xfff;+ }+ }++ Ok(prog)+}++fn cstr_from(table: &[u8], off: usize) -> String {+ if off >= table.len() {+ return String::new();+ }+ let end = table[off..]+ .iter()+ .position(|&b| b == 0)+ .map(|p| off + p)+ .unwrap_or(table.len());+ String::from_utf8_lossy(&table[off..end]).into_owned()+}diff --git a/crates/ghidrust-core/src/error.rs b/crates/ghidrust-core/src/error.rsnew file mode 100644index 0000000..3ee5f48--- /dev/null+++ b/crates/ghidrust-core/src/error.rs@@ -0,0 +1,26 @@+use std::fmt;++#[derive(Debug, Clone)]+pub enum Error {+ Io(String),+ UnsupportedFormat(String),+ Parse(String),+ OutOfBounds(String),+ Decode(String),+}++impl fmt::Display for Error {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ match self {+ Error::Io(m) => write!(f, "io: {m}"),+ Error::UnsupportedFormat(m) => write!(f, "format: {m}"),+ Error::Parse(m) => write!(f, "parse: {m}"),+ Error::OutOfBounds(m) => write!(f, "oob: {m}"),+ Error::Decode(m) => write!(f, "decode: {m}"),+ }+ }+}++impl std::error::Error for Error {}++pub type Result<T> = std::result::Result<T, Error>;diff --git a/crates/ghidrust-core/src/gpu_analyzers/engine.rs b/crates/ghidrust-core/src/gpu_analyzers/engine.rsnew file mode 100644index 0000000..f0fbacc--- /dev/null+++ b/crates/ghidrust-core/src/gpu_analyzers/engine.rs@@ -0,0 +1,657 @@+//! wgpu engine: upload → SIMT kernel → download with explicit PCIe vs device timing.++use serde::Serialize;+use std::time::Instant;++#[derive(Debug, Clone, Serialize, Default)]+pub struct GpuPhaseTiming {+ pub pcie_upload_ms: f64,+ pub device_ms: f64,+ pub pcie_download_ms: f64,+ pub wall_ms: f64,+ /// Cold adapter/pipeline setup (not counted as device compute).+ pub setup_ms: f64,+}++#[derive(Debug, Clone)]+pub struct GpuRunBackend {+ pub backend: String,+ pub device: String,+ pub timing: GpuPhaseTiming,+ /// Sample of hit offsets (capped at max_hits; order non-deterministic on GPU).+ pub hits: Vec<u32>,+ /// Full hit count from device atomic (may exceed hits.len()).+ pub total_hits: usize,+ /// Parallel aux values (e.g. FNV hashes for HashWin), same length as hits.+ pub hit_aux: Vec<u32>,+ pub note: String,+}++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum KernelKind {+ Printable,+ MagicMedia,+ MagicRes,+ Prologue,+ PtrU64,+ Rtti,+ CodeDensity,+ HashWin,+ Ret,+ Spill,+ Stack,+ Cstr,+ SubRsp,+}++impl KernelKind {+ #[cfg_attr(not(feature = "gpu"), allow(dead_code))]+ fn entry_point(&self) -> &'static str {+ match self {+ KernelKind::Printable => "k_printable",+ KernelKind::MagicMedia => "k_magic_media",+ KernelKind::MagicRes => "k_magic_res",+ KernelKind::Prologue => "k_prologue",+ KernelKind::PtrU64 => "k_ptr_u64",+ KernelKind::Rtti => "k_rtti",+ KernelKind::CodeDensity => "k_code_density",+ KernelKind::HashWin => "k_hash_win",+ KernelKind::Ret => "k_ret",+ KernelKind::Spill => "k_spill",+ KernelKind::Stack => "k_stack",+ KernelKind::Cstr => "k_cstr",+ KernelKind::SubRsp => "k_sub_rsp",+ }+ }++ /// Global invocations needed (one per candidate).+ #[cfg(feature = "gpu")]+ fn invocation_count(self, n: u32) -> u32 {+ match self {+ KernelKind::PtrU64 => n.div_ceil(8),+ KernelKind::CodeDensity => n.div_ceil(16),+ _ => n,+ }+ }+}++/// Pack needle bytes into 4×u32 LE words.+#[cfg_attr(not(feature = "gpu"), allow(dead_code))]+pub fn pack_needle(n: &[u8]) -> ([u32; 4], u32) {+ let mut words = [0u32; 4];+ let len = n.len().min(16) as u32;+ for (i, &b) in n.iter().take(16).enumerate() {+ words[i / 4] |= (b as u32) << ((i % 4) * 8);+ }+ (words, len)+}++pub const MAX_HITS: u32 = 256_000;++/// Run a strategy kernel on haystack; returns hits + PCIe/device timings.+pub fn run_kernel(+ hay: &[u8],+ kind: KernelKind,+ needle: Option<&[u8]>,+ image_base: u64,+ image_end: u64,+) -> GpuRunBackend {+ let wall0 = Instant::now();++ #[cfg(feature = "gpu")]+ {+ match run_kernel_gpu(hay, kind, needle, image_base, image_end, wall0) {+ Ok(r) => return r,+ Err(reason) => {+ let mut r = run_kernel_cpu_fallback(hay, kind, needle, image_base, image_end, wall0);+ r.backend = "cpu_kernel_fallback".into();+ r.device = reason;+ r.note = "GPU init/kernel failed; same algorithm on CPU".into();+ return r;+ }+ }+ }++ #[cfg(not(feature = "gpu"))]+ {+ let mut r = run_kernel_cpu_fallback(hay, kind, needle, image_base, image_end, wall0);+ r.backend = "cpu_kernel_fallback".into();+ r.device = "gpu feature not enabled".into();+ r+ }+}++fn run_kernel_cpu_fallback(+ hay: &[u8],+ kind: KernelKind,+ needle: Option<&[u8]>,+ image_base: u64,+ image_end: u64,+ wall0: Instant,+) -> GpuRunBackend {+ let t0 = Instant::now();+ let (hits, aux) = cpu_emulate_kernel(hay, kind, needle, image_base, image_end);+ let total_hits = hits.len();+ let device_ms = t0.elapsed().as_secs_f64() * 1000.0;+ let cap = MAX_HITS as usize;+ GpuRunBackend {+ backend: "cpu_kernel_fallback".into(),+ device: "host".into(),+ timing: GpuPhaseTiming {+ pcie_upload_ms: 0.0,+ device_ms,+ pcie_download_ms: 0.0,+ wall_ms: wall0.elapsed().as_secs_f64() * 1000.0,+ setup_ms: 0.0,+ },+ hits: hits.into_iter().take(cap).collect(),+ total_hits,+ hit_aux: aux.into_iter().take(cap).collect(),+ note: "CPU multipass of analyzer kernel".into(),+ }+}++/// CPU oracle matching WGSL SIMT semantics (same hay → same hit set).+pub fn cpu_emulate_kernel(+ hay: &[u8],+ kind: KernelKind,+ needle: Option<&[u8]>,+ image_base: u64,+ image_end: u64,+) -> (Vec<u32>, Vec<u32>) {+ let mut hits = Vec::new();+ let mut aux = Vec::new();+ match kind {+ KernelKind::Printable => {+ let mut i = 0;+ while i < hay.len() {+ if is_print(hay[i]) {+ let s = i;+ while i < hay.len() && is_print(hay[i]) {+ i += 1;+ }+ if i - s >= 4 {+ hits.push(s as u32);+ }+ } else {+ i += 1;+ }+ }+ }+ KernelKind::MagicMedia => {+ for i in 0..hay.len() {+ if i + 4 <= hay.len() && &hay[i..i + 4] == b"\x89PNG" {+ hits.push(i as u32);+ } else if i + 3 <= hay.len()+ && hay[i] == 0xff+ && hay[i + 1] == 0xd8+ && hay[i + 2] == 0xff+ {+ hits.push(i as u32);+ } else if i + 3 <= hay.len() && &hay[i..i + 3] == b"GIF" {+ hits.push(i as u32);+ } else if i + 4 <= hay.len() && &hay[i..i + 4] == b"RIFF" {+ hits.push(i as u32);+ }+ }+ }+ KernelKind::MagicRes => {+ for i in 0..hay.len().saturating_sub(2) {+ if hay[i] == b'V' && hay.get(i + 1) == Some(&0) && hay.get(i + 2) == Some(&b'S') {+ hits.push(i as u32);+ } else if hay[i] == b'R' && hay.get(i + 1) == Some(&b'S') {+ hits.push(i as u32);+ }+ }+ }+ KernelKind::Prologue => {+ for i in 0..hay.len() {+ if i + 3 < hay.len()+ && hay[i] == 0x55+ && hay[i + 1] == 0x48+ && hay[i + 2] == 0x89+ && hay[i + 3] == 0xe5+ {+ hits.push(i as u32);+ } else if i + 2 < hay.len()+ && hay[i] == 0x48+ && hay[i + 1] == 0x83+ && hay[i + 2] == 0xec+ {+ if i >= 4+ && hay[i - 4] == 0x55+ && hay[i - 3] == 0x48+ && hay[i - 2] == 0x89+ && hay[i - 1] == 0xe5+ {+ continue;+ }+ hits.push(i as u32);+ }+ }+ }+ KernelKind::PtrU64 => {+ // Match GPU: every 8-byte-aligned candidate with run >= 3+ let mut i = 0usize;+ while i + 24 <= hay.len() {+ let mut run = 0u32;+ let mut j = i;+ while j + 8 <= hay.len() && run < 64 {+ let v = u64::from_le_bytes(hay[j..j + 8].try_into().unwrap());+ if v >= image_base && v < image_end {+ run += 1;+ j += 8;+ } else {+ break;+ }+ }+ if run >= 3 {+ hits.push(i as u32);+ }+ i += 8;+ }+ }+ KernelKind::Rtti => {+ for i in 0..hay.len().saturating_sub(4) {+ if &hay[i..i + 3] == b".?A" && (hay[i + 3] == b'V' || hay[i + 3] == b'U') {+ hits.push(i as u32);+ } else if i + 4 <= hay.len() && &hay[i..i + 4] == b"_ZTS" {+ hits.push(i as u32);+ }+ }+ }+ KernelKind::CodeDensity => {+ let win = 16;+ let mut i = 0;+ while i + win <= hay.len() {+ let non = hay[i..i + win]+ .iter()+ .filter(|&&b| b != 0xcc && b != 0)+ .count();+ if non >= 12 {+ hits.push(i as u32);+ }+ i += win;+ }+ }+ KernelKind::HashWin => {+ for i in 0..hay.len().saturating_sub(8) {+ if hay[i] == 0x55 || (hay[i] == 0x48 && hay.get(i + 1) == Some(&0x83)) {+ let mut h: u32 = 2166136261;+ for k in 0..8 {+ h = (h ^ hay[i + k] as u32).wrapping_mul(16777619);+ }+ hits.push(i as u32);+ aux.push(h);+ }+ }+ }+ KernelKind::Ret => {+ for (i, &b) in hay.iter().enumerate() {+ if b == 0xc3 || b == 0xc2 {+ hits.push(i as u32);+ }+ }+ }+ KernelKind::Spill => {+ for i in 0..hay.len() {+ if i + 2 < hay.len() && hay[i] == 0x48 && hay[i + 1] == 0x89 {+ let m = hay[i + 2];+ if matches!(m, 0x4c | 0x54 | 0x44 | 0x4d | 0x45) {+ hits.push(i as u32);+ }+ }+ if i + 1 < hay.len() && hay[i] == 0x4c && hay[i + 1] == 0x89 {+ hits.push(i as u32);+ }+ }+ }+ KernelKind::Stack | KernelKind::SubRsp => {+ for i in 0..hay.len() {+ if i + 2 < hay.len()+ && hay[i] == 0x48+ && (hay[i + 1] == 0x83 || hay[i + 1] == 0x81)+ && hay[i + 2] == 0xec+ {+ hits.push(i as u32);+ continue;+ }+ if matches!(kind, KernelKind::Stack)+ && i + 2 < hay.len()+ && hay[i] == 0x48+ && hay[i + 1] == 0x89+ && matches!(hay[i + 2], 0x45 | 0x4d)+ {+ hits.push(i as u32);+ }+ }+ }+ KernelKind::Cstr => {+ let n = needle.unwrap_or(b"");+ if n.is_empty() {+ return (hits, aux);+ }+ for i in 0..=hay.len().saturating_sub(n.len()) {+ if &hay[i..i + n.len()] == n {+ hits.push(i as u32);+ }+ }+ }+ }+ (hits, aux)+}++fn is_print(b: u8) -> bool {+ (0x20..=0x7e).contains(&b) || b == b'\t'+}++#[cfg(feature = "gpu")]+fn run_kernel_gpu(+ hay: &[u8],+ kind: KernelKind,+ needle: Option<&[u8]>,+ image_base: u64,+ image_end: u64,+ wall0: Instant,+) -> Result<GpuRunBackend, String> {+ use pollster::block_on;+ use wgpu::util::DeviceExt;++ let setup0 = Instant::now();+ let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());+ let adapter = block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {+ power_preference: wgpu::PowerPreference::HighPerformance,+ compatible_surface: None,+ force_fallback_adapter: false,+ }))+ .ok_or_else(|| "no wgpu adapter".to_string())?;+ let info = adapter.get_info();+ let device_name = format!("{} ({:?})", info.name, info.backend);+ let mut limits = adapter.limits();+ limits.max_storage_buffers_per_shader_stage =+ limits.max_storage_buffers_per_shader_stage.max(8);+ let (device, queue) = block_on(adapter.request_device(+ &wgpu::DeviceDescriptor {+ label: Some("ghidrust-analyzer-gpu"),+ required_features: wgpu::Features::empty(),+ required_limits: limits,+ memory_hints: Default::default(),+ },+ None,+ ))+ .map_err(|e| format!("device: {e}"))?;++ let mut hay_pad = hay.to_vec();+ while hay_pad.len() % 4 != 0 {+ hay_pad.push(0);+ }+ let n = hay.len() as u32;+ let (nw, nlen) = pack_needle(needle.unwrap_or(b""));+ let max_hits = MAX_HITS;+ // params[12] = base_inv (updated per chunk for large images)+ let mut params = [+ n,+ 0u32,+ nw[0],+ nw[1],+ nw[2],+ nw[3],+ nlen,+ max_hits,+ image_base as u32,+ (image_base >> 32) as u32,+ image_end as u32,+ (image_end >> 32) as u32,+ 0u32, // base_inv+ 0,+ 0,+ 0,+ ];++ let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {+ label: Some("analyzer_kernels"),+ source: wgpu::ShaderSource::Wgsl(include_str!("kernels.wgsl").into()),+ });+ let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {+ label: None,+ entries: &[+ storage_ro(0),+ storage_rw(1),+ storage_rw(2),+ uniform(3),+ storage_rw(4),+ ],+ });+ let pl = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {+ label: None,+ bind_group_layouts: &[&bgl],+ push_constant_ranges: &[],+ });+ let pipe = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {+ label: Some(kind.entry_point()),+ layout: Some(&pl),+ module: &shader,+ entry_point: Some(kind.entry_point()),+ compilation_options: Default::default(),+ cache: None,+ });+ let setup_ms = setup0.elapsed().as_secs_f64() * 1000.0;++ // ── PCIe upload ──────────────────────────────────────────────────────+ let t_up = Instant::now();+ let buf_hay = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("hay"),+ contents: &hay_pad,+ usage: wgpu::BufferUsages::STORAGE,+ });+ let hits_init = vec![0u32; max_hits as usize];+ let buf_hits = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("hits"),+ contents: bytemuck::cast_slice(&hits_init),+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,+ });+ let cnt_init = [0u32];+ let buf_cnt = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("cnt"),+ contents: bytemuck::cast_slice(&cnt_init),+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,+ });+ let aux_init = vec![0u32; max_hits as usize];+ let buf_aux = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("aux"),+ contents: bytemuck::cast_slice(&aux_init),+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,+ });+ let buf_params = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("params"),+ contents: bytemuck::cast_slice(¶ms),+ usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,+ });+ queue.submit([]);+ device.poll(wgpu::Maintain::Wait);+ let pcie_upload_ms = t_up.elapsed().as_secs_f64() * 1000.0;++ let bg = device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: None,+ layout: &bgl,+ entries: &[+ wgpu::BindGroupEntry {+ binding: 0,+ resource: buf_hay.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 1,+ resource: buf_hits.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 2,+ resource: buf_cnt.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 3,+ resource: buf_params.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 4,+ resource: buf_aux.as_entire_binding(),+ },+ ],+ });++ // wgpu max workgroups per dimension is 65535; chunk large PEs.+ const MAX_WG: u32 = 65535;+ const WG_SIZE: u32 = 256;+ let inv = kind.invocation_count(n);+ let inv_per_chunk = MAX_WG.saturating_mul(WG_SIZE);++ // ── on-device SIMT (multi-dispatch chunks) ───────────────────────────+ let t_dev = Instant::now();+ let mut base_inv = 0u32;+ let mut chunks = 0u32;+ while base_inv < inv {+ let remaining = inv - base_inv;+ let wg = remaining.div_ceil(WG_SIZE).min(MAX_WG).max(1);+ params[12] = base_inv;+ queue.write_buffer(&buf_params, 0, bytemuck::cast_slice(¶ms));+ let mut enc = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {+ label: Some("analyzer-kernel-chunk"),+ });+ {+ let mut pass = enc.begin_compute_pass(&wgpu::ComputePassDescriptor {+ label: None,+ timestamp_writes: None,+ });+ pass.set_pipeline(&pipe);+ pass.set_bind_group(0, &bg, &[]);+ pass.dispatch_workgroups(wg, 1, 1);+ }+ queue.submit(Some(enc.finish()));+ chunks += 1;+ base_inv = base_inv.saturating_add(wg.saturating_mul(WG_SIZE));+ if base_inv == 0 {+ break; // safety+ }+ }+ device.poll(wgpu::Maintain::Wait);+ let device_ms = t_dev.elapsed().as_secs_f64() * 1000.0;+ let _ = inv_per_chunk;++ // ── PCIe download (staging copy + map) ───────────────────────────────+ let t_dn = Instant::now();+ let read_cnt = device.create_buffer(&wgpu::BufferDescriptor {+ label: None,+ size: 4,+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ let read_hits = device.create_buffer(&wgpu::BufferDescriptor {+ label: None,+ size: (max_hits as u64) * 4,+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ let read_aux = device.create_buffer(&wgpu::BufferDescriptor {+ label: None,+ size: (max_hits as u64) * 4,+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ let mut enc2 = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });+ enc2.copy_buffer_to_buffer(&buf_cnt, 0, &read_cnt, 0, 4);+ enc2.copy_buffer_to_buffer(&buf_hits, 0, &read_hits, 0, (max_hits as u64) * 4);+ enc2.copy_buffer_to_buffer(&buf_aux, 0, &read_aux, 0, (max_hits as u64) * 4);+ queue.submit(Some(enc2.finish()));+ device.poll(wgpu::Maintain::Wait);++ let total_hits = map_u32(&device, &read_cnt, 1)?[0] as usize;+ let n_sample = total_hits.min(max_hits as usize);+ let hits = map_u32(&device, &read_hits, n_sample)?;+ let hit_aux = if matches!(kind, KernelKind::HashWin) {+ map_u32(&device, &read_aux, n_sample)?+ } else {+ Vec::new()+ };+ let pcie_download_ms = t_dn.elapsed().as_secs_f64() * 1000.0;++ Ok(GpuRunBackend {+ backend: "gpu_analyzer_kernel".into(),+ device: device_name,+ timing: GpuPhaseTiming {+ pcie_upload_ms,+ device_ms,+ pcie_download_ms,+ wall_ms: wall0.elapsed().as_secs_f64() * 1000.0,+ setup_ms,+ },+ hits,+ total_hits,+ hit_aux,+ note: format!(+ "kernel={} inv={} chunks={} simt_chunked",+ kind.entry_point(),+ inv,+ chunks+ ),+ })+}++#[cfg(feature = "gpu")]+fn storage_ro(binding: u32) -> wgpu::BindGroupLayoutEntry {+ wgpu::BindGroupLayoutEntry {+ binding,+ visibility: wgpu::ShaderStages::COMPUTE,+ ty: wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Storage { read_only: true },+ has_dynamic_offset: false,+ min_binding_size: None,+ },+ count: None,+ }+}+#[cfg(feature = "gpu")]+fn storage_rw(binding: u32) -> wgpu::BindGroupLayoutEntry {+ wgpu::BindGroupLayoutEntry {+ binding,+ visibility: wgpu::ShaderStages::COMPUTE,+ ty: wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Storage { read_only: false },+ has_dynamic_offset: false,+ min_binding_size: None,+ },+ count: None,+ }+}+#[cfg(feature = "gpu")]+fn uniform(binding: u32) -> wgpu::BindGroupLayoutEntry {+ wgpu::BindGroupLayoutEntry {+ binding,+ visibility: wgpu::ShaderStages::COMPUTE,+ ty: wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Uniform,+ has_dynamic_offset: false,+ min_binding_size: None,+ },+ count: None,+ }+}++#[cfg(feature = "gpu")]+fn map_u32(device: &wgpu::Device, buf: &wgpu::Buffer, n: usize) -> Result<Vec<u32>, String> {+ if n == 0 {+ return Ok(Vec::new());+ }+ let slice = buf.slice(..((n as u64) * 4).max(4));+ let (tx, rx) = std::sync::mpsc::channel();+ slice.map_async(wgpu::MapMode::Read, move |r| {+ let _ = tx.send(r);+ });+ device.poll(wgpu::Maintain::Wait);+ rx.recv()+ .map_err(|e| e.to_string())?+ .map_err(|e| format!("map:{e}"))?;+ let data = slice.get_mapped_range();+ let v: Vec<u32> = bytemuck::cast_slice(&data[..n * 4]).to_vec();+ drop(data);+ buf.unmap();+ Ok(v)+}diff --git a/crates/ghidrust-core/src/gpu_analyzers/kernels.wgsl b/crates/ghidrust-core/src/gpu_analyzers/kernels.wgslnew file mode 100644index 0000000..1f6cda8--- /dev/null+++ b/crates/ghidrust-core/src/gpu_analyzers/kernels.wgsl@@ -0,0 +1,270 @@+// SIMT analyzer kernels — one work item per byte offset, atomic hit append.+// Distinct algorithms per strategy (not a single printable kernel rebranded).++struct Params {+ n: u32,+ mode: u32,+ needle0: u32,+ needle1: u32,+ needle2: u32,+ needle3: u32,+ needle_len: u32,+ max_hits: u32,+ image_base_lo: u32,+ image_base_hi: u32,+ image_end_lo: u32,+ image_end_hi: u32,+ /// Invocation base for multi-dispatch when n > 65535*workgroup (large PEs).+ base_inv: u32,+ _p1: u32,+ _p2: u32,+ _p3: u32,+}++@group(0) @binding(0) var<storage, read> hay: array<u32>;+@group(0) @binding(1) var<storage, read_write> hits: array<u32>;+@group(0) @binding(2) var<storage, read_write> hit_count: array<atomic<u32>>;+@group(0) @binding(3) var<uniform> params: Params;+// optional: hash values parallel to hits for FID+@group(0) @binding(4) var<storage, read_write> hit_aux: array<u32>;++fn load_b(off: u32) -> u32 {+ let w = hay[off / 4u];+ let s = (off % 4u) * 8u;+ return (w >> s) & 0xffu;+}++fn is_print(b: u32) -> bool {+ return (b >= 0x20u && b <= 0x7eu) || (b == 0x09u);+}++fn push_hit(off: u32) {+ let i = atomicAdd(&hit_count[0], 1u);+ if (i < params.max_hits) {+ hits[i] = off;+ }+}++fn push_hit_aux(off: u32, aux: u32) {+ let i = atomicAdd(&hit_count[0], 1u);+ if (i < params.max_hits) {+ hits[i] = off;+ hit_aux[i] = aux;+ }+}++fn in_image(lo: u32, hi: u32) -> bool {+ let blo = params.image_base_lo;+ let bhi = params.image_base_hi;+ let elo = params.image_end_lo;+ let ehi = params.image_end_hi;+ if (hi > bhi || (hi == bhi && lo >= blo)) {+ if (hi < ehi || (hi == ehi && lo < elo)) {+ return true;+ }+ }+ return false;+}++// ── printable_run: run starts of length >= 4 (SIMT) ──────────────────────+@compute @workgroup_size(256)+fn k_printable(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i >= params.n) { return; }+ if (!is_print(load_b(i))) { return; }+ if (i > 0u && is_print(load_b(i - 1u))) { return; } // only starts+ // measure run length+ var j = i;+ loop {+ if (j >= params.n || !is_print(load_b(j))) { break; }+ j = j + 1u;+ }+ if (j - i >= 4u) {+ push_hit(i);+ }+}++// ── magic_media: PNG/JPEG/GIF/RIFF (SIMT) ────────────────────────────────+@compute @workgroup_size(256)+fn k_magic_media(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i >= params.n) { return; }+ let b0 = load_b(i);+ // PNG: 4 bytes+ if (i + 4u <= params.n && b0 == 0x89u && load_b(i+1u) == 0x50u+ && load_b(i+2u) == 0x4eu && load_b(i+3u) == 0x47u) {+ push_hit(i); return;+ }+ // JPEG SOI+ if (i + 3u <= params.n && b0 == 0xffu && load_b(i+1u) == 0xd8u && load_b(i+2u) == 0xffu) {+ push_hit(i); return;+ }+ // GIF+ if (i + 3u <= params.n && b0 == 0x47u && load_b(i+1u) == 0x49u && load_b(i+2u) == 0x46u) {+ push_hit(i); return;+ }+ // RIFF+ if (i + 4u <= params.n && b0 == 0x52u && load_b(i+1u) == 0x49u+ && load_b(i+2u) == 0x46u && load_b(i+3u) == 0x46u) {+ push_hit(i);+ }+}++// ── magic_res: VS_VERSION_INFO / RS ──────────────────────────────────────+@compute @workgroup_size(256)+fn k_magic_res(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i + 2u < params.n && load_b(i) == 0x56u && load_b(i + 1u) == 0x00u && load_b(i + 2u) == 0x53u) {+ push_hit(i); return;+ }+ if (i + 1u < params.n && load_b(i) == 0x52u && load_b(i + 1u) == 0x53u) {+ push_hit(i);+ }+}++// ── prologue_seed: 55 48 89 e5 / 48 83 ec ────────────────────────────────+@compute @workgroup_size(256)+fn k_prologue(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i + 3u < params.n && load_b(i) == 0x55u && load_b(i+1u) == 0x48u+ && load_b(i+2u) == 0x89u && load_b(i+3u) == 0xe5u) {+ push_hit(i); return;+ }+ if (i + 2u < params.n && load_b(i) == 0x48u && load_b(i+1u) == 0x83u && load_b(i+2u) == 0xecu) {+ // skip if mid-frame after 55 48 89 e5+ if (i >= 4u && load_b(i-4u) == 0x55u && load_b(i-3u) == 0x48u+ && load_b(i-2u) == 0x89u && load_b(i-1u) == 0xe5u) {+ return;+ }+ push_hit(i);+ }+}++// ── ptr_chain: table base if 3+ consecutive in-image u64 ─────────────────+@compute @workgroup_size(256)+fn k_ptr_u64(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = (gid.x + params.base_inv) * 8u; // 8-byte aligned candidates+ if (i + 24u > params.n) { return; }+ var run: u32 = 0u;+ var j = i;+ loop {+ if (j + 8u > params.n || run >= 64u) { break; }+ let lo = load_b(j) | (load_b(j+1u) << 8u) | (load_b(j+2u) << 16u) | (load_b(j+3u) << 24u);+ let hi = load_b(j+4u) | (load_b(j+5u) << 8u) | (load_b(j+6u) << 16u) | (load_b(j+7u) << 24u);+ if (in_image(lo, hi)) {+ run = run + 1u;+ j = j + 8u;+ } else {+ break;+ }+ }+ if (run >= 3u) {+ push_hit(i);+ }+}++// ── rtti_scan ────────────────────────────────────────────────────────────+@compute @workgroup_size(256)+fn k_rtti(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i + 4u > params.n) { return; }+ if (load_b(i) == 0x2eu && load_b(i+1u) == 0x3fu && load_b(i+2u) == 0x41u+ && (load_b(i+3u) == 0x56u || load_b(i+3u) == 0x55u)) {+ push_hit(i); return;+ }+ if (load_b(i) == 0x5fu && load_b(i+1u) == 0x5au && load_b(i+2u) == 0x54u && load_b(i+3u) == 0x53u) {+ push_hit(i);+ }+}++// ── code_density: windows of non-cc density ──────────────────────────────+@compute @workgroup_size(256)+fn k_code_density(@builtin(global_invocation_id) gid: vec3<u32>) {+ let win = 16u;+ let i = (gid.x + params.base_inv) * win;+ if (i + win > params.n) { return; }+ var non: u32 = 0u;+ for (var k: u32 = 0u; k < win; k = k + 1u) {+ let b = load_b(i + k);+ if (b != 0xccu && b != 0u) { non = non + 1u; }+ }+ if (non >= 12u) { push_hit(i); }+}++// ── hash_window: FNV-1a over 8 bytes at prologue-like starts; aux=hash ───+@compute @workgroup_size(256)+fn k_hash_win(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i + 8u > params.n) { return; }+ let b0 = load_b(i);+ if (!(b0 == 0x55u || (b0 == 0x48u && load_b(i + 1u) == 0x83u))) { return; }+ var h: u32 = 2166136261u;+ for (var k: u32 = 0u; k < 8u; k = k + 1u) {+ h = (h ^ load_b(i + k)) * 16777619u;+ }+ push_hit_aux(i, h);+}++// ── ret_epilogue ─────────────────────────────────────────────────────────+@compute @workgroup_size(256)+fn k_ret(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i >= params.n) { return; }+ let b = load_b(i);+ if (b == 0xc3u || b == 0xc2u) { push_hit(i); }+}++// ── spill_scan ───────────────────────────────────────────────────────────+@compute @workgroup_size(256)+fn k_spill(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i + 2u < params.n && load_b(i) == 0x48u && load_b(i+1u) == 0x89u) {+ let m = load_b(i+2u);+ if (m == 0x4cu || m == 0x54u || m == 0x44u || m == 0x4du || m == 0x45u) {+ push_hit(i);+ }+ }+ if (i + 1u < params.n && load_b(i) == 0x4cu && load_b(i+1u) == 0x89u) {+ push_hit(i);+ }+}++// ── stack_frame ──────────────────────────────────────────────────────────+@compute @workgroup_size(256)+fn k_stack(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i + 2u < params.n && load_b(i) == 0x48u+ && (load_b(i+1u) == 0x83u || load_b(i+1u) == 0x81u) && load_b(i+2u) == 0xecu) {+ push_hit(i); return;+ }+ if (i + 2u < params.n && load_b(i) == 0x48u && load_b(i+1u) == 0x89u+ && (load_b(i+2u) == 0x45u || load_b(i+2u) == 0x4du)) {+ push_hit(i);+ }+}++// ── cstr multi-needle (one needle per dispatch) ──────────────────────────+@compute @workgroup_size(256)+fn k_cstr(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ let nlen = params.needle_len;+ if (nlen == 0u || nlen > 16u || i + nlen > params.n) { return; }+ var needle: array<u32, 16>;+ let p0 = params.needle0; let p1 = params.needle1; let p2 = params.needle2; let p3 = params.needle3;+ needle[0] = p0 & 0xffu; needle[1] = (p0 >> 8u) & 0xffu; needle[2] = (p0 >> 16u) & 0xffu; needle[3] = (p0 >> 24u) & 0xffu;+ needle[4] = p1 & 0xffu; needle[5] = (p1 >> 8u) & 0xffu; needle[6] = (p1 >> 16u) & 0xffu; needle[7] = (p1 >> 24u) & 0xffu;+ needle[8] = p2 & 0xffu; needle[9] = (p2 >> 8u) & 0xffu; needle[10] = (p2 >> 16u) & 0xffu; needle[11] = (p2 >> 24u) & 0xffu;+ needle[12] = p3 & 0xffu; needle[13] = (p3 >> 8u) & 0xffu; needle[14] = (p3 >> 16u) & 0xffu; needle[15] = (p3 >> 24u) & 0xffu;+ for (var k: u32 = 0u; k < nlen; k = k + 1u) {+ if (load_b(i + k) != needle[k]) { return; }+ }+ push_hit(i);+}++@compute @workgroup_size(256)+fn k_sub_rsp(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x + params.base_inv;+ if (i + 2u < params.n && load_b(i) == 0x48u && load_b(i+1u) == 0x83u && load_b(i+2u) == 0xecu) {+ push_hit(i);+ }+}diff --git a/crates/ghidrust-core/src/gpu_analyzers/mod.rs b/crates/ghidrust-core/src/gpu_analyzers/mod.rsnew file mode 100644index 0000000..53ebb84--- /dev/null+++ b/crates/ghidrust-core/src/gpu_analyzers/mod.rs@@ -0,0 +1,383 @@+//! Per-analyzer GPU acceleration: dedicated SIMT kernels + PCIe vs on-device timing.+//!+//! Equality is **seed-stage**: CPU kernel oracle vs GPU kernel on the **same** haystack.+//! Host merge applies GPU seeds into `Program` analysis fields.+//! See docs/GPU_ANALYZER_MATRIX.md.++mod engine;+mod strategies;++use crate::analyzers::{run_analyzers, ANALYZER_NAMES};+use crate::program::Program;+use serde::Serialize;+use std::time::Instant;++pub use engine::{cpu_emulate_kernel, GpuPhaseTiming, GpuRunBackend, KernelKind, MAX_HITS};+pub use strategies::{+ flat_to_va, gpu_strategy_for, merge_seeds_into_program, seeds_equal, strategy_matrix,+ GpuStrategyClass,+};++/// One row of the CPU/GPU analyzer benchmark matrix.+#[derive(Debug, Clone, Serialize)]+pub struct AnalyzerBenchRow {+ pub name: String,+ pub strategy: String,+ /// CPU seed-kernel time on the same haystack as GPU.+ pub cpu_ms: f64,+ /// CPU seed-kernel hit count (oracle for equality).+ pub cpu_primary: usize,+ pub gpu_pcie_upload_ms: f64,+ pub gpu_device_ms: f64,+ pub gpu_pcie_download_ms: f64,+ pub gpu_pcie_ms: f64,+ pub gpu_wall_ms: f64,+ /// GPU seed hit count (atomic total).+ pub gpu_primary: usize,+ /// True when seed multisets match (CPU kernel vs GPU on same hay).+ pub equal: bool,+ pub backend: String,+ pub device: String,+ pub note: String,+ /// Filtered Auto Analysis primary (informational; not used for `equal`).+ pub analyzer_oracle: usize,+ /// Count after host-merging GPU seeds into Program.+ pub merged_primary: usize,+}++/// Flatten program bytes for GPU (all blocks concatenated) + VA map.+pub fn flatten_image(prog: &Program) -> (Vec<u8>, Vec<(u64, usize, usize)>) {+ let mut flat = Vec::new();+ let mut map = Vec::new();+ for b in &prog.blocks {+ let start = flat.len();+ flat.extend_from_slice(&b.bytes);+ map.push((b.va, start, b.bytes.len()));+ }+ (flat, map)+}++/// Exec-only flatten.+pub fn flatten_exec(prog: &Program) -> (Vec<u8>, Vec<(u64, usize, usize)>) {+ let mut flat = Vec::new();+ let mut map = Vec::new();+ for b in prog.exec_blocks() {+ let start = flat.len();+ flat.extend_from_slice(&b.bytes);+ map.push((b.va, start, b.bytes.len()));+ }+ if flat.is_empty() {+ return flatten_image(prog);+ }+ (flat, map)+}++/// Pad haystack to at least `min_bytes` by tiling (reproducible large workload).+pub fn pad_large(mut hay: Vec<u8>, min_bytes: usize) -> Vec<u8> {+ if hay.is_empty() {+ hay.resize(4096, 0);+ }+ let base = hay.clone();+ while hay.len() < min_bytes {+ let need = min_bytes - hay.len();+ hay.extend_from_slice(&base[..need.min(base.len())]);+ }+ hay+}++fn analyzer_oracle_count(prog: &mut Program, name: &str) -> usize {+ let Ok(report) = run_analyzers(prog, &[name]) else {+ return 0;+ };+ let Some(r) = report.results.first() else {+ return 0;+ };+ primary_from_output(r)+}++fn primary_from_output(r: &crate::analyzers::AnalyzerOutput) -> usize {+ if let Some(ref s) = r.strings {+ return s.len();+ }+ if let Some(ref f) = r.functions {+ return f.len();+ }+ if let Some(ref m) = r.media {+ return m.len();+ }+ if let Some(ref t) = r.address_tables {+ return t.len();+ }+ if let Some(ref x) = r.rtti {+ return x.classes.len();+ }+ if let Some(ref s) = r.symbols {+ return s.len();+ }+ if let Some(ref c) = r.call_fixups {+ return c.len();+ }+ if let Some(ref f) = r.fid_matches {+ return f.len();+ }+ if let Some(ref s) = r.switches {+ return s.len();+ }+ if let Some(ref rsc) = r.resources {+ return rsc.len();+ }+ if let Some(ref v) = r.shared_returns {+ return v.len();+ }+ if let Some(ref v) = r.noreturn_entries {+ return v.len();+ }+ if let Some(ref v) = r.varargs_entries {+ return v.len();+ }+ if let Some(ref v) = r.stack_frames {+ return v.len();+ }+ if let Some(ref v) = r.conventions {+ return v.len();+ }+ if let Some(ref v) = r.external_params {+ return v.len();+ }+ if let Some(ref v) = r.recovered_ranges {+ return v.len();+ }+ parse_count_from_message(&r.message)+}++fn parse_count_from_message(msg: &str) -> usize {+ for w in msg.split(|c: char| !c.is_ascii_digit()) {+ if let Ok(n) = w.parse::<usize>() {+ if n > 0 {+ return n;+ }+ }+ }+ 0+}++/// Bench one analyzer: seed CPU oracle + GPU SIMT + host merge (honest equality).+pub fn bench_analyzer(prog: &Program, name: &str, large_min: Option<usize>) -> AnalyzerBenchRow {+ let strategy = gpu_strategy_for(name);++ // Filtered Auto Analysis oracle (informational)+ let mut prog_a = prog.clone();+ let t_a = Instant::now();+ let analyzer_oracle = analyzer_oracle_count(&mut prog_a, name);+ let _analyzer_ms = t_a.elapsed().as_secs_f64() * 1000.0;++ // CPU seed oracle on **same** hay as GPU+ let (cpu_primary, cpu_hits, cpu_ms) =+ strategies::cpu_seed_count(prog, name, strategy, large_min);++ let gpu = strategies::run_gpu_for_analyzer(prog, name, strategy, large_min);+ let equal = seeds_equal(&cpu_hits, gpu.primary, &gpu.hits);++ AnalyzerBenchRow {+ name: name.into(),+ strategy: strategy.as_str().into(),+ cpu_ms,+ cpu_primary,+ gpu_pcie_upload_ms: gpu.timing.pcie_upload_ms,+ gpu_device_ms: gpu.timing.device_ms,+ gpu_pcie_download_ms: gpu.timing.pcie_download_ms,+ gpu_pcie_ms: gpu.timing.pcie_upload_ms + gpu.timing.pcie_download_ms,+ gpu_wall_ms: gpu.timing.wall_ms,+ gpu_primary: gpu.primary,+ equal,+ backend: gpu.backend,+ device: gpu.device,+ note: format!(+ "{} | oracle_analyzer={} | setup_ms={:.3}",+ gpu.note, analyzer_oracle, gpu.timing.setup_ms+ ),+ analyzer_oracle,+ merged_primary: gpu.merged_primary,+ }+}++/// Bench all 20 analyzers (+ optional large pad).+pub fn bench_all_analyzers(prog: &Program, large_min: Option<usize>) -> Vec<AnalyzerBenchRow> {+ ANALYZER_NAMES+ .iter()+ .map(|n| bench_analyzer(prog, n, large_min))+ .collect()+}++/// Run GPU strategy kernels for each named analyzer and merge seeds into `prog`.+/// Used when CLI/GUI `--gpu` / GPU experimental is on (alongside CPU analyzers).+pub fn gpu_enrich_analyzers(prog: &mut Program, names: &[&str]) -> Vec<(String, usize, String)> {+ let mut out = Vec::new();+ for &name in names {+ if !ANALYZER_NAMES.contains(&name) {+ continue;+ }+ let st = gpu_strategy_for(name);+ let run = strategies::run_gpu_for_analyzer(prog, name, st, None);+ let (hay, map) = if matches!(+ st,+ GpuStrategyClass::PrologueSeed+ | GpuStrategyClass::PrologueAbi+ | GpuStrategyClass::CodeDensity+ | GpuStrategyClass::HashWindow+ | GpuStrategyClass::RetEpilogue+ | GpuStrategyClass::SpillScan+ | GpuStrategyClass::StackFrame+ | GpuStrategyClass::SubRsp+ ) {+ flatten_exec(prog)+ } else {+ flatten_image(prog)+ };+ let n = merge_seeds_into_program(+ prog,+ name,+ st,+ &run.hits,+ &run.hit_aux,+ &map,+ &hay,+ );+ out.push((name.into(), n, run.backend));+ }+ out+}++/// Structure-seed decompile row.+pub fn bench_gpu_decompile_row(prog: &Program) -> AnalyzerBenchRow {+ strategies::bench_decompile(prog)+}++pub fn format_matrix_table() -> String {+ let mut s = String::from("name\tstrategy\n");+ for (n, st) in strategy_matrix() {+ s.push_str(&format!("{n}\t{}\n", st.as_str()));+ }+ s.push_str("GPU Decompile\tdecomp_multipass\n");+ s+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::{fixture_path, load_path, ANALYZER_NAMES};++ #[test]+ fn matrix_covers_all_twenty_analyzers() {+ let m = strategy_matrix();+ assert_eq!(m.len(), 20);+ for &name in ANALYZER_NAMES {+ assert!(+ m.iter().any(|(n, _)| *n == name),+ "missing strategy for {name}"+ );+ }+ let table = format_matrix_table();+ for &name in ANALYZER_NAMES {+ assert!(table.contains(name), "table missing {name}");+ }+ assert!(table.contains("decomp_multipass"));+ }++ #[test]+ fn distinct_strategy_classes_not_only_printable() {+ let classes: std::collections::BTreeSet<_> = strategy_matrix()+ .into_iter()+ .map(|(_, c)| c.as_str())+ .collect();+ assert!(+ classes.len() >= 8,+ "expected diverse strategies, got {classes:?}"+ );+ assert!(classes.contains("printable_run"));+ assert!(classes.contains("rtti_scan"));+ assert!(classes.contains("magic_media"));+ assert!(classes.contains("prologue_seed"));+ }++ #[test]+ fn bench_each_analyzer_seed_equal_and_pcie_split() {+ let prog = load_path(fixture_path("analysis_lab.pe")).expect("lab");+ for &name in ANALYZER_NAMES {+ let row = bench_analyzer(&prog, name, None);+ assert_eq!(row.name, name);+ assert!(!row.strategy.is_empty());+ assert!(row.gpu_pcie_upload_ms >= 0.0);+ assert!(row.gpu_device_ms >= 0.0);+ assert!(row.gpu_pcie_download_ms >= 0.0);+ assert!(+ (row.gpu_pcie_ms - (row.gpu_pcie_upload_ms + row.gpu_pcie_download_ms)).abs()+ < 1e-6+ );+ assert!(!row.backend.is_empty());+ assert!(+ row.equal,+ "{name}: seed mismatch cpu={} gpu={} backend={} note={}",+ row.cpu_primary, row.gpu_primary, row.backend, row.note+ );+ // Real GPU when adapter present+ if row.backend == "gpu_analyzer_kernel" {+ assert!(+ row.gpu_pcie_upload_ms > 0.0 || row.gpu_device_ms > 0.0,+ "{name}: GPU path should record timing"+ );+ }+ }+ let drow = bench_gpu_decompile_row(&prog);+ assert!(drow.strategy.contains("decomp"));+ assert!(drow.equal, "structure seed decomp row must be equal");+ }++ #[test]+ fn large_pad_seed_equal_same_haystack() {+ let prog = load_path(fixture_path("tiny_x64.pe")).unwrap();+ let (hay, _) = flatten_image(&prog);+ let big = pad_large(hay.clone(), 2 * 1024 * 1024);+ assert!(big.len() >= 2 * 1024 * 1024);+ let row = bench_analyzer(&prog, "ASCII Strings", Some(2 * 1024 * 1024));+ assert_eq!(row.name, "ASCII Strings");+ assert!(+ row.equal,+ "large pad seed equal cpu={} gpu={}",+ row.cpu_primary, row.gpu_primary+ );+ assert!(row.gpu_device_ms >= 0.0);+ // GPU primary scales with tiled hay (throughput workload)+ assert!(row.gpu_primary >= row.analyzer_oracle || row.gpu_primary > 0 || row.cpu_primary == 0);+ }++ #[test]+ fn host_merge_writes_program_fields() {+ let prog = load_path(fixture_path("analysis_lab.pe")).expect("lab");+ let st = gpu_strategy_for("Function Start Search");+ let run = strategies::run_gpu_for_analyzer(&prog, "Function Start Search", st, None);+ assert!(run.merged_primary > 0 || run.primary == 0);+ let mut p2 = prog.clone();+ let (hay, map) = flatten_exec(&prog);+ let n = merge_seeds_into_program(+ &mut p2,+ "Function Start Search",+ st,+ &run.hits,+ &[],+ &map,+ &hay,+ );+ if run.primary > 0 {+ assert!(n > 0, "merge should place functions from prologue seeds");+ assert!(!p2.analysis.functions.is_empty());+ }+ }++ #[test]+ fn no_loose_tolerance_helper() {+ // Ponytail: equality is exact seeds_equal only — no 4096× fudge API.+ assert!(seeds_equal(&[1, 2, 3], 3, &[3, 1, 2]));+ assert!(!seeds_equal(&[1], 2, &[1, 2]));+ }+}diff --git a/crates/ghidrust-core/src/gpu_analyzers/strategies.rs b/crates/ghidrust-core/src/gpu_analyzers/strategies.rsnew file mode 100644index 0000000..72275e7--- /dev/null+++ b/crates/ghidrust-core/src/gpu_analyzers/strategies.rs@@ -0,0 +1,642 @@+//! Map each Auto Analysis name to a GPU kernel strategy + host seed merge.++use super::engine::{cpu_emulate_kernel, run_kernel, GpuPhaseTiming, KernelKind, MAX_HITS};+use super::{flatten_exec, flatten_image, pad_large};+use crate::program::{+ AddressTableInfo, CallFixupInfo, DiscoveredRange, FidMatch, FunctionInfo, MediaHit, Program,+ ResourceInfo, SymbolInfo,+};+use crate::rtti::RttiClass;+use std::time::Instant;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum GpuStrategyClass {+ PrintableRun,+ MagicMedia,+ MagicRes,+ PrologueSeed,+ PtrChain,+ RttiScan,+ CodeDensity,+ HashWindow,+ RetEpilogue,+ SpillScan,+ StackFrame,+ CstrMulti,+ PrologueAbi,+ SubRsp,+ DecompMultipass,+}++impl GpuStrategyClass {+ pub fn as_str(self) -> &'static str {+ match self {+ Self::PrintableRun => "printable_run",+ Self::MagicMedia => "magic_media",+ Self::MagicRes => "magic_res",+ Self::PrologueSeed => "prologue_seed",+ Self::PtrChain => "ptr_chain",+ Self::RttiScan => "rtti_scan",+ Self::CodeDensity => "code_density",+ Self::HashWindow => "hash_window",+ Self::RetEpilogue => "ret_epilogue",+ Self::SpillScan => "spill_scan",+ Self::StackFrame => "stack_frame",+ Self::CstrMulti => "cstr_multi",+ Self::PrologueAbi => "prologue_abi",+ Self::SubRsp => "sub_rsp",+ Self::DecompMultipass => "decomp_multipass",+ }+ }+}++pub fn gpu_strategy_for(name: &str) -> GpuStrategyClass {+ match name {+ "ASCII Strings" => GpuStrategyClass::PrintableRun,+ "Aggressive Instruction Finder" => GpuStrategyClass::CodeDensity,+ "Call Convention ID" => GpuStrategyClass::PrologueAbi,+ "Call-Fixup Installer" => GpuStrategyClass::CstrMulti,+ "Create Address Tables" => GpuStrategyClass::PtrChain,+ "Decompiler Parameter ID" => GpuStrategyClass::SpillScan,+ "Decompiler Switch Analysis" => GpuStrategyClass::PtrChain,+ "Demangler Microsoft" => GpuStrategyClass::CstrMulti,+ "Embedded Media" => GpuStrategyClass::MagicMedia,+ "Function ID" => GpuStrategyClass::HashWindow,+ "Function Start Search" => GpuStrategyClass::PrologueSeed,+ "Non-Returning Functions - Discovered" => GpuStrategyClass::CstrMulti,+ "PDB MSDIA" => GpuStrategyClass::CstrMulti,+ "PDB Universal" => GpuStrategyClass::CstrMulti,+ "Shared Return Calls" => GpuStrategyClass::RetEpilogue,+ "Stack" => GpuStrategyClass::StackFrame,+ "Variadic Function Signature Override" => GpuStrategyClass::CstrMulti,+ "WindowsPE x86 PE RTTI Analyzer" => GpuStrategyClass::RttiScan,+ "Windows x86 Propagate External Parameters" => GpuStrategyClass::CstrMulti,+ "WindowsResourceReference" => GpuStrategyClass::MagicRes,+ _ => GpuStrategyClass::PrintableRun,+ }+}++pub fn strategy_matrix() -> Vec<(&'static str, GpuStrategyClass)> {+ crate::analyzers::ANALYZER_NAMES+ .iter()+ .map(|&n| (n, gpu_strategy_for(n)))+ .collect()+}++pub struct GpuAnalyzerRun {+ pub primary: usize,+ /// Hits after host merge into Program (analyzer-shaped).+ pub merged_primary: usize,+ pub timing: GpuPhaseTiming,+ pub backend: String,+ pub device: String,+ pub note: String,+ pub hits: Vec<u32>,+ /// FNV aux hashes when strategy is HashWindow (parallel to hits sample).+ #[allow(dead_code)]+ pub hit_aux: Vec<u32>,+}++fn needles_for(name: &str) -> Vec<&'static [u8]> {+ match name {+ "Call-Fixup Installer" => vec![b"__security_check_cookie", b"security_cookie"],+ "Demangler Microsoft" => vec![b".?AV", b".?AU", b"??_"],+ "Non-Returning Functions - Discovered" => {+ vec![b"ExitProcess", b"abort", b"_exit", b"ExitThread"]+ }+ "PDB MSDIA" => vec![b"Microsoft C/C++", b"MSF 7.00", b".pdb"],+ "PDB Universal" => vec![b"MSF 7.00", b"PDB 7.00", b"mspdbsrv"],+ "Variadic Function Signature Override" => {+ vec![b"printf", b"sprintf", b"snprintf", b"scanf", b"sscanf"]+ }+ "Windows x86 Propagate External Parameters" => {+ vec![b"CreateFileW", b"ReadFile", b"WriteFile", b"GetProcAddress"]+ }+ _ => vec![b"main"],+ }+}++fn kernel_for(st: GpuStrategyClass) -> KernelKind {+ match st {+ GpuStrategyClass::PrintableRun => KernelKind::Printable,+ GpuStrategyClass::MagicMedia => KernelKind::MagicMedia,+ GpuStrategyClass::MagicRes => KernelKind::MagicRes,+ GpuStrategyClass::PrologueSeed | GpuStrategyClass::PrologueAbi => KernelKind::Prologue,+ GpuStrategyClass::PtrChain => KernelKind::PtrU64,+ GpuStrategyClass::RttiScan => KernelKind::Rtti,+ GpuStrategyClass::CodeDensity => KernelKind::CodeDensity,+ GpuStrategyClass::HashWindow => KernelKind::HashWin,+ GpuStrategyClass::RetEpilogue => KernelKind::Ret,+ GpuStrategyClass::SpillScan => KernelKind::Spill,+ GpuStrategyClass::StackFrame => KernelKind::Stack,+ GpuStrategyClass::CstrMulti => KernelKind::Cstr,+ GpuStrategyClass::SubRsp => KernelKind::SubRsp,+ GpuStrategyClass::DecompMultipass => KernelKind::Printable,+ }+}++fn uses_exec(strategy: GpuStrategyClass) -> bool {+ matches!(+ strategy,+ GpuStrategyClass::PrologueSeed+ | GpuStrategyClass::PrologueAbi+ | GpuStrategyClass::CodeDensity+ | GpuStrategyClass::HashWindow+ | GpuStrategyClass::RetEpilogue+ | GpuStrategyClass::SpillScan+ | GpuStrategyClass::StackFrame+ | GpuStrategyClass::SubRsp+ )+}++/// Map flat haystack offset → VA using flatten map.+pub fn flat_to_va(map: &[(u64, usize, usize)], off: u32) -> Option<u64> {+ let o = off as usize;+ for &(va, start, len) in map {+ if o >= start && o < start + len {+ return Some(va + (o - start) as u64);+ }+ }+ None+}++/// Host merge: GPU seeds → Program analysis fields (analyzer-shaped primary).+pub fn merge_seeds_into_program(+ prog: &mut Program,+ name: &str,+ strategy: GpuStrategyClass,+ hits: &[u32],+ hit_aux: &[u32],+ map: &[(u64, usize, usize)],+ hay: &[u8],+) -> usize {+ match strategy {+ GpuStrategyClass::PrintableRun => {+ let mut n = 0usize;+ for &off in hits {+ let o = off as usize;+ if o >= hay.len() {+ continue;+ }+ let mut end = o;+ while end < hay.len() && is_print(hay[end]) {+ end += 1;+ }+ if end - o < 4 {+ continue;+ }+ if let Some(va) = flat_to_va(map, off) {+ let s = String::from_utf8_lossy(&hay[o..end]).into_owned();+ prog.analysis.symbols.push(SymbolInfo {+ va,+ name: s,+ demangled: None,+ });+ n += 1;+ }+ }+ n+ }+ GpuStrategyClass::MagicMedia => {+ for &off in hits {+ if let Some(va) = flat_to_va(map, off) {+ let kind = media_kind(hay, off as usize);+ prog.analysis.media.push(MediaHit {+ va,+ kind,+ length: 0,+ });+ }+ }+ prog.analysis.media.len()+ }+ GpuStrategyClass::MagicRes => {+ for &off in hits {+ if let Some(va) = flat_to_va(map, off) {+ prog.analysis.resources.push(ResourceInfo {+ type_id: 0,+ name: format!("res_{va:x}"),+ va,+ size: 0,+ });+ }+ }+ prog.analysis.resources.len()+ }+ GpuStrategyClass::PrologueSeed | GpuStrategyClass::PrologueAbi => {+ for &off in hits {+ if let Some(va) = flat_to_va(map, off) {+ if !prog.analysis.functions.iter().any(|f| f.entry == va) {+ prog.analysis.functions.push(FunctionInfo {+ entry: va,+ end: va,+ name: format!("FUN_{va:016x}"),+ calling_convention: if strategy == GpuStrategyClass::PrologueAbi {+ Some("unknown".into())+ } else {+ None+ },+ noreturn: false,+ varargs: false,+ parameters: Vec::new(),+ stack_locals: Vec::new(),+ });+ }+ }+ }+ prog.analysis.functions.len()+ }+ GpuStrategyClass::PtrChain => {+ for &off in hits {+ if let Some(va) = flat_to_va(map, off) {+ prog.analysis.address_tables.push(AddressTableInfo {+ base: va,+ count: 3,+ entries: Vec::new(),+ });+ }+ }+ prog.analysis.address_tables.len()+ }+ GpuStrategyClass::RttiScan => {+ for &off in hits {+ if let Some(va) = flat_to_va(map, off) {+ let name_s = read_cstr(hay, off as usize);+ prog.rtti.classes.push(RttiClass {+ name: name_s,+ type_info_va: Some(va),+ vtable_va: None,+ col_va: None,+ kind: "msvc".into(),+ });+ }+ }+ prog.rtti.classes.len()+ }+ GpuStrategyClass::CodeDensity => {+ for &off in hits {+ if let Some(va) = flat_to_va(map, off) {+ prog.analysis.recovered_code.push(DiscoveredRange {+ start: va,+ end: va + 16,+ });+ }+ }+ prog.analysis.recovered_code.len()+ }+ GpuStrategyClass::HashWindow => {+ for (i, &off) in hits.iter().enumerate() {+ if let Some(va) = flat_to_va(map, off) {+ let h = hit_aux.get(i).copied().unwrap_or(0);+ prog.analysis.fid_matches.push(FidMatch {+ entry: va,+ matched_name: format!("fid_{h:08x}"),+ });+ }+ }+ prog.analysis.fid_matches.len()+ }+ GpuStrategyClass::RetEpilogue => {+ for &off in hits {+ if let Some(va) = flat_to_va(map, off) {+ prog.analysis.shared_returns.push(va);+ }+ }+ prog.analysis.shared_returns.len()+ }+ GpuStrategyClass::SpillScan | GpuStrategyClass::StackFrame | GpuStrategyClass::SubRsp => {+ // Annotate existing or seed functions with stack/param markers+ let mut n = 0usize;+ for &off in hits {+ if let Some(va) = flat_to_va(map, off) {+ if let Some(f) = prog+ .analysis+ .functions+ .iter_mut()+ .find(|f| va >= f.entry && (f.end == f.entry || va < f.end + 0x1000))+ {+ f.stack_locals.push(format!("spill_{va:x}"));+ n += 1;+ } else {+ prog.analysis.functions.push(FunctionInfo {+ entry: va,+ end: va,+ name: format!("FUN_{va:016x}"),+ calling_convention: None,+ noreturn: false,+ varargs: false,+ parameters: Vec::new(),+ stack_locals: vec![format!("frame_{va:x}")],+ });+ n += 1;+ }+ }+ }+ n+ }+ GpuStrategyClass::CstrMulti => {+ let needles = needles_for(name);+ for &off in hits {+ if let Some(va) = flat_to_va(map, off) {+ let label = needles+ .iter()+ .find(|n| {+ let o = off as usize;+ o + n.len() <= hay.len() && &hay[o..o + n.len()] == **n+ })+ .and_then(|n| std::str::from_utf8(n).ok())+ .unwrap_or("cstr");+ match name {+ "Call-Fixup Installer" => {+ prog.analysis.call_fixups.push(CallFixupInfo {+ call_va: va,+ fixup_name: label.into(),+ });+ }+ "Demangler Microsoft" => {+ prog.analysis.symbols.push(SymbolInfo {+ va,+ name: label.into(),+ demangled: Some(label.into()),+ });+ }+ "Non-Returning Functions - Discovered" => {+ prog.analysis.functions.push(FunctionInfo {+ entry: va,+ end: va,+ name: label.into(),+ calling_convention: None,+ noreturn: true,+ varargs: false,+ parameters: Vec::new(),+ stack_locals: Vec::new(),+ });+ }+ "PDB MSDIA" | "PDB Universal" => {+ prog.analysis.pdb_symbols.push(SymbolInfo {+ va,+ name: label.into(),+ demangled: None,+ });+ }+ "Variadic Function Signature Override" => {+ prog.analysis.functions.push(FunctionInfo {+ entry: va,+ end: va,+ name: label.into(),+ calling_convention: None,+ noreturn: false,+ varargs: true,+ parameters: Vec::new(),+ stack_locals: Vec::new(),+ });+ }+ "Windows x86 Propagate External Parameters" => {+ prog.analysis.symbols.push(SymbolInfo {+ va,+ name: label.into(),+ demangled: None,+ });+ }+ _ => {+ prog.analysis.symbols.push(SymbolInfo {+ va,+ name: label.into(),+ demangled: None,+ });+ }+ }+ }+ }+ match name {+ "Call-Fixup Installer" => prog.analysis.call_fixups.len(),+ "PDB MSDIA" | "PDB Universal" => prog.analysis.pdb_symbols.len(),+ "Non-Returning Functions - Discovered"+ | "Variadic Function Signature Override" => prog+ .analysis+ .functions+ .iter()+ .filter(|f| f.noreturn || f.varargs)+ .count(),+ _ => prog.analysis.symbols.len(),+ }+ }+ GpuStrategyClass::DecompMultipass => 0,+ }+}++fn is_print(b: u8) -> bool {+ (0x20..=0x7e).contains(&b) || b == b'\t'+}++fn media_kind(hay: &[u8], i: usize) -> String {+ if i + 4 <= hay.len() && &hay[i..i + 4] == b"\x89PNG" {+ "png".into()+ } else if i + 3 <= hay.len() && hay[i] == 0xff && hay[i + 1] == 0xd8 {+ "jpeg".into()+ } else if i + 3 <= hay.len() && &hay[i..i + 3] == b"GIF" {+ "gif".into()+ } else if i + 4 <= hay.len() && &hay[i..i + 4] == b"RIFF" {+ "riff".into()+ } else {+ "media".into()+ }+}++fn read_cstr(hay: &[u8], off: usize) -> String {+ let mut end = off;+ while end < hay.len() && hay[end] != 0 && end - off < 128 {+ end += 1;+ }+ String::from_utf8_lossy(&hay[off..end]).into_owned()+}++/// Exact seed equality: same total count; if both under cap, same multiset of offsets.+pub fn seeds_equal(cpu_hits: &[u32], gpu_total: usize, gpu_hits: &[u32]) -> bool {+ if cpu_hits.len() != gpu_total {+ return false;+ }+ if gpu_total > MAX_HITS as usize {+ // Buffer capped — count match only+ return true;+ }+ let mut a = cpu_hits.to_vec();+ let mut b = gpu_hits.to_vec();+ a.sort_unstable();+ b.sort_unstable();+ a == b+}++pub fn run_gpu_for_analyzer(+ prog: &Program,+ name: &str,+ strategy: GpuStrategyClass,+ large_min: Option<usize>,+) -> GpuAnalyzerRun {+ let (mut hay, map) = if uses_exec(strategy) {+ flatten_exec(prog)+ } else {+ flatten_image(prog)+ };+ if let Some(min) = large_min {+ hay = pad_large(hay, min);+ }+ let image_base = prog.image_base;+ let image_end = prog+ .blocks+ .iter()+ .map(|b| b.va + b.size)+ .max()+ .unwrap_or(image_base.saturating_add(hay.len() as u64));++ if strategy == GpuStrategyClass::CstrMulti {+ let mut all_hits = Vec::new();+ let mut timing = GpuPhaseTiming::default();+ let mut backend = String::new();+ let mut device = String::new();+ let mut note = String::from("multi-needle: ");+ for n in needles_for(name) {+ let r = run_kernel(&hay, KernelKind::Cstr, Some(n), image_base, image_end);+ all_hits.extend(r.hits.iter().copied());+ timing.pcie_upload_ms += r.timing.pcie_upload_ms;+ timing.device_ms += r.timing.device_ms;+ timing.pcie_download_ms += r.timing.pcie_download_ms;+ timing.wall_ms += r.timing.wall_ms;+ timing.setup_ms += r.timing.setup_ms;+ backend = r.backend;+ device = r.device;+ note.push_str(&format!(+ "{}=>{};",+ std::str::from_utf8(n).unwrap_or("?"),+ r.total_hits+ ));+ }+ all_hits.sort_unstable();+ all_hits.dedup();+ let primary = all_hits.len();+ let mut prog_m = prog.clone();+ let merged = merge_seeds_into_program(+ &mut prog_m,+ name,+ strategy,+ &all_hits,+ &[],+ &map,+ &hay,+ );+ return GpuAnalyzerRun {+ primary,+ merged_primary: merged,+ timing,+ backend,+ device,+ note,+ hits: all_hits,+ hit_aux: Vec::new(),+ };+ }++ let kind = kernel_for(strategy);+ let r = run_kernel(&hay, kind, None, image_base, image_end);+ let mut prog_m = prog.clone();+ let merged = merge_seeds_into_program(+ &mut prog_m,+ name,+ strategy,+ &r.hits,+ &r.hit_aux,+ &map,+ &hay,+ );+ GpuAnalyzerRun {+ primary: r.total_hits,+ merged_primary: merged,+ timing: r.timing,+ backend: r.backend,+ device: r.device,+ note: format!("{} | {} | merged={}", strategy.as_str(), r.note, merged),+ hits: r.hits,+ hit_aux: r.hit_aux,+ }+}++/// CPU seed oracle on the same haystack the GPU uses (honest equality baseline).+pub fn cpu_seed_count(+ prog: &Program,+ name: &str,+ strategy: GpuStrategyClass,+ large_min: Option<usize>,+) -> (usize, Vec<u32>, f64) {+ let (mut hay, _) = if uses_exec(strategy) {+ flatten_exec(prog)+ } else {+ flatten_image(prog)+ };+ if let Some(min) = large_min {+ hay = pad_large(hay, min);+ }+ let image_base = prog.image_base;+ let image_end = prog+ .blocks+ .iter()+ .map(|b| b.va + b.size)+ .max()+ .unwrap_or(image_base.saturating_add(hay.len() as u64));++ let t0 = Instant::now();+ if strategy == GpuStrategyClass::CstrMulti {+ let mut all = Vec::new();+ for n in needles_for(name) {+ let (h, _) = cpu_emulate_kernel(&hay, KernelKind::Cstr, Some(n), image_base, image_end);+ all.extend(h);+ }+ all.sort_unstable();+ all.dedup();+ let ms = t0.elapsed().as_secs_f64() * 1000.0;+ let n = all.len();+ return (n, all, ms);+ }+ let kind = kernel_for(strategy);+ let (hits, _) = cpu_emulate_kernel(&hay, kind, None, image_base, image_end);+ let ms = t0.elapsed().as_secs_f64() * 1000.0;+ let n = hits.len();+ (n, hits, ms)+}++/// Structure-seed row (prologue+ret). Full VRAM multipass is a separate CLI row.+pub fn bench_decompile(prog: &Program) -> super::AnalyzerBenchRow {+ let (hay, _) = flatten_exec(prog);+ let base = prog.image_base;+ let end = base + hay.len() as u64;+ let t_cpu = Instant::now();+ let (cpu_p, _) = cpu_emulate_kernel(&hay, KernelKind::Prologue, None, base, end);+ let (cpu_r, _) = cpu_emulate_kernel(&hay, KernelKind::Ret, None, base, end);+ let cpu_ms = t_cpu.elapsed().as_secs_f64() * 1000.0;+ let gpu = run_kernel(&hay, KernelKind::Prologue, None, base, end);+ let gpu2 = run_kernel(&hay, KernelKind::Ret, None, base, end);+ let cpu_primary = cpu_p.len() + cpu_r.len();+ let gpu_primary = gpu.total_hits + gpu2.total_hits;+ let equal = cpu_p.len() == gpu.total_hits && cpu_r.len() == gpu2.total_hits;+ super::AnalyzerBenchRow {+ name: "GPU Decompile structure seeds".into(),+ strategy: "decomp_structure_seeds".into(),+ cpu_ms,+ cpu_primary,+ gpu_pcie_upload_ms: gpu.timing.pcie_upload_ms + gpu2.timing.pcie_upload_ms,+ gpu_device_ms: gpu.timing.device_ms + gpu2.timing.device_ms,+ gpu_pcie_download_ms: gpu.timing.pcie_download_ms + gpu2.timing.pcie_download_ms,+ gpu_pcie_ms: gpu.timing.pcie_upload_ms+ + gpu.timing.pcie_download_ms+ + gpu2.timing.pcie_upload_ms+ + gpu2.timing.pcie_download_ms,+ gpu_wall_ms: gpu.timing.wall_ms + gpu2.timing.wall_ms,+ gpu_primary,+ equal,+ backend: gpu.backend,+ device: gpu.device,+ note: "prologue+ret structure seeds; VRAM multipass via gpu-decompile / analyzer-bench row"+ .into(),+ analyzer_oracle: 0,+ merged_primary: 0,+ }+}diff --git a/crates/ghidrust-core/src/lib.rs b/crates/ghidrust-core/src/lib.rsnew file mode 100644index 0000000..4ff5692--- /dev/null+++ b/crates/ghidrust-core/src/lib.rs@@ -0,0 +1,147 @@+//! Ghidrust analysis core — program model, PE/ELF, x86-64, RTTI, analyzer registry.++pub mod analyzers;+pub mod bulk_scan;+pub mod gpu_analyzers;+pub mod disasm;+pub mod elf;+pub mod error;+pub mod pe;+pub mod program;+pub mod project;+pub mod rtti;+pub mod theme;++pub use analyzers::{+ analyzer_catalog, run_analyzers, run_analyzers_opts, scan_ascii_strings, AnalysisRunReport,+ AnalyzerInfo, AnalyzerOutput, AnalyzerStatus, FoundString, ANALYZER_NAMES,+};+pub use bulk_scan::{+ preferred_bulk_mode, scan_ascii_strings_bulk, scan_pattern_parallel, scan_pattern_seq,+ scan_printable_runs, scan_printable_runs_gpu_or_fallback, scan_printable_runs_parallel,+ scan_printable_runs_seq, set_preferred_bulk_mode, time_bulk_printable, BulkBackend, BulkHit,+ BulkScanMode, BulkTimingReport, GpuScanReport,+};+pub use gpu_analyzers::{+ bench_all_analyzers, bench_analyzer, bench_gpu_decompile_row, flatten_image, format_matrix_table,+ gpu_enrich_analyzers, merge_seeds_into_program, pad_large, seeds_equal, strategy_matrix,+ AnalyzerBenchRow, GpuStrategyClass,+};+pub use disasm::{disassemble_at, disassemble_range, Instruction};+pub use error::{Error, Result};+pub use program::{+ AddressTableInfo, AnalysisState, CallFixupInfo, DiscoveredRange, FidMatch, FunctionInfo,+ MediaHit, MemoryBlock, Program, ReferenceInfo, ResourceInfo, SectionInfo, SwitchInfo,+ SymbolInfo,+};+pub use project::{+ AnalysisSummary, Project, ProjectFileEntry, ProjectMeta, ProjectTreeModel, ProjectTreeRow,+ SavedAnalysis, PROJECT_FILE,+};+pub use rtti::{recover_rtti, RttiClass, RttiReport};+pub use theme::{m3_tokens, ThemeMode, M3Tokens};++use std::path::{Path, PathBuf};++/// Load a PE or ELF image from bytes (magic-detected).+pub fn load_bytes(data: &[u8], name: impl Into<String>) -> Result<Program> {+ if pe::is_pe(data) {+ pe::load_pe(data, name)+ } else if elf::is_elf(data) {+ elf::load_elf(data, name)+ } else {+ Err(Error::UnsupportedFormat(+ "not a PE or ELF image (bad magic)".into(),+ ))+ }+}++/// Load from a filesystem path.+pub fn load_path(path: impl AsRef<Path>) -> Result<Program> {+ let path = path.as_ref();+ let data = std::fs::read(path).map_err(|e| Error::Io(e.to_string()))?;+ let name = path+ .file_name()+ .map(|s| s.to_string_lossy().into_owned())+ .unwrap_or_else(|| "image".into());+ load_bytes(&data, name)+}++/// Run load + disasm slice + default analyzers.+pub fn analyze_path(path: impl AsRef<Path>) -> Result<AnalysisBundle> {+ let mut prog = load_path(path)?;+ let entry = prog.entry.unwrap_or(prog.image_base);+ let listing = disassemble_range(&prog, entry, 32)?;+ let analysis = run_analyzers(&mut prog, &[])?;+ let rtti = analysis+ .results+ .iter()+ .find_map(|r| r.rtti.clone())+ .unwrap_or_else(|| prog.rtti.clone());+ prog.rtti = rtti.clone();+ Ok(AnalysisBundle {+ program: prog,+ listing,+ rtti,+ analysis,+ })+}++#[derive(Debug, Clone, serde::Serialize)]+pub struct AnalysisBundle {+ pub program: Program,+ pub listing: Vec<Instruction>,+ pub rtti: RttiReport,+ pub analysis: AnalysisRunReport,+}++/// Resolve path to committed fixtures (workspace `fixtures/`).+pub fn fixture_path(name: &str) -> PathBuf {+ let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));+ p.pop();+ p.pop();+ p.push("fixtures");+ p.push(name);+ p+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn load_pe_fixture_sections_and_bytes() {+ let path = fixture_path("tiny_x64.pe");+ let prog = load_path(&path).expect("load pe");+ assert_eq!(prog.format, "PE32+");+ assert_eq!(prog.image_base, 0x140000000);+ assert_eq!(prog.entry, Some(0x140001000));+ let bytes = prog.read_va(0x140001000, 8).expect("code bytes");+ assert_eq!(bytes, vec![0x55, 0x48, 0x89, 0xE5, 0x31, 0xC0, 0x5D, 0xC3]);+ }++ #[test]+ fn disassemble_pe_entry_matches_ground_truth() {+ let prog = load_path(fixture_path("tiny_x64.pe")).unwrap();+ let listing = disassemble_range(&prog, prog.entry.unwrap(), 8).unwrap();+ assert!(listing.len() >= 5);+ assert_eq!(listing[0].mnemonic, "push");+ assert_eq!(listing[4].mnemonic, "ret");+ }++ #[test]+ fn rtti_recovers_widget() {+ let prog = load_path(fixture_path("tiny_x64.pe")).unwrap();+ let report = recover_rtti(&prog).unwrap();+ assert!(report.classes.iter().any(|c| c.name == "Widget"));+ }++ #[test]+ fn analyze_path_bundle_all_default_ok() {+ let b = analyze_path(fixture_path("tiny_x64.pe")).unwrap();+ assert!(!b.listing.is_empty());+ for r in &b.analysis.results {+ assert_eq!(r.status, "ok", "{}", r.name);+ }+ }+}diff --git a/crates/ghidrust-core/src/pe.rs b/crates/ghidrust-core/src/pe.rsnew file mode 100644index 0000000..db02057--- /dev/null+++ b/crates/ghidrust-core/src/pe.rs@@ -0,0 +1,119 @@+//! Minimal PE32 / PE32+ loader (hand-rolled).++use crate::error::{Error, Result};+use crate::program::{MemoryBlock, Program, SectionInfo};++pub fn is_pe(data: &[u8]) -> bool {+ if data.len() < 0x40 || &data[0..2] != b"MZ" {+ return false;+ }+ let e_lfanew = u32::from_le_bytes(data[0x3C..0x40].try_into().unwrap()) as usize;+ e_lfanew + 4 <= data.len() && &data[e_lfanew..e_lfanew + 4] == b"PE\0\0"+}++fn rdu16(data: &[u8], off: usize) -> Result<u16> {+ if off + 2 > data.len() {+ return Err(Error::Parse("pe trunc u16".into()));+ }+ Ok(u16::from_le_bytes(data[off..off + 2].try_into().unwrap()))+}++fn rdu32(data: &[u8], off: usize) -> Result<u32> {+ if off + 4 > data.len() {+ return Err(Error::Parse("pe trunc u32".into()));+ }+ Ok(u32::from_le_bytes(data[off..off + 4].try_into().unwrap()))+}++fn rdu64(data: &[u8], off: usize) -> Result<u64> {+ if off + 8 > data.len() {+ return Err(Error::Parse("pe trunc u64".into()));+ }+ Ok(u64::from_le_bytes(data[off..off + 8].try_into().unwrap()))+}++pub fn load_pe(data: &[u8], name: impl Into<String>) -> Result<Program> {+ if !is_pe(data) {+ return Err(Error::UnsupportedFormat("not PE".into()));+ }+ let e_lfanew = rdu32(data, 0x3C)? as usize;+ let coff = e_lfanew + 4;+ let num_sections = rdu16(data, coff + 2)? as usize;+ let opt_size = rdu16(data, coff + 16)? as usize;+ let opt = coff + 20;+ if opt + opt_size > data.len() {+ return Err(Error::Parse("optional header OOB".into()));+ }+ let magic = rdu16(data, opt)?;+ let (image_base, entry_rva, is_pe32plus) = match magic {+ 0x10b => {+ // PE32+ let entry = rdu32(data, opt + 16)? as u64;+ let base = rdu32(data, opt + 28)? as u64;+ (base, entry, false)+ }+ 0x20b => {+ // PE32++ let entry = rdu32(data, opt + 16)? as u64;+ let base = rdu64(data, opt + 24)?;+ (base, entry, true)+ }+ _ => return Err(Error::Parse(format!("unknown optional magic {magic:#x}"))),+ };++ let sec_table = opt + opt_size;+ let mut prog = Program::new(name.into(), if is_pe32plus { "PE32+" } else { "PE32" });+ prog.image_base = image_base;+ prog.entry = Some(image_base.wrapping_add(entry_rva));+ prog.file_bytes = data.to_vec();++ for i in 0..num_sections {+ let off = sec_table + i * 40;+ if off + 40 > data.len() {+ return Err(Error::Parse("section header OOB".into()));+ }+ let raw_name = &data[off..off + 8];+ let name_end = raw_name.iter().position(|&b| b == 0).unwrap_or(8);+ let sec_name = String::from_utf8_lossy(&raw_name[..name_end]).into_owned();+ let virt_size = rdu32(data, off + 8)? as u64;+ let va_rva = rdu32(data, off + 12)? as u64;+ let raw_size = rdu32(data, off + 16)? as u64;+ let file_off = rdu32(data, off + 20)? as u64;+ let chars = rdu32(data, off + 36)?;++ let va = image_base.wrapping_add(va_rva);+ let copy_len = raw_size.min(virt_size.max(raw_size)) as usize;+ let mut bytes = vec![0u8; virt_size.max(raw_size) as usize];+ if file_off as usize + copy_len.min(raw_size as usize) <= data.len() && raw_size > 0 {+ let src_len = (raw_size as usize).min(data.len().saturating_sub(file_off as usize));+ let dst_len = src_len.min(bytes.len());+ bytes[..dst_len].copy_from_slice(&data[file_off as usize..file_off as usize + dst_len]);+ }++ let executable = chars & 0x2000_0000 != 0;+ let readable = chars & 0x4000_0000 != 0;+ let writable = chars & 0x8000_0000 != 0;++ prog.sections.push(SectionInfo {+ name: sec_name.clone(),+ va,+ virtual_size: virt_size,+ raw_size,+ file_offset: file_off,+ characteristics: chars,+ });+ prog.blocks.push(MemoryBlock {+ name: sec_name,+ va,+ size: bytes.len() as u64,+ bytes,+ readable: readable || executable,+ writable,+ executable,+ });+ }++ Ok(prog)+}++diff --git a/crates/ghidrust-core/src/program.rs b/crates/ghidrust-core/src/program.rsnew file mode 100644index 0000000..82181a2--- /dev/null+++ b/crates/ghidrust-core/src/program.rs@@ -0,0 +1,199 @@+use crate::rtti::RttiReport;+use serde::{Deserialize, Serialize};++/// One mapped memory region (section/segment) with raw bytes.+#[derive(Debug, Clone, Serialize)]+pub struct MemoryBlock {+ pub name: String,+ pub va: u64,+ pub size: u64,+ pub bytes: Vec<u8>,+ pub readable: bool,+ pub writable: bool,+ pub executable: bool,+}++/// Section metadata (subset of loader view).+#[derive(Debug, Clone, Serialize)]+pub struct SectionInfo {+ pub name: String,+ pub va: u64,+ pub virtual_size: u64,+ pub raw_size: u64,+ pub file_offset: u64,+ pub characteristics: u32,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct FunctionInfo {+ pub entry: u64,+ pub end: u64,+ pub name: String,+ pub calling_convention: Option<String>,+ pub noreturn: bool,+ pub varargs: bool,+ /// Recovered parameters: name + storage description.+ pub parameters: Vec<String>,+ /// Stack locals as "offset:size" or name.+ pub stack_locals: Vec<String>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct SymbolInfo {+ pub va: u64,+ pub name: String,+ pub demangled: Option<String>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct ReferenceInfo {+ pub from: u64,+ pub to: u64,+ pub kind: String,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct AddressTableInfo {+ pub base: u64,+ pub count: usize,+ pub entries: Vec<u64>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct CallFixupInfo {+ pub call_va: u64,+ pub fixup_name: String,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct MediaHit {+ pub va: u64,+ pub kind: String,+ pub length: usize,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct FidMatch {+ pub entry: u64,+ pub matched_name: String,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct ResourceInfo {+ pub type_id: u32,+ pub name: String,+ pub va: u64,+ pub size: u64,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct SwitchInfo {+ pub jump_va: u64,+ pub cases: Vec<(i64, u64)>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct DiscoveredRange {+ pub start: u64,+ pub end: u64,+}++/// Analysis-side state attached to a loaded program (mutated by analyzers).+#[derive(Debug, Clone, Default, Serialize, Deserialize)]+pub struct AnalysisState {+ pub functions: Vec<FunctionInfo>,+ pub symbols: Vec<SymbolInfo>,+ pub references: Vec<ReferenceInfo>,+ pub address_tables: Vec<AddressTableInfo>,+ pub call_fixups: Vec<CallFixupInfo>,+ pub media: Vec<MediaHit>,+ pub fid_matches: Vec<FidMatch>,+ pub resources: Vec<ResourceInfo>,+ pub switches: Vec<SwitchInfo>,+ pub recovered_code: Vec<DiscoveredRange>,+ pub shared_returns: Vec<u64>,+ pub pdb_symbols: Vec<SymbolInfo>,+}++/// Loaded program model shared by disasm, RTTI, CLI, MCP, GUI.+#[derive(Debug, Clone, Serialize)]+pub struct Program {+ pub name: String,+ pub format: String,+ pub image_base: u64,+ pub entry: Option<u64>,+ pub sections: Vec<SectionInfo>,+ pub blocks: Vec<MemoryBlock>,+ /// Original file bytes (for file-offset relative structures).+ #[serde(skip)]+ pub file_bytes: Vec<u8>,+ pub rtti: RttiReport,+ pub analysis: AnalysisState,+}++impl Program {+ pub fn new(name: String, format: &str) -> Self {+ Self {+ name,+ format: format.into(),+ image_base: 0,+ entry: None,+ sections: Vec::new(),+ blocks: Vec::new(),+ file_bytes: Vec::new(),+ rtti: RttiReport::default(),+ analysis: AnalysisState::default(),+ }+ }++ /// Read up to `len` bytes at virtual address `va`.+ pub fn read_va(&self, va: u64, len: usize) -> Option<Vec<u8>> {+ for b in &self.blocks {+ if va >= b.va && va < b.va.saturating_add(b.size) {+ let off = (va - b.va) as usize;+ if off >= b.bytes.len() {+ return None;+ }+ let end = (off + len).min(b.bytes.len());+ return Some(b.bytes[off..end].to_vec());+ }+ }+ None+ }++ pub fn byte_at(&self, va: u64) -> Option<u8> {+ self.read_va(va, 1).and_then(|v| v.first().copied())+ }++ /// Translate VA → file offset when the VA lands in a known section.+ pub fn va_to_file_offset(&self, va: u64) -> Option<u64> {+ for s in &self.sections {+ let end = s.va.saturating_add(s.virtual_size.max(s.raw_size));+ if va >= s.va && va < end {+ let delta = va - s.va;+ if delta < s.raw_size {+ return Some(s.file_offset + delta);+ }+ }+ }+ None+ }++ pub fn contains_va(&self, va: u64) -> bool {+ self.blocks+ .iter()+ .any(|b| va >= b.va && va < b.va.saturating_add(b.size))+ }++ pub fn exec_blocks(&self) -> impl Iterator<Item = &MemoryBlock> {+ self.blocks.iter().filter(|b| b.executable)+ }++ pub fn function_at(&self, entry: u64) -> Option<&FunctionInfo> {+ self.analysis.functions.iter().find(|f| f.entry == entry)+ }++ pub fn function_at_mut(&mut self, entry: u64) -> Option<&mut FunctionInfo> {+ self.analysis.functions.iter_mut().find(|f| f.entry == entry)+ }+}diff --git a/crates/ghidrust-core/src/project.rs b/crates/ghidrust-core/src/project.rsnew file mode 100644index 0000000..4a826f0--- /dev/null+++ b/crates/ghidrust-core/src/project.rs@@ -0,0 +1,641 @@+//! On-disk Ghidrust projects: create, open, import binaries, save analysis results.++use crate::disasm::{disassemble_range, Instruction};+use crate::error::{Error, Result};+use crate::program::{AnalysisState, Program};+use crate::rtti::RttiReport;+use crate::{load_path, run_analyzers_opts};+use serde::{Deserialize, Serialize};+use std::fs;+use std::path::{Path, PathBuf};++pub const PROJECT_FILE: &str = "ghidrust.project.json";++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct ProjectFileEntry {+ pub id: String,+ pub display_name: String,+ /// Path relative to project root (under `imports/`).+ pub imported_rel: String,+ pub original_path: String,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct ProjectMeta {+ pub name: String,+ pub version: u32,+ pub files: Vec<ProjectFileEntry>,+ pub active_id: Option<String>,+}++/// Open project handle (in-memory + root path).+#[derive(Debug, Clone)]+pub struct Project {+ pub root: PathBuf,+ pub meta: ProjectMeta,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+pub struct SavedAnalysis {+ pub program_name: String,+ pub format: String,+ pub image_base: u64,+ pub entry: Option<u64>,+ pub analysis: AnalysisState,+ pub rtti: RttiReport,+ pub listing: Vec<Instruction>,+ pub saved_analyzers: Vec<String>,+}++/// Tiny sidecar for instant UI tree/overview without loading full RTTI (often 100MB+ JSON).+#[derive(Debug, Clone, Serialize, Deserialize, Default)]+pub struct AnalysisSummary {+ pub program_name: String,+ pub format: String,+ pub image_base: u64,+ pub entry: Option<u64>,+ pub function_count: usize,+ pub rtti_count: usize,+ pub listing_lines: usize,+ pub saved_analyzers: Vec<String>,+}++impl AnalysisSummary {+ pub fn from_saved(s: &SavedAnalysis) -> Self {+ Self {+ program_name: s.program_name.clone(),+ format: s.format.clone(),+ image_base: s.image_base,+ entry: s.entry,+ function_count: s.analysis.functions.len(),+ rtti_count: s.rtti.classes.len(),+ listing_lines: s.listing.len(),+ saved_analyzers: s.saved_analyzers.clone(),+ }+ }+}++impl Project {+ pub fn project_json_path(&self) -> PathBuf {+ self.root.join(PROJECT_FILE)+ }++ pub fn imports_dir(&self) -> PathBuf {+ self.root.join("imports")+ }++ pub fn results_dir(&self) -> PathBuf {+ self.root.join("results")+ }++ /// Create a new project directory and write empty metadata.+ pub fn create(root: impl AsRef<Path>, name: impl Into<String>) -> Result<Self> {+ let root = root.as_ref().to_path_buf();+ fs::create_dir_all(root.join("imports")).map_err(|e| Error::Io(e.to_string()))?;+ fs::create_dir_all(root.join("results")).map_err(|e| Error::Io(e.to_string()))?;+ fs::create_dir_all(root.join("exports")).map_err(|e| Error::Io(e.to_string()))?;+ let proj = Self {+ root,+ meta: ProjectMeta {+ name: name.into(),+ version: 1,+ files: Vec::new(),+ active_id: None,+ },+ };+ proj.save_meta()?;+ Ok(proj)+ }++ /// Open an existing project (directory containing ghidrust.project.json, or the json path).+ pub fn open(path: impl AsRef<Path>) -> Result<Self> {+ let path = path.as_ref();+ let (root, json_path) = if path.is_file() {+ (+ path.parent()+ .ok_or_else(|| Error::Io("project path has no parent".into()))?+ .to_path_buf(),+ path.to_path_buf(),+ )+ } else {+ (path.to_path_buf(), path.join(PROJECT_FILE))+ };+ let data = fs::read_to_string(&json_path).map_err(|e| {+ Error::Io(format!("open project {}: {e}", json_path.display()))+ })?;+ let meta: ProjectMeta =+ serde_json::from_str(&data).map_err(|e| Error::Parse(format!("project json: {e}")))?;+ Ok(Self { root, meta })+ }++ pub fn save_meta(&self) -> Result<()> {+ let json = serde_json::to_string_pretty(&self.meta)+ .map_err(|e| Error::Parse(format!("serialize project: {e}")))?;+ fs::write(self.project_json_path(), json).map_err(|e| Error::Io(e.to_string()))?;+ Ok(())+ }++ /// Copy binary into `imports/` and register it.+ pub fn import_file(&mut self, src: impl AsRef<Path>) -> Result<ProjectFileEntry> {+ let src = src.as_ref();+ if !src.is_file() {+ return Err(Error::Io(format!("not a file: {}", src.display())));+ }+ let display = src+ .file_name()+ .map(|s| s.to_string_lossy().into_owned())+ .unwrap_or_else(|| "binary".into());+ let id = unique_id(&display, &self.meta.files);+ let dest_name = format!("{id}_{display}");+ let dest = self.imports_dir().join(&dest_name);+ fs::create_dir_all(self.imports_dir()).map_err(|e| Error::Io(e.to_string()))?;+ fs::copy(src, &dest).map_err(|e| Error::Io(format!("import copy: {e}")))?;+ let entry = ProjectFileEntry {+ id: id.clone(),+ display_name: display,+ imported_rel: format!("imports/{dest_name}"),+ original_path: src.display().to_string(),+ };+ self.meta.files.push(entry.clone());+ self.meta.active_id = Some(id);+ self.save_meta()?;+ Ok(entry)+ }++ pub fn set_active(&mut self, id: &str) -> Result<()> {+ if !self.meta.files.iter().any(|f| f.id == id) {+ return Err(Error::Parse(format!("unknown file id: {id}")));+ }+ self.meta.active_id = Some(id.into());+ self.save_meta()?;+ Ok(())+ }++ /// Remove a file from the project: meta entry, import copy, results, exports.+ pub fn remove_file(&mut self, id: &str) -> Result<ProjectFileEntry> {+ let idx = self+ .meta+ .files+ .iter()+ .position(|f| f.id == id)+ .ok_or_else(|| Error::Parse(format!("unknown file id: {id}")))?;+ let entry = self.meta.files.remove(idx);+ let bin_file = self.binary_path(&entry);+ if bin_file.is_file() {+ let _ = fs::remove_file(&bin_file);+ }+ let results = self.results_dir().join(&entry.id);+ if results.is_dir() {+ let _ = fs::remove_dir_all(&results);+ }+ for p in [+ self.listing_export_path(&entry.id),+ self.analysis_export_path(&entry.id),+ ] {+ if p.is_file() {+ let _ = fs::remove_file(p);+ }+ }+ if self.meta.active_id.as_deref() == Some(id) {+ self.meta.active_id = self.meta.files.first().map(|f| f.id.clone());+ }+ self.save_meta()?;+ Ok(entry)+ }++ pub fn active_file(&self) -> Option<&ProjectFileEntry> {+ let id = self.meta.active_id.as_ref()?;+ self.meta.files.iter().find(|f| &f.id == id)+ }++ pub fn binary_path(&self, entry: &ProjectFileEntry) -> PathBuf {+ self.root.join(&entry.imported_rel)+ }++ /// Legacy human/debug export (slow for large RTTI). Prefer [`Self::analysis_bin_path`].+ pub fn analysis_path(&self, id: &str) -> PathBuf {+ self.results_dir().join(id).join("analysis.json")+ }++ /// Primary fast persistence (bincode). This is what the UI should load.+ pub fn analysis_bin_path(&self, id: &str) -> PathBuf {+ self.results_dir().join(id).join("analysis.bin")+ }++ /// Tiny JSON counts for tree badges / Overview before full load.+ pub fn analysis_summary_path(&self, id: &str) -> PathBuf {+ self.results_dir().join(id).join("summary.json")+ }++ pub fn listing_export_path(&self, id: &str) -> PathBuf {+ self.root.join("exports").join(format!("{id}_listing.txt"))+ }++ pub fn analysis_export_path(&self, id: &str) -> PathBuf {+ self.root.join("exports").join(format!("{id}_analysis.json"))+ }++ /// Load imported binary into a Program (does not auto-load saved analysis).+ pub fn load_program(&self, entry: &ProjectFileEntry) -> Result<Program> {+ load_path(self.binary_path(entry))+ }++ /// Load program + apply saved analysis state if present.+ pub fn load_program_with_results(&self, entry: &ProjectFileEntry) -> Result<(Program, Option<SavedAnalysis>)> {+ let mut prog = self.load_program(entry)?;+ let saved = self.load_saved_analysis(&entry.id)?;+ if let Some(ref s) = saved {+ prog.analysis = s.analysis.clone();+ prog.rtti = s.rtti.clone();+ }+ Ok((prog, saved))+ }++ pub fn load_saved_analysis(&self, id: &str) -> Result<Option<SavedAnalysis>> {+ // Prefer binary (orders of magnitude faster than multi-100MB pretty JSON).+ let bin = self.analysis_bin_path(id);+ if bin.is_file() {+ let data = fs::read(&bin).map_err(|e| Error::Io(e.to_string()))?;+ let saved: SavedAnalysis = bincode::deserialize(&data)+ .map_err(|e| Error::Parse(format!("analysis bin: {e}")))?;+ return Ok(Some(saved));+ }+ let p = self.analysis_path(id);+ if !p.is_file() {+ return Ok(None);+ }+ // Skip JSON stub markers (large-bin placeholder)+ let data = fs::read_to_string(&p).map_err(|e| Error::Io(e.to_string()))?;+ if data.contains("too large for JSON export") && !self.analysis_bin_path(id).is_file() {+ return Ok(None);+ }+ let saved: SavedAnalysis =+ serde_json::from_str(&data).map_err(|e| Error::Parse(format!("analysis json: {e}")))?;+ // One-time migrate: cache as analysis.bin so next UI open is fast+ if let Ok(bin) = bincode::serialize(&saved) {+ let _ = fs::write(self.analysis_bin_path(id), bin);+ let summary = AnalysisSummary::from_saved(&saved);+ if let Ok(j) = serde_json::to_string_pretty(&summary) {+ let _ = fs::write(self.analysis_summary_path(id), j);+ }+ }+ Ok(Some(saved))+ }++ pub fn load_analysis_summary(&self, id: &str) -> Result<Option<AnalysisSummary>> {+ let p = self.analysis_summary_path(id);+ if p.is_file() {+ let data = fs::read_to_string(&p).map_err(|e| Error::Io(e.to_string()))?;+ let s: AnalysisSummary = serde_json::from_str(&data)+ .map_err(|e| Error::Parse(format!("summary json: {e}")))?;+ return Ok(Some(s));+ }+ // Derive from full save if only legacy JSON/bin exists+ Ok(self+ .load_saved_analysis(id)?+ .map(|s| AnalysisSummary::from_saved(&s)))+ }++ /// Run analyzers on a project file and persist results under `results/<id>/`.+ pub fn analyze_file(+ &self,+ entry: &ProjectFileEntry,+ analyzer_names: &[&str],+ ) -> Result<(Program, SavedAnalysis)> {+ self.analyze_file_opts(entry, analyzer_names, false)+ }++ /// Like [`analyze_file`] with optional GPU bulk + per-analyzer GPU seed enrich.+ pub fn analyze_file_opts(+ &self,+ entry: &ProjectFileEntry,+ analyzer_names: &[&str],+ use_gpu: bool,+ ) -> Result<(Program, SavedAnalysis)> {+ let mut prog = self.load_program(entry)?;+ if let Ok(Some(prev)) = self.load_saved_analysis(&entry.id) {+ if prog.analysis.symbols.is_empty() {+ prog.analysis.symbols = prev.analysis.symbols;+ }+ }+ let _report = run_analyzers_opts(&mut prog, analyzer_names, use_gpu)?;+ let entry_va = prog.entry.unwrap_or(prog.image_base);+ let listing = disassemble_range(&prog, entry_va, 128).unwrap_or_default();+ let saved = SavedAnalysis {+ program_name: prog.name.clone(),+ format: prog.format.clone(),+ image_base: prog.image_base,+ entry: prog.entry,+ analysis: prog.analysis.clone(),+ rtti: prog.rtti.clone(),+ listing,+ saved_analyzers: analyzer_names.iter().map(|s| (*s).to_string()).collect(),+ };+ self.save_analysis(&entry.id, &saved)?;+ Ok((prog, saved))+ }++ pub fn save_analysis(&self, id: &str, saved: &SavedAnalysis) -> Result<()> {+ let dir = self.results_dir().join(id);+ fs::create_dir_all(&dir).map_err(|e| Error::Io(e.to_string()))?;++ // Fast path: bincode (primary for GUI reopen)+ let bin = bincode::serialize(saved)+ .map_err(|e| Error::Parse(format!("serialize analysis bin: {e}")))?;+ fs::write(self.analysis_bin_path(id), &bin).map_err(|e| Error::Io(e.to_string()))?;++ // Tiny summary for tree / instant Overview counts+ let summary = AnalysisSummary::from_saved(saved);+ let sum_json = serde_json::to_string_pretty(&summary)+ .map_err(|e| Error::Parse(format!("serialize summary: {e}")))?;+ fs::write(self.analysis_summary_path(id), sum_json)+ .map_err(|e| Error::Io(e.to_string()))?;++ // Human-readable listing export only (small)+ fs::create_dir_all(self.root.join("exports")).map_err(|e| Error::Io(e.to_string()))?;+ let mut listing_txt = String::new();+ listing_txt.push_str(&format!(+ "# Ghidrust listing — {} ({})\n# entry={:?} base={:#x}\n\n",+ saved.program_name, saved.format, saved.entry, saved.image_base+ ));+ for insn in &saved.listing {+ listing_txt.push_str(&insn.text());+ listing_txt.push('\n');+ }+ fs::write(self.listing_export_path(id), listing_txt)+ .map_err(|e| Error::Io(e.to_string()))?;++ // Compact JSON export for tools (not pretty — pretty 214MB kills UI load)+ // Skip if enormous (>8MB bin) to avoid multi-minute freezes on game-sized RTTI.+ if bin.len() < 8 * 1024 * 1024 {+ let export = serde_json::to_string(saved)+ .map_err(|e| Error::Parse(format!("export analysis: {e}")))?;+ fs::write(self.analysis_export_path(id), &export)+ .map_err(|e| Error::Io(e.to_string()))?;+ fs::write(self.analysis_path(id), &export).map_err(|e| Error::Io(e.to_string()))?;+ } else {+ // Marker so agents know JSON was skipped; full data is in analysis.bin+ let note = serde_json::json!({+ "note": "full analysis in analysis.bin (too large for JSON export)",+ "summary": summary,+ "bin_bytes": bin.len(),+ });+ fs::write(+ self.analysis_path(id),+ serde_json::to_string_pretty(¬e).unwrap_or_default(),+ )+ .map_err(|e| Error::Io(e.to_string()))?;+ }+ Ok(())+ }++ /// Save current in-memory program analysis for a project file id.+ pub fn save_program_results(+ &self,+ id: &str,+ prog: &Program,+ listing: &[Instruction],+ analyzers_run: &[String],+ ) -> Result<SavedAnalysis> {+ let saved = SavedAnalysis {+ program_name: prog.name.clone(),+ format: prog.format.clone(),+ image_base: prog.image_base,+ entry: prog.entry,+ analysis: prog.analysis.clone(),+ rtti: prog.rtti.clone(),+ listing: listing.to_vec(),+ saved_analyzers: analyzers_run.to_vec(),+ };+ self.save_analysis(id, &saved)?;+ Ok(saved)+ }++ pub fn list_files(&self) -> &[ProjectFileEntry] {+ &self.meta.files+ }++ /// True when binary or legacy JSON analysis exists on disk.+ pub fn has_saved_analysis(&self, id: &str) -> bool {+ self.analysis_bin_path(id).is_file() || self.analysis_path(id).is_file()+ }++ /// Pure project-tree rows for UI (Ghidra Project Window style: project → files).+ pub fn tree_rows(&self) -> ProjectTreeModel {+ let active = self.meta.active_id.clone();+ let files = self+ .meta+ .files+ .iter()+ .map(|f| ProjectTreeRow {+ id: f.id.clone(),+ display_name: f.display_name.clone(),+ imported_rel: f.imported_rel.clone(),+ active: active.as_deref() == Some(f.id.as_str()),+ has_saved_analysis: self.has_saved_analysis(&f.id),+ })+ .collect();+ ProjectTreeModel {+ project_name: self.meta.name.clone(),+ project_root: self.root.display().to_string(),+ files,+ }+ }+}++/// One binary under a project (tree leaf).+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct ProjectTreeRow {+ pub id: String,+ pub display_name: String,+ pub imported_rel: String,+ pub active: bool,+ pub has_saved_analysis: bool,+}++impl ProjectTreeRow {+ /// Compact status for upgraded UX badges.+ pub fn status_label(&self) -> &'static str {+ if self.has_saved_analysis {+ "Analyzed"+ } else {+ "Not analyzed"+ }+ }+}++/// Hierarchical project tree data: root + file leaves (flat DomainFolder subset).+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+pub struct ProjectTreeModel {+ pub project_name: String,+ pub project_root: String,+ pub files: Vec<ProjectTreeRow>,+}++impl ProjectTreeModel {+ pub fn file_ids(&self) -> Vec<String> {+ self.files.iter().map(|f| f.id.clone()).collect()+ }++ pub fn active_row(&self) -> Option<&ProjectTreeRow> {+ self.files.iter().find(|f| f.active)+ }+}++fn unique_id(display: &str, existing: &[ProjectFileEntry]) -> String {+ let stem: String = display+ .chars()+ .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })+ .collect();+ let stem = if stem.is_empty() {+ "bin".into()+ } else {+ stem+ };+ let mut n = 0u32;+ loop {+ let id = if n == 0 {+ stem.clone()+ } else {+ format!("{stem}_{n}")+ };+ if !existing.iter().any(|f| f.id == id) {+ return id;+ }+ n += 1;+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::fixture_path;++ #[test]+ fn create_import_analyze_reopen() {+ let dir = std::env::temp_dir().join(format!(+ "ghidrust_proj_test_{}",+ std::process::id()+ ));+ let _ = fs::remove_dir_all(&dir);+ let mut proj = Project::create(&dir, "TestProj").unwrap();+ assert!(proj.project_json_path().is_file());++ let pe = fixture_path("analysis_lab.pe");+ let entry = proj.import_file(&pe).unwrap();+ assert_eq!(entry.display_name, "analysis_lab.pe");+ assert!(proj.binary_path(&entry).is_file());++ let tree = proj.tree_rows();+ assert_eq!(tree.project_name, "TestProj");+ assert_eq!(tree.files.len(), 1);+ assert!(tree.files[0].active);+ assert!(!tree.files[0].has_saved_analysis);+ assert_eq!(tree.files[0].status_label(), "Not analyzed");++ let (_prog, saved) = proj+ .analyze_file(+ &entry,+ &[+ "Function Start Search",+ "ASCII Strings",+ "Embedded Media",+ "Demangler Microsoft",+ ],+ )+ .unwrap();+ assert!(!saved.listing.is_empty());+ assert!(proj.has_saved_analysis(&entry.id));+ let tree2 = proj.tree_rows();+ assert!(tree2.files[0].has_saved_analysis);+ assert_eq!(tree2.files[0].status_label(), "Analyzed");++ // Reopen project and load results+ let proj2 = Project::open(&dir).unwrap();+ assert_eq!(proj2.meta.name, "TestProj");+ assert_eq!(proj2.meta.files.len(), 1);+ let e = &proj2.meta.files[0];+ let (prog2, saved2) = proj2.load_program_with_results(e).unwrap();+ assert!(saved2.is_some());+ assert!(!prog2.analysis.functions.is_empty() || !saved2.unwrap().listing.is_empty());++ let _ = fs::remove_dir_all(&dir);+ }++ #[test]+ fn tree_rows_multi_file_active_and_status() {+ let dir = std::env::temp_dir().join(format!(+ "ghidrust_tree_{}",+ std::process::id()+ ));+ let _ = fs::remove_dir_all(&dir);+ let mut proj = Project::create(&dir, "Multi").unwrap();+ let a = proj.import_file(fixture_path("tiny_x64.pe")).unwrap();+ let b = proj.import_file(fixture_path("analysis_lab.pe")).unwrap();+ // last import is active+ let tree = proj.tree_rows();+ assert_eq!(tree.files.len(), 2);+ assert_eq!(tree.file_ids().len(), 2);+ assert!(tree.files.iter().any(|r| r.id == a.id && !r.active));+ assert!(tree.files.iter().any(|r| r.id == b.id && r.active));+ assert!(tree.files.iter().all(|r| !r.has_saved_analysis));++ proj.analyze_file(&a, &["ASCII Strings"]).unwrap();+ let tree2 = proj.tree_rows();+ let row_a = tree2.files.iter().find(|r| r.id == a.id).unwrap();+ let row_b = tree2.files.iter().find(|r| r.id == b.id).unwrap();+ assert!(row_a.has_saved_analysis);+ assert!(!row_b.has_saved_analysis);++ let _ = fs::remove_dir_all(&dir);+ }++ #[test]+ fn remove_file_drops_import_and_results() {+ let dir = std::env::temp_dir().join(format!(+ "ghidrust_rm_{}",+ std::process::id()+ ));+ let _ = fs::remove_dir_all(&dir);+ let mut proj = Project::create(&dir, "Rm").unwrap();+ let a = proj.import_file(fixture_path("tiny_x64.pe")).unwrap();+ let b = proj.import_file(fixture_path("analysis_lab.pe")).unwrap();+ proj.analyze_file(&a, &["ASCII Strings"]).unwrap();+ assert!(proj.binary_path(&a).is_file());+ assert!(proj.has_saved_analysis(&a.id));++ let removed = proj.remove_file(&a.id).unwrap();+ assert_eq!(removed.id, a.id);+ assert!(!proj.binary_path(&a).is_file());+ assert!(!proj.has_saved_analysis(&a.id));+ assert_eq!(proj.meta.files.len(), 1);+ assert_eq!(proj.meta.files[0].id, b.id);+ assert_eq!(proj.meta.active_id.as_deref(), Some(b.id.as_str()));+ assert!(proj.remove_file("nope").is_err());++ let _ = fs::remove_dir_all(&dir);+ }++ #[test]+ fn analysis_bin_roundtrip_faster_path() {+ let dir = std::env::temp_dir().join(format!(+ "ghidrust_bin_{}",+ std::process::id()+ ));+ let _ = fs::remove_dir_all(&dir);+ let mut proj = Project::create(&dir, "Bin").unwrap();+ let a = proj.import_file(fixture_path("tiny_x64.pe")).unwrap();+ let (_p, saved) = proj+ .analyze_file(&a, &["ASCII Strings", "WindowsPE x86 PE RTTI Analyzer"])+ .unwrap();+ assert!(proj.analysis_bin_path(&a.id).is_file());+ assert!(proj.analysis_summary_path(&a.id).is_file());+ let sum = proj.load_analysis_summary(&a.id).unwrap().unwrap();+ assert_eq!(sum.rtti_count, saved.rtti.classes.len());+ let loaded = proj.load_saved_analysis(&a.id).unwrap().unwrap();+ assert_eq!(loaded.rtti.classes.len(), saved.rtti.classes.len());+ // Prefer bin even if json exists+ assert!(proj.has_saved_analysis(&a.id));+ let _ = fs::remove_dir_all(&dir);+ }+}diff --git a/crates/ghidrust-core/src/rtti.rs b/crates/ghidrust-core/src/rtti.rsnew file mode 100644index 0000000..fd97a0d--- /dev/null+++ b/crates/ghidrust-core/src/rtti.rs@@ -0,0 +1,291 @@+//! C++ RTTI recovery (Microsoft-style + string-scan fallback for Itanium-ish names).+//! Hand-rolled structure walk over the loaded program model.++use crate::error::Result;+use crate::program::Program;+use serde::{Deserialize, Serialize};++#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+pub struct RttiClass {+ pub name: String,+ /// VA of type_info / TypeDescriptor+ pub type_info_va: Option<u64>,+ /// VA of vtable (first function pointer slot) when recovered+ pub vtable_va: Option<u64>,+ /// VA of RTTICompleteObjectLocator when present+ pub col_va: Option<u64>,+ pub kind: String,+}++#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+pub struct RttiReport {+ pub classes: Vec<RttiClass>,+ pub notes: Vec<String>,+}++/// Recover RTTI from a loaded program.+pub fn recover_rtti(prog: &Program) -> Result<RttiReport> {+ let mut report = RttiReport::default();++ // 1) Scan for MSVC decorated type names: .?AV...@@ or .?AU...@@+ let msvc_hits = scan_msvc_type_names(prog);+ for (va, name) in &msvc_hits {+ report.classes.push(RttiClass {+ name: demangle_msvc_simple(name),+ type_info_va: Some(*va),+ vtable_va: None,+ col_va: None,+ kind: "msvc_type_descriptor".into(),+ });+ }++ // 2) Link COL → type descriptor → vtable (PE image-relative, 32-bit fields)+ link_msvc_col(prog, &mut report);++ // 3) Itanium-style: _ZTS / _ZTV mangled fragments in rodata+ let itanium = scan_itanium_typeinfo_names(prog);+ for (va, name) in itanium {+ if report.classes.iter().any(|c| c.name == name) {+ continue;+ }+ report.classes.push(RttiClass {+ name,+ type_info_va: Some(va),+ vtable_va: None,+ col_va: None,+ kind: "itanium_typeinfo_name".into(),+ });+ }++ if report.classes.is_empty() {+ report+ .notes+ .push("no RTTI class names recovered".into());+ } else {+ report.notes.push(format!(+ "recovered {} class record(s)",+ report.classes.len()+ ));+ }+ Ok(report)+}++/// MSVC TypeDescriptor name field holds ".?AVFoo@@" etc.+fn scan_msvc_type_names(prog: &Program) -> Vec<(u64, String)> {+ let mut hits = Vec::new();+ for block in &prog.blocks {+ let b = &block.bytes;+ let mut i = 0;+ while i + 4 < b.len() {+ // look for ".?AV" or ".?AU" or ".?AE"+ if b[i] == b'.' && b[i + 1] == b'?' && b[i + 2] == b'A' {+ let tag = b[i + 3];+ if matches!(tag, b'V' | b'U' | b'E') {+ if let Some(s) = read_cstr(b, i) {+ if s.ends_with("@@") && s.len() > 5 && s.len() < 512 {+ hits.push((block.va + i as u64, s));+ i += 4;+ continue;+ }+ }+ }+ }+ i += 1;+ }+ }+ hits+}++fn read_cstr(b: &[u8], off: usize) -> Option<String> {+ if off >= b.len() {+ return None;+ }+ let end = b[off..].iter().position(|&c| c == 0)?;+ if end == 0 || end > 512 {+ return None;+ }+ let raw = &b[off..off + end];+ if !raw.is_ascii() {+ return None;+ }+ Some(String::from_utf8_lossy(raw).into_owned())+}++/// ".?AVMyClass@@" → "MyClass" (simple undname subset)+pub fn demangle_msvc_simple(decorated: &str) -> String {+ let s = decorated+ .strip_prefix(".?AV")+ .or_else(|| decorated.strip_prefix(".?AU"))+ .or_else(|| decorated.strip_prefix(".?AE"))+ .unwrap_or(decorated);+ let s = s.strip_suffix("@@").unwrap_or(s);+ // Nested: may contain @ separators — keep last segment as leaf name if simple+ if s.contains('@') {+ // e.g. Foo@Bar@@ style — for MVP join with :: reverse+ let parts: Vec<&str> = s.split('@').filter(|p| !p.is_empty()).collect();+ if parts.len() > 1 {+ return parts.iter().rev().cloned().collect::<Vec<_>>().join("::");+ }+ }+ s.to_string()+}++/// Walk for Complete Object Locators: signature 1 (x64) or 0 (x86), pTypeDescriptor points at name-4-ish.+fn link_msvc_col(prog: &Program, report: &mut RttiReport) {+ let image_base = prog.image_base;+ // COL layout (x64):+ // u32 signature; u32 offset; u32 cdOffset; u32 pTypeDescriptor (RVA); u32 pClassDescriptor (RVA); u32 pSelf (RVA)+ for block in &prog.blocks {+ let b = &block.bytes;+ if b.len() < 24 {+ continue;+ }+ let mut i = 0;+ while i + 24 <= b.len() {+ let sig = u32::from_le_bytes(b[i..i + 4].try_into().unwrap());+ if sig > 1 {+ i += 4;+ continue;+ }+ let p_td = u32::from_le_bytes(b[i + 12..i + 16].try_into().unwrap()) as u64;+ let p_self = u32::from_le_bytes(b[i + 20..i + 24].try_into().unwrap()) as u64;+ let col_rva = (block.va + i as u64).wrapping_sub(image_base);+ // pSelf should equal COL RVA for x64 COL+ if sig == 1 && p_self != col_rva {+ i += 4;+ continue;+ }+ let td_va = image_base.wrapping_add(p_td);+ // TypeDescriptor: vfptr (8) + spare (8) + name on x64+ if let Some(name_bytes) = prog.read_va(td_va + 16, 64) {+ if name_bytes.starts_with(b".?A") {+ if let Some(decorated) = read_cstr(&name_bytes, 0) {+ let name = demangle_msvc_simple(&decorated);+ let col_va = block.va + i as u64;+ // vtable is often at COL_va + sizeof(COL) aligned, or pointer just after COL reference+ // Heuristic: 8 bytes before a pointer to this COL is start of object; vtable at that ptr+ let vtable_va = find_vtable_for_col(prog, col_va);++ if let Some(cls) = report+ .classes+ .iter_mut()+ .find(|c| c.type_info_va == Some(td_va) || c.name == name)+ {+ cls.col_va = Some(col_va);+ cls.type_info_va = Some(td_va);+ if cls.vtable_va.is_none() {+ cls.vtable_va = vtable_va;+ }+ cls.kind = "msvc_col".into();+ } else {+ report.classes.push(RttiClass {+ name,+ type_info_va: Some(td_va),+ vtable_va,+ col_va: Some(col_va),+ kind: "msvc_col".into(),+ });+ }+ }+ }+ }+ i += 4;+ }+ }+}++fn find_vtable_for_col(prog: &Program, col_va: u64) -> Option<u64> {+ // Search for a pointer-sized value equal to col_va; vtable starts at that address.+ for block in &prog.blocks {+ let b = &block.bytes;+ let mut off = 0;+ while off + 8 <= b.len() {+ let val = u64::from_le_bytes(b[off..off + 8].try_into().unwrap());+ if val == col_va {+ // On MSVC x64, the COL pointer sits at vtable[-1]; first virtfn at this+8?+ // Actually: object.vfptr -> vtable[0] which is first function; COL is at vfptr[-1].+ // So the pointer we found is at address A where *A == col; vtable starts at A+8.+ return Some(block.va + off as u64 + 8);+ }+ off += 8; // align scan+ }+ }+ None+}++fn scan_itanium_typeinfo_names(prog: &Program) -> Vec<(u64, String)> {+ let mut hits = Vec::new();+ for block in &prog.blocks {+ let b = &block.bytes;+ let mut i = 0;+ while i + 4 < b.len() {+ // _ZTS... null-terminated typeinfo name strings+ if b[i] == b'_' && b.get(i + 1) == Some(&b'Z') && b.get(i + 2) == Some(&b'T') && b.get(i + 3) == Some(&b'S')+ {+ if let Some(s) = read_cstr(b, i) {+ if s.len() > 4 && s.len() < 256 {+ let pretty = demangle_itanium_type_name(&s);+ hits.push((block.va + i as u64, pretty));+ }+ }+ }+ i += 1;+ }+ }+ hits+}++/// Minimal _ZTS length-name demangle: _ZTS3Foo → Foo; _ZTSN3Bar3BazE → Bar::Baz (best-effort)+pub fn demangle_itanium_type_name(s: &str) -> String {+ let body = s.strip_prefix("_ZTS").unwrap_or(s);+ parse_itanium_name(body).unwrap_or_else(|| s.to_string())+}++fn parse_itanium_name(mut body: &str) -> Option<String> {+ if body.starts_with('N') {+ body = &body[1..];+ let mut parts = Vec::new();+ while !body.is_empty() && !body.starts_with('E') {+ let (n, rest) = parse_len_id(body)?;+ parts.push(n);+ body = rest;+ }+ if parts.is_empty() {+ return None;+ }+ return Some(parts.join("::"));+ }+ let (n, _) = parse_len_id(body)?;+ Some(n)+}++fn parse_len_id(s: &str) -> Option<(String, &str)> {+ let mut i = 0;+ while i < s.len() && s.as_bytes()[i].is_ascii_digit() {+ i += 1;+ }+ if i == 0 {+ return None;+ }+ let len: usize = s[..i].parse().ok()?;+ if i + len > s.len() {+ return None;+ }+ Some((s[i..i + len].to_string(), &s[i + len..]))+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn demangle_msvc() {+ assert_eq!(demangle_msvc_simple(".?AVWidget@@"), "Widget");+ assert_eq!(demangle_msvc_simple(".?AUPod@@"), "Pod");+ }++ #[test]+ fn demangle_itanium() {+ assert_eq!(demangle_itanium_type_name("_ZTS3Foo"), "Foo");+ }+}diff --git a/crates/ghidrust-core/src/theme.rs b/crates/ghidrust-core/src/theme.rsnew file mode 100644index 0000000..3904120--- /dev/null+++ b/crates/ghidrust-core/src/theme.rs@@ -0,0 +1,74 @@+//! Material 3–inspired color tokens (shared for docs/tests; GUI applies via egui).++use serde::Serialize;++#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]+#[serde(rename_all = "lowercase")]+pub enum ThemeMode {+ Dark,+ Light,+}++impl ThemeMode {+ pub fn toggle(self) -> Self {+ match self {+ ThemeMode::Dark => ThemeMode::Light,+ ThemeMode::Light => ThemeMode::Dark,+ }+ }+}++/// sRGB 0–255 Material 3–inspired tokens.+#[derive(Debug, Clone, Copy, Serialize)]+pub struct M3Tokens {+ pub mode: ThemeMode,+ pub primary: [u8; 3],+ pub on_primary: [u8; 3],+ pub surface: [u8; 3],+ pub surface_container: [u8; 3],+ pub on_surface: [u8; 3],+ pub on_surface_variant: [u8; 3],+ pub outline: [u8; 3],+ pub error: [u8; 3],+}++pub fn m3_tokens(mode: ThemeMode) -> M3Tokens {+ match mode {+ ThemeMode::Dark => M3Tokens {+ mode,+ primary: [0xD0, 0xBC, 0xFF],+ on_primary: [0x38, 0x1E, 0x72],+ surface: [0x14, 0x14, 0x18],+ surface_container: [0x1C, 0x1B, 0x1F],+ on_surface: [0xE6, 0xE1, 0xE5],+ on_surface_variant: [0xCA, 0xC4, 0xD0],+ outline: [0x93, 0x8F, 0x99],+ error: [0xF2, 0xB8, 0xB5],+ },+ ThemeMode::Light => M3Tokens {+ mode,+ primary: [0x67, 0x50, 0xA4],+ on_primary: [0xFF, 0xFF, 0xFF],+ surface: [0xFF, 0xFB, 0xFE],+ surface_container: [0xF3, 0xED, 0xF7],+ on_surface: [0x1C, 0x1B, 0x1F],+ on_surface_variant: [0x49, 0x45, 0x4F],+ outline: [0x79, 0x74, 0x7E],+ error: [0xB3, 0x26, 0x1E],+ },+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn theme_toggle_and_tokens() {+ assert_eq!(ThemeMode::Dark.toggle(), ThemeMode::Light);+ let d = m3_tokens(ThemeMode::Dark);+ let l = m3_tokens(ThemeMode::Light);+ assert_ne!(d.surface, l.surface);+ assert_eq!(d.primary[0], 0xD0);+ }+}diff --git a/crates/ghidrust-core/tests/analyzer_content.rs b/crates/ghidrust-core/tests/analyzer_content.rsnew file mode 100644index 0000000..abdf5ec--- /dev/null+++ b/crates/ghidrust-core/tests/analyzer_content.rs@@ -0,0 +1,312 @@+//! Per-analyzer TDD: each shipped entry on analysis_lab.pe asserts concrete fields.++use ghidrust_core::{fixture_path, load_path, run_analyzers, AnalyzerOutput};++fn lab() -> ghidrust_core::Program {+ load_path(fixture_path("analysis_lab.pe")).expect("fixtures/analysis_lab.pe")+}++fn run(name: &str) -> AnalyzerOutput {+ let mut prog = lab();+ let rep = run_analyzers(&mut prog, &[name]).unwrap();+ assert_eq!(rep.results.len(), 1);+ assert_eq!(rep.results[0].status, "ok", "{}: {}", name, rep.results[0].message);+ rep.results.into_iter().next().unwrap()+}++#[test]+fn ascii_strings_finds_api_and_class_names() {+ let o = run("ASCII Strings");+ let s = o.strings.as_ref().expect("strings field");+ assert!(s.iter().any(|x| x.value.contains("ExitProcess")), "{s:?}");+ assert!(s.iter().any(|x| x.value.contains("printf") || x.value.contains("LabClass") || x.value.contains("MyFunc")), "{s:?}");+}++#[test]+fn function_start_finds_entry_and_lab_functions() {+ let o = run("Function Start Search");+ let fns = o.functions.as_ref().expect("functions");+ assert!(fns.iter().any(|f| f.entry == 0x140001000), "{fns:?}");+ // prologue-based starts+ assert!(+ fns.iter().any(|f| f.entry == 0x140001030 || f.entry == 0x140001018),+ "expected stack/orphan start: {fns:?}"+ );+ // Must NOT create mid-prologue seed at 0x140001034 (sub rsp inside func_stack)+ assert!(+ !fns.iter().any(|f| f.entry == 0x140001034),+ "mid-prologue seed: {fns:?}"+ );+ // No start strictly inside another function body+ for f in fns {+ for g in fns {+ if f.entry != g.entry {+ assert!(+ !(f.entry > g.entry && f.entry < g.end),+ "nested start {:#x} inside {:#x}..{:#x}",+ f.entry,+ g.entry,+ g.end+ );+ }+ }+ }+}++#[test]+fn aggressive_finds_orphan_or_gap_code() {+ let mut prog = lab();+ // Register only entry so orphan at 0x18 is a gap for AIF+ run_analyzers(&mut prog, &["Function Start Search"]).unwrap();+ // Keep only entry function to force gap+ prog.analysis.functions.retain(|f| f.entry == 0x140001000);+ let rep = run_analyzers(&mut prog, &["Aggressive Instruction Finder"]).unwrap();+ let ranges = rep.results[0]+ .recovered_ranges+ .as_ref()+ .expect("recovered_ranges");+ assert!(+ ranges.iter().any(|r| r.start == 0x140001018 || r.start == 0x140001030),+ "expected gap recovery: {ranges:?}"+ );+}++#[test]+fn call_convention_tags_entry() {+ let mut prog = lab();+ run_analyzers(&mut prog, &["Function Start Search"]).unwrap();+ let rep = run_analyzers(&mut prog, &["Call Convention ID"]).unwrap();+ let c = rep.results[0].conventions.as_ref().expect("conventions");+ assert!(c.iter().any(|(va, name)| *va == 0x140001000 && !name.is_empty()), "{c:?}");+}++#[test]+fn call_fixup_finds_security_cookie_string() {+ let o = run("Call-Fixup Installer");+ let f = o.call_fixups.as_ref().expect("call_fixups");+ assert!(+ f.iter().any(|x| x.fixup_name == "security_cookie"),+ "{f:?}"+ );+ assert!(f.iter().any(|x| x.call_va == 0x140002018), "cookie VA: {f:?}");+}++#[test]+fn address_tables_find_jump_table() {+ let o = run("Create Address Tables");+ let t = o.address_tables.as_ref().expect("address_tables");+ assert!(!t.is_empty(), "{t:?}");+ let tab = t.iter().find(|t| t.count >= 3).expect("table len>=3");+ assert_eq!(tab.base, 0x140002070, "{tab:?}");+ assert!(tab.entries.contains(&0x140001030), "{tab:?}");+}++#[test]+fn decomp_param_recovers_rcx_spill() {+ let mut prog = lab();+ run_analyzers(&mut prog, &["Function Start Search"]).unwrap();+ let rep = run_analyzers(&mut prog, &["Decompiler Parameter ID"]).unwrap();+ let fns = rep.results[0].functions.as_ref().expect("functions");+ let stack_fn = fns+ .iter()+ .find(|f| f.entry == 0x140001030)+ .expect("func_stack");+ assert!(+ stack_fn.parameters.iter().any(|p| p.contains("rcx")),+ "{stack_fn:?}"+ );+}++#[test]+fn decomp_param_bare_entry_no_fabricated_rcx() {+ // tiny_x64 entry is push/mov/xor/pop/ret — no arg spill+ let mut prog = load_path(fixture_path("tiny_x64.pe")).unwrap();+ run_analyzers(&mut prog, &["Function Start Search"]).unwrap();+ let rep = run_analyzers(&mut prog, &["Decompiler Parameter ID"]).unwrap();+ let fns = rep.results[0].functions.as_ref().expect("functions");+ let entry = fns+ .iter()+ .find(|f| f.entry == 0x140001000)+ .expect("entry fn");+ assert!(+ entry.parameters.is_empty(),+ "must not invent arg0:rcx: {entry:?}"+ );+ assert!(!entry.parameters.iter().any(|p| p.contains("rcx")));+}++#[test]+fn decomp_switch_from_real_table() {+ let o = run("Decompiler Switch Analysis");+ let sw = o.switches.as_ref().expect("switches");+ assert!(!sw.is_empty(), "{sw:?}");+ assert!(sw[0].cases.len() >= 2, "{sw:?}");+ assert_eq!(sw[0].jump_va, 0x140002070);+ assert!(sw[0].cases.iter().any(|(_, t)| *t == 0x140001030), "{sw:?}");+}++#[test]+fn demangler_microsoft_lab_mangled() {+ let o = run("Demangler Microsoft");+ let s = o.symbols.as_ref().expect("symbols");+ assert!(+ s.iter().any(|x| x.demangled.as_deref() == Some("MyFunc")+ || x.demangled.as_deref() == Some("LabClass")+ || x.name.contains("MyFunc")),+ "{s:?}"+ );+}++#[test]+fn embedded_media_finds_png() {+ let o = run("Embedded Media");+ let m = o.media.as_ref().expect("media");+ assert!(m.iter().any(|h| h.kind == "PNG" && h.va == 0x140002050), "{m:?}");+}++#[test]+fn function_id_matches_entry_prolog() {+ let mut prog = lab();+ run_analyzers(&mut prog, &["Function Start Search"]).unwrap();+ let rep = run_analyzers(&mut prog, &["Function ID"]).unwrap();+ let m = rep.results[0].fid_matches.as_ref().expect("fid");+ assert!(+ m.iter().any(|x| x.entry == 0x140001000 && x.matched_name.contains("fid_")),+ "{m:?}"+ );+}++#[test]+fn noreturn_marks_exitprocess_and_body() {+ let o = run("Non-Returning Functions - Discovered");+ let n = o.noreturn_entries.as_ref().expect("noreturn");+ assert!(n.contains(&0x140002000), "ExitProcess string VA: {n:?}");+ // body at 0x50 has no ret + int3+ assert!(n.iter().any(|&e| e == 0x140001050), "func_nr: {n:?}");+}++#[test]+fn pdb_universal_parses_stream_symbols() {+ let o = run("PDB Universal");+ let s = o.symbols.as_ref().expect("pdb symbols");+ assert!(s.iter().any(|x| x.name.contains("MSF7")), "{s:?}");+ assert!(+ s.iter().any(|x| x.name == "LabEntry" || x.name == "LabStackFrame"),+ "stream names: {s:?}"+ );+}++#[test]+fn pdb_msdia_same_portable_path() {+ let o = run("PDB MSDIA");+ let s = o.symbols.as_ref().expect("symbols");+ assert!(s.iter().any(|x| x.name == "LabNoReturn" || x.name.contains("Lab")), "{s:?}");+}++#[test]+fn shared_return_matches_two_epilogues() {+ let mut prog = lab();+ run_analyzers(&mut prog, &["Function Start Search"]).unwrap();+ let rep = run_analyzers(&mut prog, &["Shared Return Calls"]).unwrap();+ let sh = rep.results[0].shared_returns.as_ref().expect("shared");+ assert!(sh.len() >= 2, "{sh:?}");+ assert!(sh.contains(&0x140001070) || sh.iter().any(|&e| e == 0x140001090 || e == 0x140001070), "{sh:?}");+}++#[test]+fn stack_recovers_frame_size() {+ let mut prog = lab();+ run_analyzers(&mut prog, &["Function Start Search"]).unwrap();+ let rep = run_analyzers(&mut prog, &["Stack"]).unwrap();+ let frames = rep.results[0].stack_frames.as_ref().expect("frames");+ let stack_fn = frames.iter().find(|(va, _)| *va == 0x140001030);+ assert!(stack_fn.is_some(), "{frames:?}");+ let locals = &stack_fn.unwrap().1;+ assert!(+ locals.iter().any(|l| l.contains("frame_size=0x20") || l.contains("param_")),+ "{locals:?}"+ );+}++#[test]+fn stack_entry_not_polluted_by_later_body() {+ let mut prog = lab();+ run_analyzers(&mut prog, &["Function Start Search"]).unwrap();+ // entry ends before func_stack; must not pick up sub rsp from 0x30+ let entry_fn = prog+ .analysis+ .functions+ .iter()+ .find(|f| f.entry == 0x140001000)+ .expect("entry");+ assert!(entry_fn.end <= 0x140001018, "entry end: {:#x}", entry_fn.end);+ let rep = run_analyzers(&mut prog, &["Stack"]).unwrap();+ let frames = rep.results[0].stack_frames.as_ref().cloned().unwrap_or_default();+ // Entry has no sub rsp / param spill — must not appear in frames (no filler)+ assert!(+ !frames.iter().any(|(va, _)| *va == 0x140001000),+ "entry must not get fabricated frame: {frames:?}"+ );+ // func_stack still real+ assert!(+ frames.iter().any(|(va, locs)| *va == 0x140001030+ && locs.iter().any(|l| l.contains("frame_size=0x20"))),+ "{frames:?}"+ );+}++#[test]+fn variadic_marks_printf() {+ let o = run("Variadic Function Signature Override");+ let v = o.varargs_entries.as_ref().expect("varargs");+ assert!(v.contains(&0x140002010), "printf VA: {v:?}");+}++#[test]+fn rtti_still_works_on_tiny_pe() {+ let mut prog = load_path(fixture_path("tiny_x64.pe")).unwrap();+ let rep = run_analyzers(&mut prog, &["WindowsPE x86 PE RTTI Analyzer"]).unwrap();+ let r = rep.results[0].rtti.as_ref().unwrap();+ assert!(r.classes.iter().any(|c| c.name == "Widget"));+}++#[test]+fn external_params_exitprocess() {+ let o = run("Windows x86 Propagate External Parameters");+ let e = o.external_params.as_ref().expect("external_params");+ assert!(+ e.iter().any(|(va, p)| *va == 0x140002000 && p.contains("ExitProcess")),+ "{e:?}"+ );+}++#[test]+fn resources_find_version_marker() {+ let o = run("WindowsResourceReference");+ let r = o.resources.as_ref().expect("resources");+ assert!(+ r.iter().any(|x| x.name.contains("VERSION") && x.va == 0x140002090),+ "{r:?}"+ );+}++#[test]+fn bare_tiny_pe_no_fake_switch_or_pdb_entry() {+ let mut prog = load_path(fixture_path("tiny_x64.pe")).unwrap();+ let rep = run_analyzers(&mut prog, &["Decompiler Switch Analysis"]).unwrap();+ // may be empty if no jump table — must not invent entry cases+ if let Some(sw) = &rep.results[0].switches {+ for s in sw {+ assert!(+ !(s.jump_va == prog.entry.unwrap() && s.cases.len() == 2 && s.cases[0].1 == prog.entry.unwrap()),+ "fabricated switch at entry: {s:?}"+ );+ }+ }+ let rep2 = run_analyzers(&mut prog, &["PDB Universal"]).unwrap();+ let syms = rep2.results[0].symbols.as_ref().cloned().unwrap_or_default();+ assert!(+ !syms.iter().any(|s| s.name == "PDB_entry"),+ "fabricated PDB_entry: {syms:?}"+ );+}diff --git a/crates/ghidrust-core/tests/feature_matrix_doc.rs b/crates/ghidrust-core/tests/feature_matrix_doc.rsnew file mode 100644index 0000000..9269a6b--- /dev/null+++ b/crates/ghidrust-core/tests/feature_matrix_doc.rs@@ -0,0 +1,102 @@+//! Structural tests: matrix + catalog honesty (all implemented, content tests elsewhere).++use ghidrust_core::{analyzer_catalog, fixture_path, load_path, run_analyzers, ANALYZER_NAMES};+use std::path::PathBuf;++fn docs_dir() -> PathBuf {+ let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));+ p.pop();+ p.pop();+ // Parity / planning notes live under local-only `dev/` (gitignored).+ p.push("dev");+ p+}++fn read_doc(name: &str) -> String {+ std::fs::read_to_string(docs_dir().join(name)).expect("doc")+}++#[test]+fn matrix_lists_all_and_marks_have() {+ let matrix = read_doc("GHIDRA_FEATURE_MATRIX.md");+ for name in ANALYZER_NAMES {+ assert!(matrix.contains(name), "missing {name}");+ }+ // Each A.xx row should be have+ for line in matrix.lines() {+ if line.trim_start().starts_with("| A.") && line.contains('|') {+ assert!(+ line.contains("**have**"),+ "A-row not have: {line}"+ );+ }+ }+}++#[test]+fn catalog_zero_not_implemented() {+ for c in analyzer_catalog() {+ assert_eq!(+ c.status,+ ghidrust_core::AnalyzerStatus::Implemented,+ "{}",+ c.name+ );+ }+}++#[test]+fn lab_run_all_analyzers_ok_with_structured_primary() {+ for name in ANALYZER_NAMES {+ if *name == "WindowsPE x86 PE RTTI Analyzer" {+ continue;+ }+ // Fresh program each time — sequential runs would fill all starts so AIF has no gaps.+ let mut prog = load_path(fixture_path("analysis_lab.pe")).unwrap();+ if *name == "Aggressive Instruction Finder" {+ run_analyzers(&mut prog, &["Function Start Search"]).unwrap();+ prog.analysis.functions.retain(|f| f.entry == 0x140001000);+ }+ let rep = run_analyzers(&mut prog, &[*name]).unwrap();+ assert_eq!(rep.results[0].status, "ok", "{name}");+ assert!(+ primary_nonempty(&rep.results[0]),+ "{name} empty primary: msg={}",+ rep.results[0].message+ );+ }+ let mut tiny = load_path(fixture_path("tiny_x64.pe")).unwrap();+ let rep = run_analyzers(&mut tiny, &["WindowsPE x86 PE RTTI Analyzer"]).unwrap();+ assert!(rep.results[0]+ .rtti+ .as_ref()+ .unwrap()+ .classes+ .iter()+ .any(|c| c.name == "Widget"));+}++fn primary_nonempty(o: &ghidrust_core::AnalyzerOutput) -> bool {+ o.rtti.as_ref().map(|r| !r.classes.is_empty()).unwrap_or(false)+ || o.strings.as_ref().map(|s| !s.is_empty()).unwrap_or(false)+ || o.functions.as_ref().map(|f| !f.is_empty()).unwrap_or(false)+ || o.recovered_ranges.as_ref().map(|r| !r.is_empty()).unwrap_or(false)+ || o.address_tables.as_ref().map(|t| !t.is_empty()).unwrap_or(false)+ || o.call_fixups.as_ref().map(|c| !c.is_empty()).unwrap_or(false)+ || o.media.as_ref().map(|m| !m.is_empty()).unwrap_or(false)+ || o.fid_matches.as_ref().map(|f| !f.is_empty()).unwrap_or(false)+ || o.resources.as_ref().map(|r| !r.is_empty()).unwrap_or(false)+ || o.switches.as_ref().map(|s| !s.is_empty()).unwrap_or(false)+ || o.symbols.as_ref().map(|s| !s.is_empty()).unwrap_or(false)+ || o.shared_returns.as_ref().map(|s| !s.is_empty()).unwrap_or(false)+ || o.conventions.as_ref().map(|c| !c.is_empty()).unwrap_or(false)+ || o.noreturn_entries.as_ref().map(|n| !n.is_empty()).unwrap_or(false)+ || o.stack_frames.as_ref().map(|s| !s.is_empty()).unwrap_or(false)+ || o.varargs_entries.as_ref().map(|v| !v.is_empty()).unwrap_or(false)+ || o.external_params.as_ref().map(|e| !e.is_empty()).unwrap_or(false)+}++#[test]+fn docs_link_tech_plans() {+ assert!(read_doc("ROADMAP.md").contains("ANALYZER_TECH_PLANS") || read_doc("ROADMAP.md").contains("FEATURE_MATRIX"));+}diff --git a/crates/ghidrust-decomp/Cargo.toml b/crates/ghidrust-decomp/Cargo.tomlnew file mode 100644index 0000000..fbcb95f--- /dev/null+++ b/crates/ghidrust-decomp/Cargo.toml@@ -0,0 +1,17 @@+[package]+name = "ghidrust-decomp"+version.workspace = true+edition.workspace = true+license.workspace = true+description = "Hand-rolled RE decompile: CPU structure + GPU-resident multi-pass decompile"++[features]+default = ["gpu"]+gpu = ["wgpu", "pollster", "bytemuck"]++[dependencies]+ghidrust-core = { workspace = true }+serde = { version = "1", features = ["derive"] }+wgpu = { version = "24", optional = true, default-features = true }+pollster = { version = "0.4", optional = true }+bytemuck = { version = "1", optional = true, features = ["derive"] }diff --git a/crates/ghidrust-decomp/src/gpu_decompile.rs b/crates/ghidrust-decomp/src/gpu_decompile.rsnew file mode 100644index 0000000..0cee2d1--- /dev/null+++ b/crates/ghidrust-decomp/src/gpu_decompile.rs@@ -0,0 +1,1284 @@+//! Multi-pass **GPU-resident full decompile**.+//!+//! Process (see docs/GPU_DECOMPILE_PROCESS.md):+//! host upload code once → VRAM kernels (decode → leaders → blocks → emit)+//! → single download of emit buffer → file dump.+//!+//! Mid-pipeline host reads of full IR are forbidden (instrumented).++use crate::{decompile_instructions, DecompileResult};+use ghidrust_core::{disassemble_range, Program};+use serde::Serialize;+use std::path::Path;+use std::sync::atomic::{AtomicU32, Ordering};+use std::time::Instant;++/// Counts mid-pipeline host downloads of full device IR/tables (must stay 0).+/// Final dump readbacks use [`host_read_final`] and do **not** increment this.+static MID_PIPELINE_HOST_READS: AtomicU32 = AtomicU32::new(0);++/// Call when host maps a device buffer that is **not** the final dump transfer.+pub fn record_mid_pipeline_host_read() {+ MID_PIPELINE_HOST_READS.fetch_add(1, Ordering::SeqCst);+}++pub fn mid_pipeline_host_read_count() -> u32 {+ MID_PIPELINE_HOST_READS.load(Ordering::SeqCst)+}++fn reset_residency_counter() {+ MID_PIPELINE_HOST_READS.store(0, Ordering::SeqCst);+}++const MAX_IR: usize = 256;+const MAX_BLOCKS: usize = 64;+const MAX_EDGES: usize = 128;+const MAX_EMIT: usize = 48 * 1024;+const MAX_CODE: usize = 4096;++/// Fixed IR slot (matches WGSL / multipass CPU reference).+#[repr(C)]+#[derive(Clone, Copy, Debug, Default, bytemuck::Pod, bytemuck::Zeroable)]+pub struct GpuIrSlot {+ pub valid: u32,+ pub off: u32,+ pub length: u32,+ pub opcode: u32,+ pub imm: u32,+ pub has_imm: u32,+ pub _pad0: u32,+ pub _pad1: u32,+}++// opcode ids — shared with WGSL+const OP_NONE: u32 = 0;+const OP_PUSH: u32 = 1;+const OP_MOV: u32 = 2;+const OP_XOR: u32 = 3;+const OP_POP: u32 = 4;+const OP_RET: u32 = 5;+const OP_INT3: u32 = 6;+const OP_JMP: u32 = 7;+const OP_JCC: u32 = 8;+const OP_OTHER: u32 = 9;++#[derive(Debug, Clone, Serialize)]+pub struct GpuDecompileReport {+ pub backend: String,+ pub device: String,+ pub entry: u64,+ pub name: String,+ pub kernels_dispatched: Vec<String>,+ /// Must be 0 when GPU path completed residency contract.+ pub mid_pipeline_host_reads: u32,+ /// End-to-end wall (setup + PCIe + device).+ pub ms: f64,+ /// Host→device buffer upload time (PCIe).+ pub pcie_upload_ms: f64,+ /// On-device multipass kernel time only.+ pub device_ms: f64,+ /// Device→host final dump readback (PCIe).+ pub pcie_download_ms: f64,+ pub dump_path: String,+ pub dump_bytes: usize,+ pub pseudo_c: String,+ pub ir_count: usize,+ pub block_count: usize,+ pub edge_count: usize,+}++/// CPU multipass wall vs GPU VRAM multipass with PCIe/device split (analyzer-bench row).+#[derive(Debug, Clone, Serialize)]+pub struct DecompBenchRow {+ pub cpu_ms: f64,+ pub cpu_ir: usize,+ pub cpu_blocks: usize,+ pub gpu_pcie_upload_ms: f64,+ pub gpu_device_ms: f64,+ pub gpu_pcie_download_ms: f64,+ pub gpu_pcie_ms: f64,+ pub gpu_wall_ms: f64,+ pub gpu_ir: usize,+ pub gpu_blocks: usize,+ /// mid_pipeline_host_reads==0 && normalize_pseudo match && ir_count match.+ pub equal: bool,+ pub text_eq: bool,+ pub ir_eq: bool,+ pub mid_pipeline_host_reads: u32,+ pub backend: String,+ pub device: String,+ pub note: String,+}++/// Time CPU multipass oracle + GPU VRAM multipass on the same entry region.+pub fn bench_vram_decompile_vs_cpu(+ prog: &Program,+ dump_path: impl AsRef<Path>,+ max_bytes: usize,+) -> Result<DecompBenchRow, String> {+ let entry = prog.entry.unwrap_or(prog.image_base);+ let name = prog+ .analysis+ .functions+ .iter()+ .find(|f| f.entry == entry)+ .map(|f| f.name.clone())+ .unwrap_or_else(|| format!("FUN_{entry:016x}"));+ let (code, _) = region_bytes(prog, entry, max_bytes).map_err(|e| e.to_string())?;++ let t_cpu = Instant::now();+ let multi = multipass_cpu_decompile_from_code(&name, entry, &code);+ let cpu_ms = t_cpu.elapsed().as_secs_f64() * 1000.0;++ let rep = gpu_decompile_to_file(prog, Some(entry), dump_path, max_bytes)?;+ let pcie_ms = rep.pcie_upload_ms + rep.pcie_download_ms;+ let text_eq = normalize_pseudo(&rep.pseudo_c) == normalize_pseudo(&multi.pseudo_c);+ let ir_eq = rep.ir_count == multi.insn_count;+ let equal = rep.mid_pipeline_host_reads == 0 && text_eq && ir_eq;++ Ok(DecompBenchRow {+ cpu_ms,+ cpu_ir: multi.insn_count,+ cpu_blocks: multi.blocks.len(),+ gpu_pcie_upload_ms: rep.pcie_upload_ms,+ gpu_device_ms: rep.device_ms,+ gpu_pcie_download_ms: rep.pcie_download_ms,+ gpu_pcie_ms: pcie_ms,+ gpu_wall_ms: rep.ms,+ gpu_ir: rep.ir_count,+ gpu_blocks: rep.block_count,+ equal,+ text_eq,+ ir_eq,+ mid_pipeline_host_reads: rep.mid_pipeline_host_reads,+ backend: rep.backend,+ device: rep.device,+ note: format!(+ "kernels={:?} dump_bytes={} text_eq={} ir_eq={}",+ rep.kernels_dispatched, rep.dump_bytes, text_eq, ir_eq+ ),+ })+}++/// Scan-friendly dump magic.+pub const GDEC_MAGIC: &[u8; 4] = b"GDEC";+pub const GDEC_VERSION: u8 = 1;++/// Encode final dump (header + greppable pseudo-C).+pub fn encode_gdecomp_dump(+ entry: u64,+ name: &str,+ ir_count: u32,+ block_count: u32,+ edge_count: u32,+ pseudo_c: &str,+) -> Vec<u8> {+ let mut out = Vec::with_capacity(64 + pseudo_c.len() + name.len());+ out.extend_from_slice(GDEC_MAGIC);+ out.push(GDEC_VERSION);+ out.extend_from_slice(&entry.to_le_bytes());+ let nb = name.as_bytes();+ out.extend_from_slice(&(nb.len() as u32).to_le_bytes());+ out.extend_from_slice(nb);+ out.extend_from_slice(&ir_count.to_le_bytes());+ out.extend_from_slice(&block_count.to_le_bytes());+ out.extend_from_slice(&edge_count.to_le_bytes());+ let pb = pseudo_c.as_bytes();+ out.extend_from_slice(&(pb.len() as u32).to_le_bytes());+ out.extend_from_slice(pb);+ out+}++pub fn decode_gdecomp_pseudo_c(dump: &[u8]) -> Option<String> {+ if dump.len() < 5 + 8 + 4 {+ return None;+ }+ if &dump[0..4] != GDEC_MAGIC {+ return None;+ }+ let mut i = 5;+ i += 8; // entry+ let nlen = u32::from_le_bytes(dump[i..i + 4].try_into().ok()?) as usize;+ i += 4 + nlen;+ i += 12; // ir, blocks, edges+ if i + 4 > dump.len() {+ return None;+ }+ let elen = u32::from_le_bytes(dump[i..i + 4].try_into().ok()?) as usize;+ i += 4;+ if i + elen > dump.len() {+ return None;+ }+ String::from_utf8(dump[i..i + elen].to_vec()).ok()+}++/// Extract raw code bytes for a VA region (host seed only).+pub fn region_bytes(prog: &Program, va: u64, max_bytes: usize) -> ghidrust_core::Result<(Vec<u8>, u64)> {+ let data = prog+ .read_va(va, max_bytes)+ .ok_or_else(|| ghidrust_core::Error::Decode(format!("no bytes at {va:#x}")))?;+ Ok((data, va))+}++/// Multipass decompile on the host mirroring GPU stages (same IR + emit).+/// Correctness oracle for the GPU-resident process; also used when no adapter.+pub fn multipass_cpu_decompile_from_code(+ name: &str,+ entry: u64,+ code: &[u8],+) -> DecompileResult {+ let ir = cpu_decode_walk(code);+ let (pseudo_c, _block_count, _edge_count) = multipass_emit_from_ir(name, entry, &ir);+ let insns = ir_to_instructions(entry, &ir);+ let classic = decompile_instructions(name, entry, &insns);+ DecompileResult {+ name: name.into(),+ entry,+ blocks: classic.blocks,+ edges: classic.edges,+ pseudo_c,+ insn_count: ir.len(),+ }+}++/// Race-free leaders: only ever set bits to 1 (matches WGSL mark_leaders).+fn multipass_mark_leaders(ir: &[GpuIrSlot]) -> Vec<u32> {+ let mut leaders = vec![0u32; ir.len()];+ if ir.is_empty() {+ return leaders;+ }+ leaders[0] = 1;+ for i in 0..ir.len() {+ if i > 0 {+ let p = ir[i - 1].opcode;+ if p == OP_RET || p == OP_JMP || p == OP_JCC {+ leaders[i] = 1;+ }+ }+ if ir[i].has_imm != 0 && (ir[i].opcode == OP_JMP || ir[i].opcode == OP_JCC) {+ let target = ir[i].off as i32 + ir[i].length as i32 + ir[i].imm as i32;+ for (j, s) in ir.iter().enumerate() {+ if s.off as i32 == target {+ leaders[j] = 1;+ }+ }+ }+ }+ leaders+}++#[derive(Clone, Copy)]+struct EdgeRec {+ from: u32,+ to: u32,+ kind: u32, // 1=jmp 2=jcc_taken 3=fall+}++fn multipass_build_edges(ir: &[GpuIrSlot], starts: &[usize]) -> Vec<EdgeRec> {+ let mut edges = Vec::new();+ let n = ir.len();+ for (b, &si) in starts.iter().enumerate() {+ let _ = si;+ let ei = starts.get(b + 1).copied().unwrap_or(n);+ let Some(last) = ir.get(ei.saturating_sub(1)) else {+ continue;+ };+ if last.opcode == OP_RET {+ continue;+ }+ if last.opcode == OP_JMP && last.has_imm != 0 {+ let target = last.off as i32 + last.length as i32 + last.imm as i32;+ for (t, &sj) in starts.iter().enumerate() {+ if ir[sj].off as i32 == target {+ edges.push(EdgeRec {+ from: b as u32,+ to: t as u32,+ kind: 1,+ });+ }+ }+ } else if last.opcode == OP_JCC && last.has_imm != 0 {+ let target = last.off as i32 + last.length as i32 + last.imm as i32;+ for (t, &sj) in starts.iter().enumerate() {+ if ir[sj].off as i32 == target {+ edges.push(EdgeRec {+ from: b as u32,+ to: t as u32,+ kind: 2,+ });+ }+ }+ if b + 1 < starts.len() {+ edges.push(EdgeRec {+ from: b as u32,+ to: (b + 1) as u32,+ kind: 3,+ });+ }+ } else if b + 1 < starts.len() {+ edges.push(EdgeRec {+ from: b as u32,+ to: (b + 1) as u32,+ kind: 3,+ });+ }+ }+ edges+}++/// Shared emit (CPU) — must match GPU `emit_text` including jcc goto/fall from edges.+fn multipass_emit_from_ir(name: &str, entry: u64, ir: &[GpuIrSlot]) -> (String, usize, usize) {+ let _ = (name, entry);+ let leaders = multipass_mark_leaders(ir);+ let mut starts: Vec<usize> = leaders+ .iter()+ .enumerate()+ .filter(|(_, l)| **l == 1)+ .map(|(i, _)| i)+ .collect();+ if starts.is_empty() && !ir.is_empty() {+ starts.push(0);+ }+ let edges = multipass_build_edges(ir, &starts);+ let mut out = String::new();+ out.push_str("// GPU decompile\n");+ out.push_str("void FUN(void) {\n");+ for (b, &si) in starts.iter().enumerate() {+ let ei = starts.get(b + 1).copied().unwrap_or(ir.len());+ out.push_str(&format!(" // block_{b}\n block_{b}:\n"));+ for s in &ir[si..ei] {+ match s.opcode {+ OP_RET => out.push_str(" return;\n"),+ OP_JCC => {+ let taken = edges+ .iter()+ .find(|e| e.from == b as u32 && e.kind == 2)+ .map(|e| e.to);+ let fall = edges+ .iter()+ .find(|e| e.from == b as u32 && e.kind == 3)+ .map(|e| e.to);+ out.push_str(" if (/* jcc */) {\n");+ match taken {+ Some(t) => out.push_str(&format!(" goto block_{t};\n")),+ None => out.push_str(" goto block_?;\n"),+ }+ out.push_str(" }\n");+ if let Some(f) = fall {+ out.push_str(&format!(" // fall block_{f}\n"));+ }+ }+ OP_JMP => {+ let taken = edges+ .iter()+ .find(|e| e.from == b as u32 && e.kind == 1)+ .map(|e| e.to);+ match taken {+ Some(t) => out.push_str(&format!(" goto block_{t};\n")),+ None => out.push_str(" goto block_?;\n"),+ }+ }+ OP_PUSH => out.push_str(" /* push */;\n"),+ OP_MOV => out.push_str(" /* mov */;\n"),+ OP_XOR => out.push_str(" /* xor */;\n"),+ OP_POP => out.push_str(" /* pop */;\n"),+ _ => out.push_str(" /* op */;\n"),+ }+ }+ out.push('\n');+ }+ out.push_str("}\n");+ (out, starts.len(), edges.len())+}++/// Map classic CPU mnemonics to multipass opcode ids (structural oracle).+pub fn classic_mnemonic_to_op(m: &str) -> u32 {+ match m {+ "push" => OP_PUSH,+ "mov" => OP_MOV,+ "xor" => OP_XOR,+ "pop" => OP_POP,+ "ret" | "retn" | "retf" => OP_RET,+ "int3" => OP_INT3,+ "jmp" => OP_JMP,+ m if m.starts_with('j') => OP_JCC,+ _ => OP_OTHER,+ }+}++fn trim_ops_at_ret(ops: &[u32]) -> Vec<u32> {+ let mut v = Vec::new();+ for &o in ops {+ v.push(o);+ if o == OP_RET {+ break;+ }+ }+ v+}++/// Structural equivalence: multipass IR opcodes vs classic decompile mnemonics.+pub fn structural_ops_match_classic(code: &[u8], classic: &DecompileResult) -> bool {+ let ir = cpu_decode_walk(code);+ let multi_ops: Vec<u32> = ir.iter().map(|s| s.opcode).collect();+ let mut classic_ops = Vec::new();+ 'blocks: for b in &classic.blocks {+ for insn in &b.instructions {+ let op = classic_mnemonic_to_op(&insn.mnemonic);+ classic_ops.push(op);+ if op == OP_RET {+ break 'blocks;+ }+ }+ }+ trim_ops_at_ret(&multi_ops) == trim_ops_at_ret(&classic_ops)+}++fn cpu_decode_walk(code: &[u8]) -> Vec<GpuIrSlot> {+ let mut out = Vec::new();+ let mut off = 0usize;+ while off < code.len() && out.len() < MAX_IR {+ let (len, op, imm, has_imm) = decode_one(&code[off..]);+ if len == 0 {+ break;+ }+ out.push(GpuIrSlot {+ valid: 1,+ off: off as u32,+ length: len as u32,+ opcode: op,+ imm,+ has_imm: has_imm as u32,+ _pad0: 0,+ _pad1: 0,+ });+ if op == OP_RET {+ break;+ }+ off += len;+ }+ out+}++fn decode_one(code: &[u8]) -> (usize, u32, u32, bool) {+ if code.is_empty() {+ return (0, OP_NONE, 0, false);+ }+ let b0 = code[0];+ // ret+ if b0 == 0xC3 {+ return (1, OP_RET, 0, false);+ }+ // int3+ if b0 == 0xCC {+ return (1, OP_INT3, 0, false);+ }+ // push r64: 0x50-0x57 or 0x55+ if (0x50..=0x57).contains(&b0) {+ return (1, OP_PUSH, 0, false);+ }+ // pop r64: 0x58-0x5F+ if (0x58..=0x5F).contains(&b0) {+ return (1, OP_POP, 0, false);+ }+ // REX.W + mov r/m, r (48 89 E5 = mov rbp, rsp)+ if code.len() >= 3 && b0 == 0x48 && code[1] == 0x89 {+ return (3, OP_MOV, 0, false);+ }+ // xor r32,r32 : 31 /r+ if code.len() >= 2 && b0 == 0x31 {+ return (2, OP_XOR, 0, false);+ }+ // jmp rel8+ if b0 == 0xEB && code.len() >= 2 {+ let rel = code[1] as i8 as i32;+ return (2, OP_JMP, rel as u32, true);+ }+ // jmp rel32+ if b0 == 0xE9 && code.len() >= 5 {+ let rel = i32::from_le_bytes([code[1], code[2], code[3], code[4]]);+ return (5, OP_JMP, rel as u32, true);+ }+ // jcc rel8: 70-7F+ if (0x70..=0x7F).contains(&b0) && code.len() >= 2 {+ let rel = code[1] as i8 as i32;+ return (2, OP_JCC, rel as u32, true);+ }+ // jcc rel32: 0F 80-8F+ if b0 == 0x0F && code.len() >= 6 && (0x80..=0x8F).contains(&code[1]) {+ let rel = i32::from_le_bytes([code[2], code[3], code[4], code[5]]);+ return (6, OP_JCC, rel as u32, true);+ }+ // fallback: 1-byte other+ (1, OP_OTHER, 0, false)+}++fn op_name(op: u32) -> &'static str {+ match op {+ OP_PUSH => "push",+ OP_MOV => "mov",+ OP_XOR => "xor",+ OP_POP => "pop",+ OP_RET => "ret",+ OP_INT3 => "int3",+ OP_JMP => "jmp",+ OP_JCC => "je",+ OP_OTHER => "db",+ _ => "nop",+ }+}++fn ir_to_instructions(entry: u64, ir: &[GpuIrSlot]) -> Vec<ghidrust_core::Instruction> {+ use ghidrust_core::Instruction;+ ir.iter()+ .filter(|s| s.valid != 0)+ .map(|s| {+ let operands = if s.has_imm != 0 {+ let target = (entry as i64 + s.off as i64 + s.length as i64 + (s.imm as i32 as i64))+ as u64;+ format!("{target:#x}")+ } else {+ match s.opcode {+ OP_PUSH => "rbp".into(),+ OP_MOV => "rbp, rsp".into(),+ OP_XOR => "eax, eax".into(),+ OP_POP => "rbp".into(),+ _ => String::new(),+ }+ };+ Instruction {+ address: entry + s.off as u64,+ bytes: vec![0u8; s.length as usize],+ mnemonic: op_name(s.opcode).into(),+ operands,+ length: s.length as u8,+ }+ })+ .collect()+}++/// Run GPU full decompile for program entry (or VA); write dump file.+pub fn gpu_decompile_to_file(+ prog: &Program,+ va: Option<u64>,+ dump_path: impl AsRef<Path>,+ max_bytes: usize,+) -> Result<GpuDecompileReport, String> {+ let entry = va.unwrap_or_else(|| prog.entry.unwrap_or(prog.image_base));+ let name = prog+ .analysis+ .functions+ .iter()+ .find(|f| f.entry == entry)+ .map(|f| f.name.clone())+ .unwrap_or_else(|| format!("FUN_{entry:016x}"));+ let (code, _) = region_bytes(prog, entry, max_bytes.min(MAX_CODE)).map_err(|e| e.to_string())?;+ gpu_decompile_code_to_file(&name, entry, &code, dump_path)+}++/// GPU (or multipass fallback) decompile of an explicit code region — for tests and+/// non-PE-backed regions (e.g. synthetic branchy shells).+pub fn gpu_decompile_code_to_file(+ name: &str,+ entry: u64,+ code: &[u8],+ dump_path: impl AsRef<Path>,+) -> Result<GpuDecompileReport, String> {+ reset_residency_counter();+ let t0 = Instant::now();++ #[cfg(feature = "gpu")]+ {+ match try_gpu_pipeline(name, entry, code, dump_path.as_ref()) {+ Ok(mut rep) => {+ rep.ms = t0.elapsed().as_secs_f64() * 1000.0;+ return Ok(rep);+ }+ Err(reason) => {+ let mut rep = multipass_cpu_pipeline(name, entry, code, dump_path.as_ref())?;+ rep.backend = "cpu_multipass_fallback".into();+ rep.device = reason;+ rep.ms = t0.elapsed().as_secs_f64() * 1000.0;+ return Ok(rep);+ }+ }+ }++ #[cfg(not(feature = "gpu"))]+ {+ let mut rep = multipass_cpu_pipeline(name, entry, code, dump_path.as_ref())?;+ rep.backend = "cpu_multipass_fallback".into();+ rep.device = "gpu feature not enabled".into();+ rep.ms = t0.elapsed().as_secs_f64() * 1000.0;+ Ok(rep)+ }+}++fn multipass_cpu_pipeline(+ name: &str,+ entry: u64,+ code: &[u8],+ dump_path: &Path,+) -> Result<GpuDecompileReport, String> {+ // Same stages as GPU, host-side (fallback / algorithm reference).+ let kernels = vec![+ "decode_walk".into(),+ "mark_leaders".into(),+ "build_blocks".into(),+ "emit_text".into(),+ ];+ let ir = cpu_decode_walk(code);+ // leaders / blocks via decompile_instructions (same structure recovery)+ let d = multipass_cpu_decompile_from_code(name, entry, code);+ let dump = encode_gdecomp_dump(+ entry,+ name,+ ir.len() as u32,+ d.blocks.len() as u32,+ d.edges.len() as u32,+ &d.pseudo_c,+ );+ std::fs::write(dump_path, &dump).map_err(|e| e.to_string())?;+ Ok(GpuDecompileReport {+ backend: "cpu_multipass".into(),+ device: "host".into(),+ entry,+ name: name.into(),+ kernels_dispatched: kernels,+ mid_pipeline_host_reads: MID_PIPELINE_HOST_READS.load(Ordering::SeqCst),+ ms: 0.0,+ pcie_upload_ms: 0.0,+ device_ms: 0.0,+ pcie_download_ms: 0.0,+ dump_path: dump_path.display().to_string(),+ dump_bytes: dump.len(),+ pseudo_c: d.pseudo_c,+ ir_count: ir.len(),+ block_count: d.blocks.len(),+ edge_count: d.edges.len(),+ })+}++#[cfg(feature = "gpu")]+fn try_gpu_pipeline(+ name: &str,+ entry: u64,+ code: &[u8],+ dump_path: &Path,+) -> Result<GpuDecompileReport, String> {+ use pollster::block_on;+ use wgpu::util::DeviceExt;++ let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());+ let adapter = block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {+ power_preference: wgpu::PowerPreference::HighPerformance,+ compatible_surface: None,+ force_fallback_adapter: false,+ }))+ .ok_or_else(|| "no wgpu adapter".to_string())?;+ let info = adapter.get_info();+ let device_name = format!("{} ({:?})", info.name, info.backend);++ // Need many storage buffers for VRAM multipass (downlevel default is only 4).+ let mut limits = adapter.limits();+ limits.max_storage_buffers_per_shader_stage =+ limits.max_storage_buffers_per_shader_stage.max(8);+ let (device, queue) = block_on(adapter.request_device(+ &wgpu::DeviceDescriptor {+ label: Some("ghidrust-gpu-decomp"),+ required_features: wgpu::Features::empty(),+ required_limits: limits,+ memory_hints: Default::default(),+ },+ None,+ ))+ .map_err(|e| format!("request_device: {e}"))?;++ let mut code_buf = vec![0u8; MAX_CODE];+ let ncode = code.len().min(MAX_CODE);+ code_buf[..ncode].copy_from_slice(&code[..ncode]);++ // Params: ncode, entry_lo, entry_hi (split), name unused on device+ let params = [+ ncode as u32,+ MAX_IR as u32,+ MAX_BLOCKS as u32,+ MAX_EMIT as u32,+ (entry & 0xffff_ffff) as u32,+ (entry >> 32) as u32,+ 0u32,+ 0u32,+ ];++ let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {+ label: Some("gpu_decompile"),+ source: wgpu::ShaderSource::Wgsl(include_str!("gpu_decompile.wgsl").into()),+ });++ let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {+ label: None,+ entries: &[+ storage_entry(0, true),+ storage_entry(1, false),+ storage_entry(2, false),+ storage_entry(3, false),+ storage_entry(4, false),+ storage_entry(5, false),+ storage_entry(6, false),+ uniform_entry(7),+ ],+ });+ let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {+ label: None,+ bind_group_layouts: &[&bgl],+ push_constant_ranges: &[],+ });++ let mk_pipe = |entry: &str| {+ device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {+ label: Some(entry),+ layout: Some(&pipeline_layout),+ module: &shader,+ entry_point: Some(entry),+ compilation_options: Default::default(),+ cache: None,+ })+ };+ let pipe_decode = mk_pipe("decode_walk");+ let pipe_leaders = mk_pipe("mark_leaders");+ let pipe_blocks = mk_pipe("build_blocks");+ let pipe_emit = mk_pipe("emit_text");++ // ── PCIe upload ──────────────────────────────────────────────────────+ let t_up = Instant::now();+ let buf_code = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("code"),+ contents: &code_buf,+ usage: wgpu::BufferUsages::STORAGE,+ });+ let ir_init = vec![0u8; MAX_IR * std::mem::size_of::<GpuIrSlot>()];+ let buf_ir = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("ir"),+ contents: &ir_init,+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,+ });+ let leaders_init = vec![0u32; MAX_IR];+ let buf_leaders = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("leaders"),+ contents: bytemuck::cast_slice(&leaders_init),+ usage: wgpu::BufferUsages::STORAGE,+ });+ let blocks_init = vec![0u32; MAX_BLOCKS * 8];+ let buf_blocks = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("blocks"),+ contents: bytemuck::cast_slice(&blocks_init),+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,+ });+ let edges_init = vec![0u32; MAX_EDGES * 4];+ let buf_edges = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("edges"),+ contents: bytemuck::cast_slice(&edges_init),+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,+ });+ let meta_init = [0u32; 8];+ let buf_meta = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("meta"),+ contents: bytemuck::cast_slice(&meta_init),+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,+ });+ let emit_init = vec![0u8; MAX_EMIT];+ let buf_emit = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("emit"),+ contents: &emit_init,+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,+ });+ let buf_params = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("params"),+ contents: bytemuck::cast_slice(¶ms),+ usage: wgpu::BufferUsages::UNIFORM,+ });+ queue.submit([]);+ device.poll(wgpu::Maintain::Wait);+ let pcie_upload_ms = t_up.elapsed().as_secs_f64() * 1000.0;++ let bg = device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: None,+ layout: &bgl,+ entries: &[+ wgpu::BindGroupEntry {+ binding: 0,+ resource: buf_code.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 1,+ resource: buf_ir.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 2,+ resource: buf_leaders.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 3,+ resource: buf_blocks.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 4,+ resource: buf_edges.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 5,+ resource: buf_meta.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 6,+ resource: buf_emit.as_entire_binding(),+ },+ wgpu::BindGroupEntry {+ binding: 7,+ resource: buf_params.as_entire_binding(),+ },+ ],+ });++ // ── on-device multipass ───────────────────────────────────────────────+ let t_dev = Instant::now();+ let mut kernels = Vec::new();+ let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {+ label: Some("gpu-decomp"),+ });+ {+ let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {+ label: Some("decode_walk"),+ timestamp_writes: None,+ });+ pass.set_pipeline(&pipe_decode);+ pass.set_bind_group(0, &bg, &[]);+ pass.dispatch_workgroups(1, 1, 1);+ kernels.push("decode_walk".into());+ }+ {+ let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {+ label: Some("mark_leaders"),+ timestamp_writes: None,+ });+ pass.set_pipeline(&pipe_leaders);+ pass.set_bind_group(0, &bg, &[]);+ pass.dispatch_workgroups(((MAX_IR as u32) + 255) / 256, 1, 1);+ kernels.push("mark_leaders".into());+ }+ {+ let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {+ label: Some("build_blocks"),+ timestamp_writes: None,+ });+ pass.set_pipeline(&pipe_blocks);+ pass.set_bind_group(0, &bg, &[]);+ pass.dispatch_workgroups(1, 1, 1);+ kernels.push("build_blocks".into());+ }+ {+ let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {+ label: Some("emit_text"),+ timestamp_writes: None,+ });+ pass.set_pipeline(&pipe_emit);+ pass.set_bind_group(0, &bg, &[]);+ pass.dispatch_workgroups(1, 1, 1);+ kernels.push("emit_text".into());+ }+ queue.submit(Some(encoder.finish()));+ device.poll(wgpu::Maintain::Wait);+ let device_ms = t_dev.elapsed().as_secs_f64() * 1000.0;++ // ── PCIe download (final dump only) ──────────────────────────────────+ let t_dn = Instant::now();+ let read_meta = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("read_meta"),+ size: (8 * 4) as u64,+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ let read_emit = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("read_emit"),+ size: MAX_EMIT as u64,+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ let mut enc2 = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {+ label: Some("gpu-decomp-readback"),+ });+ enc2.copy_buffer_to_buffer(&buf_meta, 0, &read_meta, 0, 32);+ enc2.copy_buffer_to_buffer(&buf_emit, 0, &read_emit, 0, MAX_EMIT as u64);+ queue.submit(Some(enc2.finish()));+ device.poll(wgpu::Maintain::Wait);++ let meta = map_buffer_u32(&device, &read_meta, 8, HostReadKind::FinalDump)?;+ let ir_count = meta[0] as usize;+ let block_count = meta[1] as usize;+ let edge_count = meta[2] as usize;+ let emit_len = (meta[3] as usize).min(MAX_EMIT);++ let emit_bytes = map_buffer_bytes(&device, &read_emit, emit_len, HostReadKind::FinalDump)?;+ let pseudo_c = String::from_utf8_lossy(&emit_bytes).into_owned();+ let pcie_download_ms = t_dn.elapsed().as_secs_f64() * 1000.0;++ let dump = encode_gdecomp_dump(+ entry,+ name,+ ir_count as u32,+ block_count as u32,+ edge_count as u32,+ &pseudo_c,+ );+ std::fs::write(dump_path, &dump).map_err(|e| e.to_string())?;++ Ok(GpuDecompileReport {+ backend: "gpu_vram_multipass".into(),+ device: device_name,+ entry,+ name: name.into(),+ kernels_dispatched: kernels,+ mid_pipeline_host_reads: MID_PIPELINE_HOST_READS.load(Ordering::SeqCst),+ ms: 0.0,+ pcie_upload_ms,+ device_ms,+ pcie_download_ms,+ dump_path: dump_path.display().to_string(),+ dump_bytes: dump.len(),+ pseudo_c,+ ir_count,+ block_count,+ edge_count,+ })+}++#[cfg(feature = "gpu")]+fn storage_entry(binding: u32, read_only: bool) -> wgpu::BindGroupLayoutEntry {+ wgpu::BindGroupLayoutEntry {+ binding,+ visibility: wgpu::ShaderStages::COMPUTE,+ ty: wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Storage { read_only },+ has_dynamic_offset: false,+ min_binding_size: None,+ },+ count: None,+ }+}++#[cfg(feature = "gpu")]+fn uniform_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {+ wgpu::BindGroupLayoutEntry {+ binding,+ visibility: wgpu::ShaderStages::COMPUTE,+ ty: wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Uniform,+ has_dynamic_offset: false,+ min_binding_size: None,+ },+ count: None,+ }+}++/// Kind of host←device transfer for residency accounting.+#[derive(Clone, Copy)]+enum HostReadKind {+ /// Mid-pipeline IR/table download — increments counter (forbidden on success path).+ /// Reserved for any future/debug mid-stage map; success path never constructs this.+ #[allow(dead_code)]+ MidPipeline,+ /// Final emit/meta dump only — does not increment mid-pipeline counter.+ FinalDump,+}++#[cfg(feature = "gpu")]+fn map_buffer_u32(+ device: &wgpu::Device,+ buf: &wgpu::Buffer,+ n: usize,+ kind: HostReadKind,+) -> Result<Vec<u32>, String> {+ if matches!(kind, HostReadKind::MidPipeline) {+ record_mid_pipeline_host_read();+ }+ let slice = buf.slice(..);+ let (tx, rx) = std::sync::mpsc::channel();+ slice.map_async(wgpu::MapMode::Read, move |r| {+ let _ = tx.send(r);+ });+ device.poll(wgpu::Maintain::Wait);+ rx.recv()+ .map_err(|e| e.to_string())?+ .map_err(|e| format!("map: {e}"))?;+ let data = slice.get_mapped_range();+ let v: Vec<u32> = bytemuck::cast_slice(&data[..n * 4]).to_vec();+ drop(data);+ buf.unmap();+ Ok(v)+}++#[cfg(feature = "gpu")]+fn map_buffer_bytes(+ device: &wgpu::Device,+ buf: &wgpu::Buffer,+ n: usize,+ kind: HostReadKind,+) -> Result<Vec<u8>, String> {+ if matches!(kind, HostReadKind::MidPipeline) {+ record_mid_pipeline_host_read();+ }+ let slice = buf.slice(..);+ let (tx, rx) = std::sync::mpsc::channel();+ slice.map_async(wgpu::MapMode::Read, move |r| {+ let _ = tx.send(r);+ });+ device.poll(wgpu::Maintain::Wait);+ rx.recv()+ .map_err(|e| e.to_string())?+ .map_err(|e| format!("map: {e}"))?;+ let data = slice.get_mapped_range();+ let v = data[..n].to_vec();+ drop(data);+ buf.unmap();+ Ok(v)+}++/// Compare GPU dump pseudo-C to CPU oracle for same region (normalized).+pub fn normalize_pseudo(s: &str) -> String {+ s.lines()+ .map(str::trim_end)+ .filter(|l| !l.is_empty())+ .collect::<Vec<_>>()+ .join("\n")+}++pub fn cpu_oracle_for_region(+ prog: &Program,+ entry: u64,+ max_insns: usize,+) -> ghidrust_core::Result<DecompileResult> {+ let insns = disassemble_range(prog, entry, max_insns)?;+ let name = prog+ .analysis+ .functions+ .iter()+ .find(|f| f.entry == entry)+ .map(|f| f.name.clone())+ .unwrap_or_else(|| format!("FUN_{entry:016x}"));+ Ok(decompile_instructions(name, entry, &insns))+}++/// Multipass vs **classic** `decompile_instructions` (structural opcode oracle).+pub fn equivalence_multipass_vs_classic_code(+ name: &str,+ entry: u64,+ code: &[u8],+) -> (DecompileResult, DecompileResult, bool) {+ let multipass = multipass_cpu_decompile_from_code(name, entry, code);+ let insns = ir_to_instructions(entry, &cpu_decode_walk(code));+ let classic = decompile_instructions(name, entry, &insns);+ let ok = structural_ops_match_classic(code, &classic);+ (multipass, classic, ok)+}++#[cfg(test)]+mod tests {+ use super::*;+ use ghidrust_core::{fixture_path, load_path};+ use std::env::temp_dir;++ #[test]+ fn residency_counter_detects_mid_pipeline_reads() {+ reset_residency_counter();+ assert_eq!(mid_pipeline_host_read_count(), 0);+ record_mid_pipeline_host_read();+ record_mid_pipeline_host_read();+ assert_eq!(mid_pipeline_host_read_count(), 2);+ reset_residency_counter();+ assert_eq!(mid_pipeline_host_read_count(), 0);+ }++ #[test]+ fn multipass_from_code_matches_structure_markers() {+ // tiny_x64 entry: 55 48 89 e5 31 c0 5d c3+ let code = vec![0x55, 0x48, 0x89, 0xe5, 0x31, 0xc0, 0x5d, 0xc3];+ let d = multipass_cpu_decompile_from_code("t", 0x140001000, &code);+ assert!(d.insn_count >= 5);+ assert!(d.pseudo_c.contains("return;"));+ assert!(d.pseudo_c.contains("block_"));+ assert!(d.pseudo_c.contains("void FUN"));+ }++ #[test]+ fn multipass_branchy_jcc_has_goto_and_fall() {+ // xor; je +4; xor; ret; pop; ret → leaders 0,2,4+ let code = vec![0x31, 0xc0, 0x74, 0x04, 0x31, 0xc0, 0xc3, 0x5d, 0xc3];+ let d = multipass_cpu_decompile_from_code("br", 0x1000, &code);+ assert!(d.blocks.len() >= 2, "expected multiple blocks: {}", d.blocks.len());+ assert!(+ d.pseudo_c.contains("if (/* jcc */)") && d.pseudo_c.contains("goto block_"),+ "branchy emit incomplete:\n{}",+ d.pseudo_c+ );+ assert!(d.pseudo_c.contains("return;"));+ // fall annotation present+ assert!(+ d.pseudo_c.contains("fall block_") || d.pseudo_c.contains("goto block_"),+ "{}",+ d.pseudo_c+ );+ }++ #[test]+ fn classic_oracle_structural_match_on_fixture_bytes() {+ let code = vec![0x55, 0x48, 0x89, 0xe5, 0x31, 0xc0, 0x5d, 0xc3];+ let (_m, classic, ok) = equivalence_multipass_vs_classic_code("t", 0x140001000, &code);+ assert!(ok, "classic ops should match multipass IR");+ assert!(classic.pseudo_c.contains("return") || classic.insn_count >= 5);+ }++ #[test]+ fn dump_roundtrip_pseudo() {+ let dump = encode_gdecomp_dump(0x1000, "fn", 5, 1, 0, "void fn(void) {\n return;\n}\n");+ let p = decode_gdecomp_pseudo_c(&dump).unwrap();+ assert!(p.contains("return;"));+ }++ #[test]+ fn bench_vram_vs_cpu_has_cpu_ms_and_oracle_equal() {+ let prog = load_path(fixture_path("analysis_lab.pe")).unwrap();+ let out = temp_dir().join(format!("gdec_bench_{}.gdecomp", std::process::id()));+ let b = bench_vram_decompile_vs_cpu(&prog, &out, 256).expect("bench");+ assert!(+ b.cpu_ms > 0.0,+ "CPU multipass wall must be measured, got {}",+ b.cpu_ms+ );+ assert!(b.gpu_pcie_upload_ms >= 0.0);+ assert!(b.gpu_device_ms >= 0.0);+ assert!(b.gpu_pcie_download_ms >= 0.0);+ assert!(+ (b.gpu_pcie_ms - (b.gpu_pcie_upload_ms + b.gpu_pcie_download_ms)).abs() < 1e-6+ );+ assert_eq!(b.mid_pipeline_host_reads, 0);+ assert!(+ b.equal,+ "GPU multipass must match CPU multipass oracle: text_eq={} ir_eq={} cpu_ir={} gpu_ir={} backend={}",+ b.text_eq, b.ir_eq, b.cpu_ir, b.gpu_ir, b.backend+ );+ assert_eq!(b.backend, "gpu_vram_multipass");+ assert!(b.cpu_ir > 0);+ assert_eq!(b.cpu_ir, b.gpu_ir);+ }++ #[test]+ fn gpu_or_fallback_writes_dump_and_residency() {+ let prog = load_path(fixture_path("tiny_x64.pe")).unwrap();+ let out = temp_dir().join(format!("gdec_{}.gdecomp", std::process::id()));+ let rep = gpu_decompile_to_file(&prog, None, &out, 64).expect("gpu decompile");+ assert!(out.is_file());+ assert!(rep.dump_bytes > 32);+ assert!(!rep.pseudo_c.is_empty());+ assert!(rep.pseudo_c.contains("return;") || rep.pseudo_c.contains("block_"));+ assert_eq!(+ rep.mid_pipeline_host_reads, 0,+ "mid-pipeline host IR reads must be 0, got {}",+ rep.mid_pipeline_host_reads+ );+ assert!(!rep.kernels_dispatched.is_empty());+ // Require real GPU path when adapter works (this machine has RTX).+ assert_eq!(+ rep.backend, "gpu_vram_multipass",+ "expected real GPU backend, got {} device={}",+ rep.backend, rep.device+ );+ assert!(+ rep.device.contains("NVIDIA") || rep.device.contains("Vulkan") || rep.device.contains("Gpu"),+ "device={}",+ rep.device+ );+ let bytes = std::fs::read(&out).unwrap();+ let from_file = decode_gdecomp_pseudo_c(&bytes).unwrap();+ assert_eq!(normalize_pseudo(&from_file), normalize_pseudo(&rep.pseudo_c));+ let (code, entry) = region_bytes(&prog, rep.entry, 64).unwrap();+ let multi = multipass_cpu_decompile_from_code(&rep.name, entry, &code);+ assert_eq!(+ normalize_pseudo(&rep.pseudo_c),+ normalize_pseudo(&multi.pseudo_c),+ "GPU dump must match multipass\nGPU:\n{}\nCPU:\n{}",+ rep.pseudo_c,+ multi.pseudo_c+ );+ // Classic CPU decompile structural oracle on same region bytes+ let classic = cpu_oracle_for_region(&prog, entry, 32).unwrap();+ assert!(+ structural_ops_match_classic(&code, &classic),+ "classic decompile_instructions ops must match multipass IR"+ );+ let _ = std::fs::remove_file(&out);+ }++ #[test]+ fn gpu_branchy_code_region_equivalence() {+ // Real GPU path on branchy bytes — not PE entry, not multipass-only.+ // xor; je +4; xor; ret; pop; ret → multiple blocks + jcc edges+ let code = vec![0x31, 0xc0, 0x74, 0x04, 0x31, 0xc0, 0xc3, 0x5d, 0xc3];+ let entry = 0x1000u64;+ let multi = multipass_cpu_decompile_from_code("br", entry, &code);+ assert!(+ multi.pseudo_c.contains("goto block_") && multi.pseudo_c.contains("if (/* jcc */)"),+ "multipass branchy emit:\n{}",+ multi.pseudo_c+ );+ assert!(+ multi.blocks.len() >= 2,+ "expected ≥2 blocks, got {}",+ multi.blocks.len()+ );++ let out = temp_dir().join(format!("gdec_br_{}.gdecomp", std::process::id()));+ let rep = gpu_decompile_code_to_file("br", entry, &code, &out).expect("gpu branchy");+ assert_eq!(+ rep.backend, "gpu_vram_multipass",+ "must run real GPU kernels on branchy region, got {} device={}",+ rep.backend, rep.device+ );+ assert_eq!(rep.mid_pipeline_host_reads, 0);+ assert!(+ rep.pseudo_c.contains("goto block_") && rep.pseudo_c.contains("if (/* jcc */)"),+ "GPU branchy pseudo_c incomplete:\n{}",+ rep.pseudo_c+ );+ assert!(+ rep.block_count >= 2,+ "GPU block_count={}, expected ≥2",+ rep.block_count+ );+ assert_eq!(+ normalize_pseudo(&rep.pseudo_c),+ normalize_pseudo(&multi.pseudo_c),+ "GPU dump must equal multipass on same branchy bytes\nGPU:\n{}\nCPU multipass:\n{}",+ rep.pseudo_c,+ multi.pseudo_c+ );+ let dump = std::fs::read(&out).unwrap();+ let from_file = decode_gdecomp_pseudo_c(&dump).unwrap();+ assert_eq!(normalize_pseudo(&from_file), normalize_pseudo(&rep.pseudo_c));+ let _ = std::fs::remove_file(&out);+ }++ #[test]+ fn shipped_entry_twice_consistent() {+ let prog = load_path(fixture_path("tiny_x64.pe")).unwrap();+ let a = temp_dir().join(format!("gdec_a_{}.gdecomp", std::process::id()));+ let b = temp_dir().join(format!("gdec_b_{}.gdecomp", std::process::id()));+ let r1 = gpu_decompile_to_file(&prog, None, &a, 64).unwrap();+ let r2 = gpu_decompile_to_file(&prog, None, &b, 64).unwrap();+ assert_eq!(r1.backend, "gpu_vram_multipass");+ assert_eq!(r2.backend, "gpu_vram_multipass");+ assert_eq!(normalize_pseudo(&r1.pseudo_c), normalize_pseudo(&r2.pseudo_c));+ assert!(a.is_file() && b.is_file());+ let _ = std::fs::remove_file(&a);+ let _ = std::fs::remove_file(&b);+ }+}diff --git a/crates/ghidrust-decomp/src/gpu_decompile.wgsl b/crates/ghidrust-decomp/src/gpu_decompile.wgslnew file mode 100644index 0000000..5ab9579--- /dev/null+++ b/crates/ghidrust-decomp/src/gpu_decompile.wgsl@@ -0,0 +1,401 @@+// Multi-pass GPU decompile kernels — all buffers stay in VRAM until final emit readback.+// Stages: decode_walk → mark_leaders → build_blocks → emit_text++struct Params {+ ncode: u32,+ max_ir: u32,+ max_blocks: u32,+ max_emit: u32,+ entry_lo: u32,+ entry_hi: u32,+ _p0: u32,+ _p1: u32,+}++struct IrSlot {+ valid: u32,+ off: u32,+ length: u32,+ opcode: u32,+ imm: u32,+ has_imm: u32,+ _pad0: u32,+ _pad1: u32,+}++@group(0) @binding(0) var<storage, read> code: array<u32>; // packed bytes as u32 words+@group(0) @binding(1) var<storage, read_write> ir: array<IrSlot>;+@group(0) @binding(2) var<storage, read_write> leaders: array<u32>;+@group(0) @binding(3) var<storage, read_write> blocks: array<u32>; // 8 u32 per block+@group(0) @binding(4) var<storage, read_write> edges: array<u32>; // 4 u32 per edge+@group(0) @binding(5) var<storage, read_write> stage_meta: array<u32>; // ir_count,block_count,edge_count,emit_len+@group(0) @binding(6) var<storage, read_write> emit: array<u32>; // packed ASCII+@group(0) @binding(7) var<uniform> params: Params;++const OP_PUSH: u32 = 1u;+const OP_MOV: u32 = 2u;+const OP_XOR: u32 = 3u;+const OP_POP: u32 = 4u;+const OP_RET: u32 = 5u;+const OP_INT3: u32 = 6u;+const OP_JMP: u32 = 7u;+const OP_JCC: u32 = 8u;+const OP_OTHER: u32 = 9u;++fn load_byte(off: u32) -> u32 {+ let word = code[off / 4u];+ let shift = (off % 4u) * 8u;+ return (word >> shift) & 0xffu;+}++fn store_byte(off: u32, b: u32) {+ // emit is u32 packed; atomic-less RMW for single-thread emit_text+ let idx = off / 4u;+ let shift = (off % 4u) * 8u;+ let mask = 0xffu << shift;+ let cur = emit[idx];+ emit[idx] = (cur & ~mask) | ((b & 0xffu) << shift);+}++fn i8_as_i32(b: u32) -> i32 {+ var v = i32(b);+ if ((b & 0x80u) != 0u) {+ v = v - 256;+ }+ return v;+}++// ── K1: sequential walk decode into IR slots (single workgroup) ──────────+@compute @workgroup_size(1)+fn decode_walk(@builtin(global_invocation_id) gid: vec3<u32>) {+ if (gid.x != 0u) { return; }+ var off: u32 = 0u;+ var n: u32 = 0u;+ loop {+ if (off >= params.ncode || n >= params.max_ir) { break; }+ let b0 = load_byte(off);+ var len: u32 = 1u;+ var op: u32 = OP_OTHER;+ var imm: u32 = 0u;+ var has_imm: u32 = 0u;++ if (b0 == 0xc3u) {+ op = OP_RET; len = 1u;+ } else if (b0 == 0xccu) {+ op = OP_INT3; len = 1u;+ } else if (b0 >= 0x50u && b0 <= 0x57u) {+ op = OP_PUSH; len = 1u;+ } else if (b0 >= 0x58u && b0 <= 0x5fu) {+ op = OP_POP; len = 1u;+ } else if (b0 == 0x48u && off + 2u < params.ncode && load_byte(off + 1u) == 0x89u) {+ op = OP_MOV; len = 3u;+ } else if (b0 == 0x31u && off + 1u < params.ncode) {+ op = OP_XOR; len = 2u;+ } else if (b0 == 0xebu && off + 1u < params.ncode) {+ op = OP_JMP; len = 2u; has_imm = 1u;+ imm = u32(i8_as_i32(load_byte(off + 1u)));+ } else if (b0 == 0xe9u && off + 4u < params.ncode) {+ op = OP_JMP; len = 5u; has_imm = 1u;+ imm = load_byte(off + 1u)+ | (load_byte(off + 2u) << 8u)+ | (load_byte(off + 3u) << 16u)+ | (load_byte(off + 4u) << 24u);+ } else if (b0 >= 0x70u && b0 <= 0x7fu && off + 1u < params.ncode) {+ op = OP_JCC; len = 2u; has_imm = 1u;+ imm = u32(i8_as_i32(load_byte(off + 1u)));+ } else if (b0 == 0x0fu && off + 5u < params.ncode) {+ let b1 = load_byte(off + 1u);+ if (b1 >= 0x80u && b1 <= 0x8fu) {+ op = OP_JCC; len = 6u; has_imm = 1u;+ imm = load_byte(off + 2u)+ | (load_byte(off + 3u) << 8u)+ | (load_byte(off + 4u) << 16u)+ | (load_byte(off + 5u) << 24u);+ }+ }++ ir[n] = IrSlot(1u, off, len, op, imm, has_imm, 0u, 0u);+ n = n + 1u;+ if (op == OP_RET) { break; }+ off = off + len;+ }+ stage_meta[0] = n; // ir_count+}++// ── K2: mark leaders (parallel over IR slots) ────────────────────────────+// Race-free: buffer is zero-initialized; threads ONLY write 1 (never 0).+// Writing 0 would clobber another thread's branch-target mark.+@compute @workgroup_size(256)+fn mark_leaders(@builtin(global_invocation_id) gid: vec3<u32>) {+ let i = gid.x;+ let n = stage_meta[0];+ if (i >= n) { return; }++ // entry is always a leader+ if (i == 0u) {+ leaders[0] = 1u;+ }+ // fall-through after terminator is a leader+ if (i > 0u) {+ let prev = ir[i - 1u];+ if (prev.opcode == OP_RET || prev.opcode == OP_JMP || prev.opcode == OP_JCC) {+ leaders[i] = 1u;+ }+ }+ // branch targets are leaders (only write 1)+ if (ir[i].has_imm == 1u && (ir[i].opcode == OP_JMP || ir[i].opcode == OP_JCC)) {+ let target_off = i32(ir[i].off) + i32(ir[i].length) + i32(ir[i].imm);+ for (var j: u32 = 0u; j < n; j = j + 1u) {+ if (i32(ir[j].off) == target_off) {+ leaders[j] = 1u;+ }+ }+ }+}++// ── K3: compact leaders into block table + edges (single thread) ──────────+@compute @workgroup_size(1)+fn build_blocks(@builtin(global_invocation_id) gid: vec3<u32>) {+ if (gid.x != 0u) { return; }+ let n = stage_meta[0];+ var bc: u32 = 0u;+ var ec: u32 = 0u;+ var starts: array<u32, 64>;+ var ns: u32 = 0u;+ for (var i: u32 = 0u; i < n; i = i + 1u) {+ if (leaders[i] == 1u && ns < 64u) {+ starts[ns] = i;+ ns = ns + 1u;+ }+ }+ if (ns == 0u && n > 0u) {+ starts[0] = 0u;+ ns = 1u;+ }+ for (var b: u32 = 0u; b < ns && b < params.max_blocks; b = b + 1u) {+ let si = starts[b];+ var ei = n;+ if (b + 1u < ns) { ei = starts[b + 1u]; }+ let first = ir[si];+ let last = ir[ei - 1u];+ let base = b * 8u;+ blocks[base + 0u] = first.off;+ blocks[base + 1u] = last.off + last.length;+ blocks[base + 2u] = si;+ blocks[base + 3u] = ei - si;+ blocks[base + 4u] = select(0u, 1u, last.opcode == OP_RET);+ blocks[base + 5u] = select(0u, 1u, last.opcode == OP_JMP || last.opcode == OP_JCC);+ blocks[base + 6u] = 0u;+ blocks[base + 7u] = 0u;+ bc = bc + 1u;++ // edges+ if (last.opcode != OP_RET && ec < params.max_blocks * 2u) {+ if (last.opcode == OP_JMP && last.has_imm == 1u) {+ let target_off = i32(last.off) + i32(last.length) + i32(last.imm);+ for (var t: u32 = 0u; t < ns; t = t + 1u) {+ if (i32(ir[starts[t]].off) == target_off && ec < 128u) {+ let ebase = ec * 4u;+ edges[ebase + 0u] = b;+ edges[ebase + 1u] = t;+ edges[ebase + 2u] = 1u; // jmp+ edges[ebase + 3u] = 0u;+ ec = ec + 1u;+ }+ }+ } else if (last.opcode == OP_JCC && last.has_imm == 1u) {+ let target_off = i32(last.off) + i32(last.length) + i32(last.imm);+ for (var t: u32 = 0u; t < ns; t = t + 1u) {+ if (i32(ir[starts[t]].off) == target_off && ec < 128u) {+ let ebase = ec * 4u;+ edges[ebase + 0u] = b;+ edges[ebase + 1u] = t;+ edges[ebase + 2u] = 2u; // jcc_taken+ edges[ebase + 3u] = 0u;+ ec = ec + 1u;+ }+ }+ if (b + 1u < ns && ec < 128u) {+ let ebase = ec * 4u;+ edges[ebase + 0u] = b;+ edges[ebase + 1u] = b + 1u;+ edges[ebase + 2u] = 3u; // fall+ edges[ebase + 3u] = 0u;+ ec = ec + 1u;+ }+ } else if (b + 1u < ns && ec < 128u) {+ let ebase = ec * 4u;+ edges[ebase + 0u] = b;+ edges[ebase + 1u] = b + 1u;+ edges[ebase + 2u] = 3u;+ edges[ebase + 3u] = 0u;+ ec = ec + 1u;+ }+ }+ }+ stage_meta[1] = bc;+ stage_meta[2] = ec;+}++fn append_char(pos: ptr<function, u32>, ch: u32) {+ if (*pos < params.max_emit) {+ store_byte(*pos, ch);+ *pos = *pos + 1u;+ }+}++fn append_str(pos: ptr<function, u32>, s: ptr<function, array<u32, 64>>, n: u32) {+ for (var i: u32 = 0u; i < n; i = i + 1u) {+ append_char(pos, (*s)[i]);+ }+}++fn append_lit(pos: ptr<function, u32>, lit: u32) {+ // pack up to 4 ASCII in a u32 little-endian+ append_char(pos, lit & 0xffu);+ let b1 = (lit >> 8u) & 0xffu;+ if (b1 != 0u) { append_char(pos, b1); }+ let b2 = (lit >> 16u) & 0xffu;+ if (b2 != 0u) { append_char(pos, b2); }+ let b3 = (lit >> 24u) & 0xffu;+ if (b3 != 0u) { append_char(pos, b3); }+}++// ── K4: emit pseudo-C into device text buffer (single thread) ────────────+@compute @workgroup_size(1)+fn emit_text(@builtin(global_invocation_id) gid: vec3<u32>) {+ if (gid.x != 0u) { return; }+ var pos: u32 = 0u;+ let bc = stage_meta[1];+ let n = stage_meta[0];++ // header lines (ASCII)+ // "// GPU decompile\nvoid FUN(void) {\n"+ let h1 = array<u32, 32>(+ 0x2f,0x2f,0x20,0x47,0x50,0x55,0x20,0x64,0x65,0x63,0x6f,0x6d,0x70,0x69,0x6c,0x65,+ 0x0a,0x76,0x6f,0x69,0x64,0x20,0x46,0x55,0x4e,0x28,0x76,0x6f,0x69,0x64,0x29,0x20+ );+ for (var i: u32 = 0u; i < 32u; i = i + 1u) { append_char(&pos, h1[i]); }+ append_char(&pos, 0x7bu); // {+ append_char(&pos, 0x0au);++ for (var b: u32 = 0u; b < bc; b = b + 1u) {+ let base = b * 8u;+ let si = blocks[base + 2u];+ let cnt = blocks[base + 3u];+ // " // block_N\n block_N:\n"+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x2fu); append_char(&pos, 0x2fu); append_char(&pos, 0x20u);+ // block_+ append_char(&pos, 0x62u); append_char(&pos, 0x6cu); append_char(&pos, 0x6fu);+ append_char(&pos, 0x63u); append_char(&pos, 0x6bu); append_char(&pos, 0x5fu);+ append_char(&pos, 0x30u + (b % 10u));+ append_char(&pos, 0x0au);+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x62u); append_char(&pos, 0x6cu); append_char(&pos, 0x6fu);+ append_char(&pos, 0x63u); append_char(&pos, 0x6bu); append_char(&pos, 0x5fu);+ append_char(&pos, 0x30u + (b % 10u));+ append_char(&pos, 0x3au); append_char(&pos, 0x0au);++ for (var k: u32 = 0u; k < cnt; k = k + 1u) {+ let slot = ir[si + k];+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ if (slot.opcode == OP_RET) {+ // return;+ append_char(&pos, 0x72u); append_char(&pos, 0x65u); append_char(&pos, 0x74u);+ append_char(&pos, 0x75u); append_char(&pos, 0x72u); append_char(&pos, 0x6eu);+ append_char(&pos, 0x3bu); append_char(&pos, 0x0au);+ } else if (slot.opcode == OP_JCC) {+ // if (/* jcc */) { goto block_T; } // fall → block_F+ var taken: u32 = 0xffffffffu;+ var fall: u32 = 0xffffffffu;+ let ec = stage_meta[2];+ for (var e: u32 = 0u; e < ec; e = e + 1u) {+ let ebase = e * 4u;+ if (edges[ebase + 0u] == b) {+ if (edges[ebase + 2u] == 2u) { taken = edges[ebase + 1u]; }+ if (edges[ebase + 2u] == 3u) { fall = edges[ebase + 1u]; }+ }+ }+ append_char(&pos, 0x69u); append_char(&pos, 0x66u); append_char(&pos, 0x20u);+ append_char(&pos, 0x28u); append_char(&pos, 0x2fu); append_char(&pos, 0x2au);+ append_char(&pos, 0x20u); append_char(&pos, 0x6au); append_char(&pos, 0x63u);+ append_char(&pos, 0x63u); append_char(&pos, 0x20u); append_char(&pos, 0x2au);+ append_char(&pos, 0x2fu); append_char(&pos, 0x29u); append_char(&pos, 0x20u);+ append_char(&pos, 0x7bu); append_char(&pos, 0x0au);+ // " goto block_T;\n"+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x67u); append_char(&pos, 0x6fu); append_char(&pos, 0x74u);+ append_char(&pos, 0x6fu); append_char(&pos, 0x20u);+ append_char(&pos, 0x62u); append_char(&pos, 0x6cu); append_char(&pos, 0x6fu);+ append_char(&pos, 0x63u); append_char(&pos, 0x6bu); append_char(&pos, 0x5fu);+ if (taken != 0xffffffffu) {+ append_char(&pos, 0x30u + (taken % 10u));+ } else {+ append_char(&pos, 0x3fu);+ }+ append_char(&pos, 0x3bu); append_char(&pos, 0x0au);+ // "}\n"+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x7du); append_char(&pos, 0x0au);+ // "// fall block_F\n" (matches CPU multipass emit)+ if (fall != 0xffffffffu) {+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x20u); append_char(&pos, 0x20u);+ append_char(&pos, 0x2fu); append_char(&pos, 0x2fu); append_char(&pos, 0x20u);+ append_char(&pos, 0x66u); append_char(&pos, 0x61u); append_char(&pos, 0x6cu);+ append_char(&pos, 0x6cu); append_char(&pos, 0x20u);+ append_char(&pos, 0x62u); append_char(&pos, 0x6cu); append_char(&pos, 0x6fu);+ append_char(&pos, 0x63u); append_char(&pos, 0x6bu); append_char(&pos, 0x5fu);+ append_char(&pos, 0x30u + (fall % 10u));+ append_char(&pos, 0x0au);+ }+ } else if (slot.opcode == OP_JMP) {+ var taken: u32 = 0xffffffffu;+ let ec = stage_meta[2];+ for (var e: u32 = 0u; e < ec; e = e + 1u) {+ let ebase = e * 4u;+ if (edges[ebase + 0u] == b && edges[ebase + 2u] == 1u) {+ taken = edges[ebase + 1u];+ }+ }+ append_char(&pos, 0x67u); append_char(&pos, 0x6fu); append_char(&pos, 0x74u);+ append_char(&pos, 0x6fu); append_char(&pos, 0x20u);+ append_char(&pos, 0x62u); append_char(&pos, 0x6cu); append_char(&pos, 0x6fu);+ append_char(&pos, 0x63u); append_char(&pos, 0x6bu); append_char(&pos, 0x5fu);+ if (taken != 0xffffffffu) {+ append_char(&pos, 0x30u + (taken % 10u));+ } else {+ append_char(&pos, 0x3fu);+ }+ append_char(&pos, 0x3bu); append_char(&pos, 0x0au);+ } else {+ // /* op */;+ append_char(&pos, 0x2fu); append_char(&pos, 0x2au); append_char(&pos, 0x20u);+ if (slot.opcode == OP_PUSH) {+ append_char(&pos, 0x70u); append_char(&pos, 0x75u); append_char(&pos, 0x73u);+ append_char(&pos, 0x68u);+ } else if (slot.opcode == OP_MOV) {+ append_char(&pos, 0x6du); append_char(&pos, 0x6fu); append_char(&pos, 0x76u);+ } else if (slot.opcode == OP_XOR) {+ append_char(&pos, 0x78u); append_char(&pos, 0x6fu); append_char(&pos, 0x72u);+ } else if (slot.opcode == OP_POP) {+ append_char(&pos, 0x70u); append_char(&pos, 0x6fu); append_char(&pos, 0x70u);+ } else {+ append_char(&pos, 0x6fu); append_char(&pos, 0x70u);+ }+ append_char(&pos, 0x20u); append_char(&pos, 0x2au); append_char(&pos, 0x2fu);+ append_char(&pos, 0x3bu); append_char(&pos, 0x0au);+ }+ }+ append_char(&pos, 0x0au);+ }+ append_char(&pos, 0x7du); // }+ append_char(&pos, 0x0au);+ stage_meta[3] = pos; // emit_len+}+diff --git a/crates/ghidrust-decomp/src/lib.rs b/crates/ghidrust-decomp/src/lib.rsnew file mode 100644index 0000000..d1d236b--- /dev/null+++ b/crates/ghidrust-decomp/src/lib.rs@@ -0,0 +1,462 @@+//! Hand-rolled reverse-engineering **decompile method** (not Hex-Rays / Ghidra).+//!+//! ## CPU path+//! Linear instructions → basic blocks + branch edges → structured pseudo-C.+//!+//! ## GPU-resident path (`gpu_decompile`)+//! Multi-pass SIMT kernels keep IR/CFG/emit buffers in **VRAM**; host only uploads+//! code once and downloads the final dump. See `docs/GPU_DECOMPILE_PROCESS.md`.++pub mod gpu_decompile;++use ghidrust_core::{disassemble_range, Instruction, Program};+use serde::Serialize;+use std::collections::{BTreeMap, BTreeSet};++pub use gpu_decompile::{+ bench_vram_decompile_vs_cpu, classic_mnemonic_to_op, decode_gdecomp_pseudo_c,+ encode_gdecomp_dump, equivalence_multipass_vs_classic_code, gpu_decompile_code_to_file,+ gpu_decompile_to_file, mid_pipeline_host_read_count, multipass_cpu_decompile_from_code,+ normalize_pseudo, record_mid_pipeline_host_read, region_bytes, structural_ops_match_classic,+ DecompBenchRow, GpuDecompileReport, GDEC_MAGIC, GDEC_VERSION,+};++/// One basic block: closed instruction sequence with a single entry.+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]+pub struct BasicBlock {+ pub id: usize,+ pub start: u64,+ pub end: u64,+ pub instructions: Vec<Instruction>,+ /// Fall-through or taken targets (block ids).+ pub successors: Vec<usize>,+ pub is_return: bool,+ pub is_branch: bool,+}++/// Directed CFG edge.+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]+pub struct CfgEdge {+ pub from: usize,+ pub to: usize,+ pub kind: String,+}++/// Full decompile result for one function region.+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]+pub struct DecompileResult {+ pub name: String,+ pub entry: u64,+ pub blocks: Vec<BasicBlock>,+ pub edges: Vec<CfgEdge>,+ /// High-level-ish pseudo source (C-like).+ pub pseudo_c: String,+ pub insn_count: usize,+}++impl DecompileResult {+ pub fn line_count(&self) -> usize {+ self.pseudo_c.lines().count()+ }+ pub fn char_count(&self) -> usize {+ self.pseudo_c.len()+ }+}++/// Decompile a pre-decoded instruction list (unit-testable without PE I/O).+pub fn decompile_instructions(+ name: impl Into<String>,+ entry: u64,+ insns: &[Instruction],+) -> DecompileResult {+ let name = name.into();+ // Stop at first ret so post-function padding (int3) is not structured as code.+ let end = insns+ .iter()+ .position(|i| is_ret(&i.mnemonic))+ .map(|i| i + 1)+ .unwrap_or(insns.len());+ let insns = &insns[..end];+ if insns.is_empty() {+ return DecompileResult {+ name,+ entry,+ blocks: Vec::new(),+ edges: Vec::new(),+ pseudo_c: format!(+ "// function at {entry:#x}\n// empty region — no instructions recovered\n"+ ),+ insn_count: 0,+ };+ }++ let leaders = collect_leaders(insns, entry);+ let blocks = split_blocks(insns, &leaders);+ let (blocks, edges) = wire_successors(blocks, insns);+ let pseudo_c = emit_pseudo_c(&name, entry, &blocks, &edges);++ DecompileResult {+ name,+ entry,+ insn_count: insns.len(),+ blocks,+ edges,+ pseudo_c,+ }+}++/// Load-independent entry: decode `max_insns` from `va` then decompile.+pub fn decompile_at(prog: &Program, va: u64, max_insns: usize) -> ghidrust_core::Result<DecompileResult> {+ let insns = disassemble_range(prog, va, max_insns)?;+ let name = prog+ .analysis+ .functions+ .iter()+ .find(|f| f.entry == va)+ .map(|f| f.name.clone())+ .unwrap_or_else(|| format!("FUN_{va:016x}"));+ Ok(decompile_instructions(name, va, &insns))+}++/// Convenience: decompile program entry point.+pub fn decompile_entry(prog: &Program, max_insns: usize) -> ghidrust_core::Result<DecompileResult> {+ let va = prog.entry.unwrap_or(prog.image_base);+ decompile_at(prog, va, max_insns)+}++fn is_uncond_jmp(m: &str) -> bool {+ m == "jmp"+}++fn is_cond_jmp(m: &str) -> bool {+ matches!(+ m,+ "je" | "jne"+ | "jz"+ | "jnz"+ | "ja"+ | "jae"+ | "jb"+ | "jbe"+ | "jg"+ | "jge"+ | "jl"+ | "jle"+ | "jo"+ | "jno"+ | "js"+ | "jns"+ | "jp"+ | "jnp"+ | "jcxz"+ | "jecxz"+ | "jrcxz"+ )+}++fn is_ret(m: &str) -> bool {+ m == "ret" || m == "retn" || m == "retf"+}++fn parse_branch_target(op: &str) -> Option<u64> {+ let t = op.trim();+ if t.is_empty() {+ return None;+ }+ // "0x140001234" or "140001234" or decimal+ let t = t.trim_start_matches("0x").trim_start_matches("0X");+ u64::from_str_radix(t, 16).ok().or_else(|| t.parse().ok())+}++fn collect_leaders(insns: &[Instruction], entry: u64) -> BTreeSet<u64> {+ let mut leaders = BTreeSet::new();+ leaders.insert(entry);+ if let Some(first) = insns.first() {+ leaders.insert(first.address);+ }+ for (i, insn) in insns.iter().enumerate() {+ let m = insn.mnemonic.as_str();+ if is_cond_jmp(m) || is_uncond_jmp(m) {+ if let Some(t) = parse_branch_target(&insn.operands) {+ leaders.insert(t);+ }+ // fall-through is a leader after conditional+ if is_cond_jmp(m) {+ if let Some(next) = insns.get(i + 1) {+ leaders.insert(next.address);+ }+ }+ } else if is_ret(m) {+ if let Some(next) = insns.get(i + 1) {+ leaders.insert(next.address);+ }+ } else if m == "call" {+ // call does not force a new leader after in simple model (fall-through continues)+ }+ }+ leaders+}++fn split_blocks(insns: &[Instruction], leaders: &BTreeSet<u64>) -> Vec<BasicBlock> {+ if insns.is_empty() {+ return Vec::new();+ }+ let mut starts: Vec<usize> = Vec::new();+ for (i, insn) in insns.iter().enumerate() {+ if leaders.contains(&insn.address) || i == 0 {+ starts.push(i);+ }+ }+ starts.sort_unstable();+ starts.dedup();++ let mut blocks = Vec::new();+ for (bi, &si) in starts.iter().enumerate() {+ let ei = starts.get(bi + 1).copied().unwrap_or(insns.len());+ let slice = &insns[si..ei];+ if slice.is_empty() {+ continue;+ }+ let last = slice.last().unwrap();+ let is_return = is_ret(&last.mnemonic);+ let is_branch = is_cond_jmp(&last.mnemonic) || is_uncond_jmp(&last.mnemonic);+ blocks.push(BasicBlock {+ id: blocks.len(),+ start: slice[0].address,+ end: last.address + last.length as u64,+ instructions: slice.to_vec(),+ successors: Vec::new(),+ is_return,+ is_branch,+ });+ }+ // re-id+ for (i, b) in blocks.iter_mut().enumerate() {+ b.id = i;+ }+ blocks+}++fn wire_successors(+ mut blocks: Vec<BasicBlock>,+ _insns: &[Instruction],+) -> (Vec<BasicBlock>, Vec<CfgEdge>) {+ let by_start: BTreeMap<u64, usize> = blocks.iter().map(|b| (b.start, b.id)).collect();+ let mut edges = Vec::new();++ for i in 0..blocks.len() {+ let last = match blocks[i].instructions.last() {+ Some(x) => x.clone(),+ None => continue,+ };+ let m = last.mnemonic.as_str();+ if is_ret(m) {+ continue;+ }+ if is_uncond_jmp(m) {+ if let Some(t) = parse_branch_target(&last.operands) {+ if let Some(&tid) = by_start.get(&t) {+ blocks[i].successors.push(tid);+ edges.push(CfgEdge {+ from: i,+ to: tid,+ kind: "jmp".into(),+ });+ }+ }+ continue;+ }+ if is_cond_jmp(m) {+ if let Some(t) = parse_branch_target(&last.operands) {+ if let Some(&tid) = by_start.get(&t) {+ blocks[i].successors.push(tid);+ edges.push(CfgEdge {+ from: i,+ to: tid,+ kind: "jcc_taken".into(),+ });+ }+ }+ // fall-through+ if let Some(next) = blocks.get(i + 1) {+ let nid = next.id;+ blocks[i].successors.push(nid);+ edges.push(CfgEdge {+ from: i,+ to: nid,+ kind: "jcc_fall".into(),+ });+ }+ continue;+ }+ // sequential fall-through+ if let Some(next) = blocks.get(i + 1) {+ let nid = next.id;+ blocks[i].successors.push(nid);+ edges.push(CfgEdge {+ from: i,+ to: nid,+ kind: "fall".into(),+ });+ }+ }+ (blocks, edges)+}++fn emit_pseudo_c(name: &str, entry: u64, blocks: &[BasicBlock], edges: &[CfgEdge]) -> String {+ let mut out = String::new();+ out.push_str(&format!("// Ghidrust hand-rolled decompile — function {name} at {entry:#x}\n"));+ out.push_str(&format!(+ "// blocks={} edges={} insns={}\n",+ blocks.len(),+ edges.len(),+ blocks.iter().map(|b| b.instructions.len()).sum::<usize>()+ ));+ out.push_str(&format!("void {name}(void) {{\n"));++ for b in blocks {+ out.push_str(&format!(" // block_{} @ {:#x}\n", b.id, b.start));+ out.push_str(&format!(" block_{}:\n", b.id));+ for insn in &b.instructions {+ let m = insn.mnemonic.as_str();+ if is_ret(m) {+ out.push_str(" return;\n");+ continue;+ }+ if is_uncond_jmp(m) {+ if let Some(t) = parse_branch_target(&insn.operands) {+ if let Some(tb) = blocks.iter().find(|x| x.start == t) {+ out.push_str(&format!(" goto block_{};\n", tb.id));+ continue;+ }+ }+ out.push_str(&format!(" goto /* {} */;\n", insn.operands));+ continue;+ }+ if is_cond_jmp(m) {+ let taken = parse_branch_target(&insn.operands)+ .and_then(|t| blocks.iter().find(|x| x.start == t).map(|x| x.id));+ let fall = b+ .successors+ .iter()+ .copied()+ .find(|&s| Some(s) != taken);+ out.push_str(&format!(+ " if (/* {} {} */) {{\n",+ insn.mnemonic, insn.operands+ ));+ if let Some(tid) = taken {+ out.push_str(&format!(" goto block_{tid};\n"));+ } else {+ out.push_str(&format!(+ " /* branch {} {} */;\n",+ insn.mnemonic, insn.operands+ ));+ }+ out.push_str(" }\n");+ if let Some(fid) = fall {+ out.push_str(&format!(" // else fall → block_{fid}\n"));+ }+ continue;+ }+ // Expression-ish: present decoded insn as statement+ if insn.operands.is_empty() {+ out.push_str(&format!(" /* {} */;\n", insn.mnemonic));+ } else {+ out.push_str(&format!(+ " /* {} {} */;\n",+ insn.mnemonic, insn.operands+ ));+ }+ }+ if !b.is_return && !b.is_branch && b.successors.len() == 1 {+ // implicit fall already sequential in emission order when linear+ }+ out.push('\n');+ }+ out.push_str("}\n");+ out+}++#[cfg(test)]+mod tests {+ use super::*;+ use ghidrust_core::{fixture_path, load_path};++ fn insn(addr: u64, mnem: &str, ops: &str, len: u8) -> Instruction {+ Instruction {+ address: addr,+ bytes: vec![0; len as usize],+ mnemonic: mnem.into(),+ operands: ops.into(),+ length: len,+ }+ }++ #[test]+ fn synthetic_linear_has_block_and_return() {+ let insns = vec![+ insn(0x1000, "push", "rbp", 1),+ insn(0x1001, "mov", "rbp, rsp", 3),+ insn(0x1004, "xor", "eax, eax", 2),+ insn(0x1006, "pop", "rbp", 1),+ insn(0x1007, "ret", "", 1),+ ];+ let d = decompile_instructions("test_fn", 0x1000, &insns);+ assert_eq!(d.entry, 0x1000);+ assert!(!d.blocks.is_empty());+ assert!(d.insn_count >= 5);+ assert!(d.pseudo_c.contains("void test_fn"));+ assert!(d.pseudo_c.contains("block_0"));+ assert!(d.pseudo_c.contains("return;"));+ assert!(d.pseudo_c.contains(&format!("{:#x}", 0x1000)) || d.pseudo_c.contains("0x1000"));+ assert!(d.line_count() > 3);+ }++ #[test]+ fn synthetic_branch_creates_edges() {+ let insns = vec![+ insn(0x2000, "cmp", "eax, 0", 3),+ insn(0x2003, "je", "0x2010", 2),+ insn(0x2005, "mov", "eax, 1", 5),+ insn(0x200a, "ret", "", 1),+ insn(0x2010, "xor", "eax, eax", 2),+ insn(0x2012, "ret", "", 1),+ ];+ let d = decompile_instructions("branchy", 0x2000, &insns);+ assert!(d.blocks.len() >= 2, "expected multiple blocks, got {}", d.blocks.len());+ assert!(!d.edges.is_empty(), "expected CFG edges");+ assert!(d.pseudo_c.contains("if (") || d.pseudo_c.contains("goto block_"));+ assert!(d.pseudo_c.contains("branchy"));+ }++ #[test]+ fn fixture_entry_decompiles_nonempty() {+ let prog = load_path(fixture_path("tiny_x64.pe")).expect("load pe");+ let d = decompile_entry(&prog, 32).expect("decomp");+ assert!(d.insn_count > 0, "no instructions");+ assert!(!d.blocks.is_empty());+ assert!(!d.pseudo_c.is_empty());+ assert!(d.pseudo_c.contains("void "));+ assert!(d.pseudo_c.contains("block_"));+ // entry identity present+ let entry = prog.entry.unwrap();+ assert_eq!(d.entry, entry);+ assert!(+ d.pseudo_c.contains(&format!("{entry:#x}"))+ || d.pseudo_c.contains("function")+ || d.pseudo_c.contains("FUN_"),+ "missing function identity in {}",+ d.pseudo_c+ );+ // structure markers from real decode of fixture+ assert!(+ d.blocks.iter().any(|b| {+ b.instructions+ .iter()+ .any(|i| i.mnemonic == "push" || i.mnemonic == "ret")+ }),+ "expected push/ret from tiny_x64 entry"+ );+ }+}diff --git a/crates/ghidrust-gui/Cargo.toml b/crates/ghidrust-gui/Cargo.tomlnew file mode 100644index 0000000..6e95cf1--- /dev/null+++ b/crates/ghidrust-gui/Cargo.toml@@ -0,0 +1,16 @@+[package]+name = "ghidrust-gui"+version.workspace = true+edition.workspace = true+license.workspace = true+description = "Ghidrust egui CodeBrowser-lite UI"++[[bin]]+name = "ghidrust-gui"+path = "src/main.rs"++[dependencies]+ghidrust-core = { workspace = true, features = ["gpu"] }+eframe = { version = "0.31", default-features = true }+egui = "0.31"+rfd = "0.15"diff --git a/crates/ghidrust-gui/src/icons.rs b/crates/ghidrust-gui/src/icons.rsnew file mode 100644index 0000000..c87078f--- /dev/null+++ b/crates/ghidrust-gui/src/icons.rs@@ -0,0 +1,113 @@+//! Google Material Design / Material 3 icon SVGs (24×24 viewBox), painted with egui.+//! Source paths: https://github.com/google/material-design-icons (Apache-2.0).+//! No emoji. No extra icon crates — paths are inlined and stroked/filled via Painter.++use eframe::egui::{self, Color32, Pos2, Rect, Sense, Stroke, Ui, Vec2};++/// Material Icons 24dp viewBox.+const VB: f32 = 24.0;++#[derive(Clone, Copy)]+pub enum M3Icon {+ /// material: folder+ Folder,+ /// material: check_circle (filled check for "analyzed")+ CheckCircle,+ /// material: radio_button_unchecked (hollow for "not analyzed")+ RadioUnchecked,+ /// material: play_arrow (active / current file)+ PlayArrow,+}++/// Paint a Material 3 icon at the cursor; advances UI by `size`.+pub fn m3_icon(ui: &mut Ui, icon: M3Icon, size: f32, color: Color32) -> egui::Response {+ let (rect, response) = ui.allocate_exact_size(Vec2::splat(size), Sense::hover());+ if ui.is_rect_visible(rect) {+ paint_icon(ui.painter(), rect, icon, color);+ }+ response+}++fn paint_icon(painter: &egui::Painter, rect: Rect, icon: M3Icon, color: Color32) {+ let s = rect.width().min(rect.height());+ let origin = rect.center() - Vec2::splat(s * 0.5);+ let map = |x: f32, y: f32| -> Pos2 {+ Pos2::new(origin.x + x / VB * s, origin.y + y / VB * s)+ };+ let stroke = Stroke::new((s / VB) * 1.75, color);++ match icon {+ M3Icon::Folder => {+ // Path: M10 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2h-8l-2-2z+ let pts = [+ map(10.0, 4.0),+ map(4.0, 4.0),+ map(2.0, 6.0),+ map(2.0, 18.0),+ map(4.0, 20.0),+ map(20.0, 20.0),+ map(22.0, 18.0),+ map(22.0, 8.0),+ map(20.0, 6.0),+ map(12.0, 6.0),+ map(10.0, 4.0),+ ];+ painter.add(egui::Shape::convex_polygon(pts.to_vec(), color.gamma_multiply(0.35), stroke));+ }+ M3Icon::CheckCircle => {+ // Outer circle fill + check mark+ let c = map(12.0, 12.0);+ let r = (s / VB) * 9.0;+ painter.circle_filled(c, r, color);+ // check: (9,12) -> (11,14) -> (16,9) — white on colored circle+ let ink = if color.r() as u16 + color.g() as u16 + color.b() as u16 > 400 {+ Color32::from_rgb(0x1C, 0x1B, 0x1F)+ } else {+ Color32::from_rgb(0xFF, 0xFB, 0xFE)+ };+ let check_stroke = Stroke::new((s / VB) * 2.0, ink);+ painter.line_segment([map(9.0, 12.0), map(11.0, 14.5)], check_stroke);+ painter.line_segment([map(11.0, 14.5), map(16.0, 9.0)], check_stroke);+ }+ M3Icon::RadioUnchecked => {+ let c = map(12.0, 12.0);+ let r = (s / VB) * 8.5;+ painter.circle_stroke(c, r, stroke);+ }+ M3Icon::PlayArrow => {+ // Triangle pointing right: (8,5) (8,19) (19,12)+ let pts = [map(8.0, 5.0), map(8.0, 19.0), map(19.0, 12.0)];+ painter.add(egui::Shape::convex_polygon(pts.to_vec(), color, Stroke::NONE));+ }+ }+}++/// Material 3 linear progress indicator (4dp track + primary fill).+pub fn m3_linear_progress(ui: &mut Ui, fraction: f32, primary: Color32, track: Color32) {+ let height = 4.0;+ let width = ui.available_width().max(40.0);+ let (rect, _) = ui.allocate_exact_size(Vec2::new(width, height), Sense::hover());+ ui.painter()+ .rect_filled(rect, egui::CornerRadius::same(2), track);+ let f = fraction.clamp(0.0, 1.0);+ if f > 0.0 {+ let mut fill = rect;+ fill.set_width((rect.width() * f).max(if f > 0.0 { 2.0 } else { 0.0 }));+ ui.painter()+ .rect_filled(fill, egui::CornerRadius::same(2), primary);+ }+}++/// Status row: Material check_circle or radio_button_unchecked + label text (no emoji).+pub fn status_badge(ui: &mut Ui, analyzed: bool, analyzed_color: Color32, muted: Color32) {+ ui.horizontal(|ui| {+ ui.spacing_mut().item_spacing.x = 4.0;+ if analyzed {+ m3_icon(ui, M3Icon::CheckCircle, 14.0, analyzed_color);+ ui.label(egui::RichText::new("Analyzed").small().color(analyzed_color));+ } else {+ m3_icon(ui, M3Icon::RadioUnchecked, 14.0, muted);+ ui.label(egui::RichText::new("Not analyzed").small().color(muted));+ }+ });+}diff --git a/crates/ghidrust-gui/src/main.rs b/crates/ghidrust-gui/src/main.rsnew file mode 100644index 0000000..0d3b7c4--- /dev/null+++ b/crates/ghidrust-gui/src/main.rs@@ -0,0 +1,2190 @@+//! Ghidrust CodeBrowser shell — Material 3 Dark/Light, Ghidra-like menus/panes.+//! Icons: Google Material 3 geometry (see `icons.rs`); no emoji in the UI.++mod icons;++use eframe::egui::{self, Color32, Visuals};+use ghidrust_core::{+ analyzer_catalog, disassemble_range, load_path, m3_tokens, set_preferred_bulk_mode,+ AnalysisRunReport, AnalyzerInfo, BulkScanMode, FoundString,+ Instruction, Program, Project, ProjectTreeModel, RttiReport, ThemeMode,+};+use icons::{m3_icon, m3_linear_progress, status_badge, M3Icon};+use std::path::{Path, PathBuf};++fn recent_projects_path() -> PathBuf {+ // %APPDATA%/ghidrust/recent_projects.txt (or home fallback)+ if let Ok(appdata) = std::env::var("APPDATA") {+ PathBuf::from(appdata).join("ghidrust").join("recent_projects.txt")+ } else if let Ok(home) = std::env::var("USERPROFILE") {+ PathBuf::from(home)+ .join(".ghidrust")+ .join("recent_projects.txt")+ } else {+ PathBuf::from("ghidrust_recent_projects.txt")+ }+}++fn load_recent_projects() -> Vec<String> {+ let p = recent_projects_path();+ let Ok(text) = std::fs::read_to_string(&p) else {+ return Vec::new();+ };+ text.lines()+ .map(str::trim)+ .filter(|l| !l.is_empty() && Path::new(l).is_dir())+ .map(|s| s.to_string())+ .collect()+}++fn save_recent_projects(paths: &[String]) {+ let p = recent_projects_path();+ if let Some(parent) = p.parent() {+ let _ = std::fs::create_dir_all(parent);+ }+ let _ = std::fs::write(p, paths.join("\n"));+}++/// In-progress stepped analysis (one analyzer per frame for live M3 progress).+struct AnalysisJob {+ names: Vec<String>,+ index: usize,+ results: AnalysisRunReport,+ file_label: String,+ use_gpu: bool,+}++fn main() -> eframe::Result<()> {+ let opts = eframe::NativeOptions {+ viewport: egui::ViewportBuilder::default()+ .with_inner_size([1280.0, 800.0])+ .with_title("Ghidrust CodeBrowser"),+ ..Default::default()+ };+ eframe::run_native(+ "Ghidrust CodeBrowser",+ opts,+ Box::new(|cc| Ok(Box::new(GhidrustApp::new(cc)))),+ )+}++#[derive(Clone, Copy, PartialEq, Eq)]+enum CenterPane {+ /// File summary + analysis counts (default after open/analyze).+ Overview,+ Listing,+ Decompiler,+ DataTypes,+}++/// Root UI state bound to real analysis core (not a mock dataset).+pub struct GhidrustApp {+ path_input: String,+ project_dir_input: String,+ project_name_input: String,+ status: String,+ console: Vec<String>,+ theme: ThemeMode,+ project: Option<Project>,+ active_file_id: Option<String>,+ program: Option<Program>,+ listing: Vec<Instruction>,+ rtti: RttiReport,+ strings: Vec<FoundString>,+ last_analysis: AnalysisRunReport,+ last_analyzers_run: Vec<String>,+ analyzer_enabled: Vec<bool>,+ analyzer_infos: Vec<AnalyzerInfo>,+ center: CenterPane,+ show_project_tree: bool,+ show_program_tree: bool,+ show_symbol_tree: bool,+ show_console: bool,+ show_analysis_dialog: bool,+ /// Use experimental GPU bulk path for string/byte scan analyzers.+ use_gpu_experimental: bool,+ /// File id to open when user confirms analysis dialog (from Project Tree).+ pending_analyze_file_id: Option<String>,+ /// Live analysis job (progress UI while stepping).+ analysis_job: Option<AnalysisJob>,+ /// Tree selection (may differ from active until Open).+ tree_selected_id: Option<String>,+ project_tree_expanded: bool,+ /// Pending delete: (file id, display name) — shown in confirm dialog.+ pending_delete: Option<(String, String)>,+ /// Dismissible banner after analysis finishes.+ analysis_done_banner: Option<String>,+ /// RTTI panel filter (case-insensitive substring).+ rtti_filter: String,+ rtti_filter_cache: String,+ rtti_filtered_idx: Vec<usize>,+ /// Function list filter.+ fn_filter: String,+ /// First-run: pick/open a project before the empty shell.+ show_startup_picker: bool,+ recent_projects: Vec<String>,+ nyi_note: Option<String>,+}++impl GhidrustApp {+ pub fn new(cc: &eframe::CreationContext<'_>) -> Self {+ let mut app = Self::headless();+ app.recent_projects = load_recent_projects();+ app.show_startup_picker = true;+ app.status = "Select a project to begin".into();+ app.apply_theme(&cc.egui_ctx);+ app+ }++ pub fn headless() -> Self {+ let infos = analyzer_catalog();+ let enabled = infos.iter().map(|a| a.default_enabled).collect();+ Self {+ path_input: String::new(),+ project_dir_input: String::new(),+ project_name_input: "MyProject".into(),+ status: "Ready — File → New/Open Project, then Import binary".into(),+ console: vec!["Ghidrust CodeBrowser started.".into()],+ theme: ThemeMode::Dark,+ project: None,+ active_file_id: None,+ program: None,+ listing: Vec::new(),+ rtti: RttiReport::default(),+ strings: Vec::new(),+ last_analysis: AnalysisRunReport::default(),+ last_analyzers_run: Vec::new(),+ analyzer_enabled: enabled,+ analyzer_infos: infos,+ center: CenterPane::Overview,+ show_project_tree: true,+ show_program_tree: true,+ show_symbol_tree: true,+ show_console: true,+ show_analysis_dialog: false,+ use_gpu_experimental: false,+ pending_analyze_file_id: None,+ analysis_job: None,+ tree_selected_id: None,+ project_tree_expanded: true,+ pending_delete: None,+ analysis_done_banner: None,+ rtti_filter: String::new(),+ rtti_filter_cache: String::new(),+ rtti_filtered_idx: Vec::new(),+ fn_filter: String::new(),+ show_startup_picker: false,+ recent_projects: Vec::new(),+ nyi_note: None,+ }+ }++ fn remember_project(&mut self, dir: &str) {+ let dir = dir.trim().to_string();+ if dir.is_empty() {+ return;+ }+ self.recent_projects.retain(|p| p != &dir);+ self.recent_projects.insert(0, dir);+ self.recent_projects.truncate(12);+ save_recent_projects(&self.recent_projects);+ }++ fn rebuild_rtti_filter_cache(&mut self) {+ let q = self.rtti_filter.to_ascii_lowercase();+ if q == self.rtti_filter_cache && !self.rtti_filtered_idx.is_empty() {+ return;+ }+ self.rtti_filter_cache = q.clone();+ if q.is_empty() {+ self.rtti_filtered_idx = (0..self.rtti.classes.len()).collect();+ } else {+ self.rtti_filtered_idx = self+ .rtti+ .classes+ .iter()+ .enumerate()+ .filter(|(_, c)| c.name.to_ascii_lowercase().contains(&q))+ .map(|(i, _)| i)+ .collect();+ }+ }++ fn analysis_summary_line(&self) -> String {+ let fns = self+ .program+ .as_ref()+ .map(|p| p.analysis.functions.len())+ .unwrap_or(0);+ let rtti_n = self.rtti.classes.len();+ let str_n = self.strings.len();+ let list_n = self.listing.len();+ format!("{fns} functions · {rtti_n} RTTI · {str_n} strings · {list_n} listing lines")+ }++ fn browse_binary_path(&mut self) {+ if let Some(path) = rfd::FileDialog::new()+ .set_title("Open binary (PE / ELF)")+ .add_filter("Binaries", &["exe", "dll", "sys", "pe", "elf", "so", "bin"])+ .add_filter("All files", &["*"])+ .pick_file()+ {+ self.path_input = path.display().to_string();+ self.log(format!("Browsed binary: {}", self.path_input));+ }+ }++ fn browse_project_dir(&mut self) {+ if let Some(path) = rfd::FileDialog::new()+ .set_title("Select project folder")+ .pick_folder()+ {+ self.project_dir_input = path.display().to_string();+ self.log(format!("Browsed project dir: {}", self.project_dir_input));+ }+ }++ /// Browse for a binary and load it immediately (no project required).+ fn browse_and_load_binary(&mut self) {+ self.browse_binary_path();+ if !self.path_input.trim().is_empty() {+ if let Err(e) = self.load_binary(self.path_input.clone()) {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ }++ /// Browse folder then open project at that path.+ fn browse_and_open_project(&mut self) {+ self.browse_project_dir();+ if !self.project_dir_input.trim().is_empty() {+ if let Err(e) = self.open_project() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ }++ /// Browse folder then create project there.+ fn browse_and_create_project(&mut self) {+ self.browse_project_dir();+ if !self.project_dir_input.trim().is_empty() {+ if let Err(e) = self.create_project() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ }++ /// Browse binary then import into the open project.+ fn browse_and_import(&mut self) {+ self.browse_binary_path();+ if !self.path_input.trim().is_empty() {+ if let Err(e) = self.import_into_project() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ }++ /// Request delete with confirmation (does not delete yet).+ pub fn request_delete_file(&mut self, id: &str) {+ let name = self+ .project+ .as_ref()+ .and_then(|p| p.meta.files.iter().find(|f| f.id == id))+ .map(|f| f.display_name.clone())+ .unwrap_or_else(|| id.to_string());+ self.pending_delete = Some((id.to_string(), name));+ }++ /// Confirm pending delete: remove from project disk + clear UI if active.+ pub fn confirm_delete_file(&mut self) -> Result<(), String> {+ let (id, name) = self+ .pending_delete+ .take()+ .ok_or_else(|| "no pending delete".to_string())?;+ let was_active = self.active_file_id.as_deref() == Some(id.as_str());+ let entry = {+ let proj = self+ .project+ .as_mut()+ .ok_or_else(|| "no project open".to_string())?;+ proj.remove_file(&id).map_err(|e| e.to_string())?+ };+ self.log(format!("Deleted {} (id={})", entry.display_name, entry.id));+ if self.tree_selected_id.as_deref() == Some(id.as_str()) {+ self.tree_selected_id = None;+ }+ if was_active {+ self.program = None;+ self.listing.clear();+ self.strings.clear();+ self.rtti = RttiReport::default();+ let next = self+ .project+ .as_ref()+ .and_then(|p| p.meta.active_id.clone());+ self.active_file_id = next.clone();+ if let Some(next) = next {+ self.open_project_file(&next)?;+ } else {+ self.status = format!("Deleted {name} — project empty");+ }+ } else {+ self.status = format!("Deleted {name} from project");+ }+ Ok(())+ }++ pub fn cancel_delete_file(&mut self) {+ self.pending_delete = None;+ }++ /// Ghidra Project Window–style rows for the Project Tree (testable without a window).+ pub fn project_tree_model(&self) -> Option<ProjectTreeModel> {+ self.project.as_ref().map(|p| {+ let mut m = p.tree_rows();+ // Reflect GUI active selection if set+ if let Some(ref aid) = self.active_file_id {+ for f in &mut m.files {+ f.active = f.id == *aid;+ }+ }+ m+ })+ }++ /// Open binary from project tree selection (same path as file chips).+ pub fn open_from_tree(&mut self, id: &str) -> Result<(), String> {+ self.tree_selected_id = Some(id.to_string());+ self.open_project_file(id)+ }++ /// Open analysis options dialog for a project-tree file (does not run yet).+ pub fn analyze_from_tree(&mut self, id: &str) -> Result<(), String> {+ if self.analysis_job.is_some() {+ return Err("analysis already in progress".into());+ }+ self.tree_selected_id = Some(id.to_string());+ self.pending_analyze_file_id = Some(id.to_string());+ self.show_analysis_dialog = true;+ self.status = "Choose analyzers and options, then Run Analysis".into();+ Ok(())+ }++ /// Start stepped analysis from dialog selections (progress updates each frame).+ pub fn begin_analysis_job(&mut self) -> Result<(), String> {+ if self.analysis_job.is_some() {+ return Err("analysis already in progress".into());+ }+ if let Some(id) = self.pending_analyze_file_id.take() {+ self.open_from_tree(&id)?;+ }+ if self.program.is_none() {+ return Err("no program loaded — open or import a binary first".into());+ }+ let names: Vec<String> = self+ .analyzer_infos+ .iter()+ .zip(self.analyzer_enabled.iter())+ .filter(|(_, on)| **on)+ .map(|(a, _)| a.name.clone())+ .collect();+ if names.is_empty() {+ return Err("select at least one analyzer".into());+ }+ // Bulk mode is applied inside run_analyzers_opts per step when use_gpu.+ let file_label = self+ .program+ .as_ref()+ .map(|p| p.name.clone())+ .unwrap_or_else(|| "program".into());+ self.log(format!(+ "Starting analysis on {file_label}: {} analyzer(s), gpu={}",+ names.len(),+ self.use_gpu_experimental+ ));+ self.status = format!("Analyzing {file_label}…");+ self.analysis_job = Some(AnalysisJob {+ names,+ index: 0,+ results: AnalysisRunReport::default(),+ file_label,+ use_gpu: self.use_gpu_experimental,+ });+ Ok(())+ }++ /// Run one analyzer step; call every frame while `analysis_job` is Some.+ pub fn step_analysis_job(&mut self) -> Result<bool, String> {+ let (name, idx, total, label) = {+ let job = self+ .analysis_job+ .as_ref()+ .ok_or_else(|| "no analysis job".to_string())?;+ if job.index >= job.names.len() {+ self.finish_analysis_job()?;+ return Ok(true);+ }+ (+ job.names[job.index].clone(),+ job.index,+ job.names.len(),+ job.file_label.clone(),+ )+ };+ let use_gpu = self+ .analysis_job+ .as_ref()+ .map(|j| j.use_gpu)+ .unwrap_or(false);+ let prog = self+ .program+ .as_mut()+ .ok_or_else(|| "no program loaded".to_string())?;+ let report =+ ghidrust_core::run_analyzers_opts(prog, &[name.as_str()], use_gpu)+ .map_err(|e| e.to_string())?;+ let mut log_lines = Vec::new();+ let mut rtti_upd = None;+ let mut strings_upd = None;+ let mut outputs = Vec::new();+ for r in report.results {+ log_lines.push(format!("[{}] {} — {}", r.status, r.name, r.message));+ if r.rtti.is_some() {+ rtti_upd = r.rtti.clone();+ }+ if r.strings.is_some() {+ strings_upd = r.strings.clone();+ }+ outputs.push(r);+ }+ for line in log_lines {+ self.console.push(line);+ }+ if let Some(r) = rtti_upd {+ self.rtti = r;+ }+ if let Some(s) = strings_upd {+ self.strings = s;+ }+ if let Some(job) = self.analysis_job.as_mut() {+ job.results.results.extend(outputs);+ job.index = idx + 1;+ }+ let done = self+ .analysis_job+ .as_ref()+ .map(|j| j.index >= j.names.len())+ .unwrap_or(true);+ if done {+ self.finish_analysis_job()?;+ return Ok(true);+ }+ self.status = format!(+ "Analyzing {label} — {}/{}: {}",+ idx + 2,+ total,+ self.analysis_job+ .as_ref()+ .and_then(|j| j.names.get(j.index))+ .map(|s| s.as_str())+ .unwrap_or("…")+ );+ Ok(false)+ }++ fn finish_analysis_job(&mut self) -> Result<(), String> {+ let job = self+ .analysis_job+ .take()+ .ok_or_else(|| "no analysis job".to_string())?;+ if let Some(prog) = self.program.as_ref() {+ let entry = prog.entry.unwrap_or(prog.image_base);+ if let Ok(l) = disassemble_range(prog, entry, 128) {+ self.listing = l;+ }+ self.rtti = prog.rtti.clone();+ }+ // Capture strings from this run's results+ for r in &job.results.results {+ if let Some(ref s) = r.strings {+ self.strings = s.clone();+ }+ }+ self.rtti_filter.clear();+ self.rtti_filter_cache.clear();+ self.rtti_filtered_idx.clear();+ self.rebuild_rtti_filter_cache();+ self.last_analyzers_run = job.names.clone();+ let n = job.results.results.len();+ self.last_analysis = job.results;+ let summary = self.analysis_summary_line();+ let banner = format!(+ "Analysis complete on {} — {n} analyzer(s) · {summary}{}",+ job.file_label,+ if job.use_gpu {+ " · GPU experimental"+ } else {+ ""+ }+ );+ self.analysis_done_banner = Some(banner.clone());+ self.status = banner.clone();+ self.log(banner);+ if self.project.is_some() && self.active_file_id.is_some() {+ let _ = self.save_results();+ self.log("Results saved to project (results/ + exports/).");+ }+ self.center = CenterPane::Overview;+ self.show_symbol_tree = true;+ // Restore default bulk mode after experimental run+ set_preferred_bulk_mode(BulkScanMode::ParallelCpu);+ Ok(())+ }++ pub fn analysis_progress_fraction(&self) -> Option<f32> {+ self.analysis_job.as_ref().map(|j| {+ if j.names.is_empty() {+ 1.0+ } else {+ j.index as f32 / j.names.len() as f32+ }+ })+ }++ pub fn apply_theme(&self, ctx: &egui::Context) {+ let t = m3_tokens(self.theme);+ let mut v = match self.theme {+ ThemeMode::Dark => Visuals::dark(),+ ThemeMode::Light => Visuals::light(),+ };+ let rgb = |c: [u8; 3]| Color32::from_rgb(c[0], c[1], c[2]);+ v.override_text_color = Some(rgb(t.on_surface));+ v.widgets.noninteractive.bg_fill = rgb(t.surface_container);+ v.widgets.inactive.bg_fill = rgb(t.surface_container);+ v.widgets.hovered.bg_fill = rgb(t.primary).gamma_multiply(0.25);+ v.widgets.active.bg_fill = rgb(t.primary).gamma_multiply(0.35);+ v.widgets.open.bg_fill = rgb(t.surface_container);+ v.panel_fill = rgb(t.surface);+ v.window_fill = rgb(t.surface_container);+ v.extreme_bg_color = rgb(t.surface);+ v.faint_bg_color = rgb(t.surface_container);+ v.selection.bg_fill = rgb(t.primary).gamma_multiply(0.4);+ v.hyperlink_color = rgb(t.primary);+ v.warn_fg_color = rgb(t.error);+ ctx.set_visuals(v);+ }++ pub fn load_binary(&mut self, path: impl Into<PathBuf>) -> Result<(), String> {+ let path = path.into();+ self.path_input = path.display().to_string();+ let prog = load_path(&path).map_err(|e| e.to_string())?;+ let entry = prog.entry.unwrap_or(prog.image_base);+ let listing = disassemble_range(&prog, entry, 128).unwrap_or_default();+ self.log(format!(+ "Loaded {} ({}) base={:#x}",+ prog.name, prog.format, prog.image_base+ ));+ self.status = format!(+ "Loaded {} — {} sections, {} listing insns",+ prog.name,+ prog.sections.len(),+ listing.len()+ );+ self.program = Some(prog);+ self.listing = listing;+ self.rtti = RttiReport::default();+ self.strings.clear();+ self.last_analysis = AnalysisRunReport::default();+ self.last_analyzers_run.clear();+ Ok(())+ }++ pub fn create_project(&mut self) -> Result<(), String> {+ let dir = self.project_dir_input.trim().to_string();+ if dir.is_empty() {+ return Err("set Project dir path first".into());+ }+ let name = if self.project_name_input.trim().is_empty() {+ "MyProject".into()+ } else {+ self.project_name_input.trim().to_string()+ };+ let p = Project::create(&dir, name).map_err(|e| e.to_string())?;+ self.log(format!("Created project '{}' at {}", p.meta.name, p.root.display()));+ self.status = format!("Project open: {}", p.root.display());+ self.remember_project(&dir);+ self.show_startup_picker = false;+ self.project = Some(p);+ self.active_file_id = None;+ Ok(())+ }++ pub fn open_project(&mut self) -> Result<(), String> {+ let dir = self.project_dir_input.trim().to_string();+ if dir.is_empty() {+ return Err("set Project dir path first".into());+ }+ let p = Project::open(&dir).map_err(|e| e.to_string())?;+ self.project_name_input = p.meta.name.clone();+ self.active_file_id = p.meta.active_id.clone();+ self.log(format!(+ "Opened project '{}' ({} files)",+ p.meta.name,+ p.meta.files.len()+ ));+ self.status = format!("Project open: {}", p.root.display());+ self.remember_project(&dir);+ self.show_startup_picker = false;+ // Auto-open active file if any+ if let Some(id) = p.meta.active_id.clone() {+ self.project = Some(p);+ let _ = self.open_project_file(&id);+ } else {+ self.project = Some(p);+ }+ Ok(())+ }++ pub fn import_into_project(&mut self) -> Result<(), String> {+ let path = self.path_input.trim();+ if path.is_empty() {+ return Err("set binary path first".into());+ }+ let proj = self+ .project+ .as_mut()+ .ok_or_else(|| "no project open — create or open one first".to_string())?;+ let entry = proj.import_file(path).map_err(|e| e.to_string())?;+ self.active_file_id = Some(entry.id.clone());+ self.log(format!("Imported {} (id={})", entry.display_name, entry.id));+ let id = entry.id.clone();+ self.open_project_file(&id)+ }++ pub fn open_project_file(&mut self, id: &str) -> Result<(), String> {+ let entry = {+ let proj = self+ .project+ .as_ref()+ .ok_or_else(|| "no project".to_string())?;+ proj.meta+ .files+ .iter()+ .find(|f| f.id == id)+ .ok_or_else(|| format!("unknown file id {id}"))?+ .clone()+ };+ let display = entry.display_name.clone();+ self.status = format!("Loading {display}…");+ self.log(format!("Loading {display} (saved results if any)…"));++ let (prog, saved, has_saved, bin_path) = {+ let proj = self+ .project+ .as_ref()+ .ok_or_else(|| "no project".to_string())?;+ let has_saved = proj.has_saved_analysis(&entry.id);+ let bin_path = proj.binary_path(&entry).display().to_string();+ let (prog, saved) = proj+ .load_program_with_results(&entry)+ .map_err(|e| e.to_string())?;+ (prog, saved, has_saved, bin_path)+ };++ let mut saved_analyzers = Vec::new();+ let listing = if let Some(ref s) = saved {+ saved_analyzers = s.saved_analyzers.clone();+ if !s.listing.is_empty() {+ s.listing.clone()+ } else {+ let e = prog.entry.unwrap_or(prog.image_base);+ disassemble_range(&prog, e, 128).unwrap_or_default()+ }+ } else {+ let e = prog.entry.unwrap_or(prog.image_base);+ disassemble_range(&prog, e, 128).unwrap_or_default()+ };+ // Strings: session last_analysis only (full rescan is Analyze opt-in on large games).+ if let Some(s) = self+ .last_analysis+ .results+ .iter()+ .find_map(|r| r.strings.clone().filter(|s| !s.is_empty()))+ {+ self.strings = s;+ } else {+ self.strings.clear();+ }+ self.rtti = prog.rtti.clone();+ self.rtti_filter.clear();+ self.rtti_filter_cache.clear();+ self.rtti_filtered_idx.clear();+ self.rebuild_rtti_filter_cache();+ self.path_input = bin_path;+ self.active_file_id = Some(entry.id.clone());+ self.tree_selected_id = Some(entry.id.clone());+ if !saved_analyzers.is_empty() {+ self.last_analyzers_run = saved_analyzers;+ }+ let rtti_n = self.rtti.classes.len();+ let fn_n = prog.analysis.functions.len();+ self.status = format!(+ "Opened {display} — {fn_n} functions · {rtti_n} RTTI · {} listing lines{}",+ listing.len(),+ if has_saved {+ " · analysis on disk"+ } else {+ " · not analyzed yet"+ }+ );+ self.log(self.status.clone());+ self.program = Some(prog);+ self.listing = listing;+ self.center = CenterPane::Overview;+ self.show_symbol_tree = true;+ if let Some(p) = self.project.as_mut() {+ let _ = p.set_active(id);+ }+ Ok(())+ }++ pub fn save_results(&mut self) -> Result<(), String> {+ let id = self+ .active_file_id+ .clone()+ .ok_or_else(|| "no active project file — import a binary into a project".to_string())?;+ let prog = self+ .program+ .as_ref()+ .ok_or_else(|| "no program loaded".to_string())?;+ let (analysis_path, listing_path, saved) = {+ let proj = self+ .project+ .as_ref()+ .ok_or_else(|| "no project open".to_string())?;+ let saved = proj+ .save_program_results(&id, prog, &self.listing, &self.last_analyzers_run)+ .map_err(|e| e.to_string())?;+ (+ proj.analysis_path(&id).display().to_string(),+ proj.listing_export_path(&id).display().to_string(),+ saved,+ )+ };+ self.log(format!("Saved analysis → {analysis_path}"));+ self.log(format!("Listing export → {listing_path}"));+ self.status = format!(+ "Saved {} ({} functions, {} insns)",+ id,+ saved.analysis.functions.len(),+ saved.listing.len()+ );+ Ok(())+ }++ /// Headless/sync: begin job and drain all steps (tests + non-UI callers).+ pub fn run_selected_analysis(&mut self) -> Result<(), String> {+ self.begin_analysis_job()?;+ while self.analysis_job.is_some() {+ self.step_analysis_job()?;+ }+ Ok(())+ }++ fn log(&mut self, msg: impl Into<String>) {+ self.console.push(msg.into());+ if self.console.len() > 200 {+ self.console.drain(0..self.console.len() - 200);+ }+ }++ fn nyi(&mut self, what: &str) {+ let m = format!("Not yet implemented: {what}");+ self.status = m.clone();+ self.nyi_note = Some(m.clone());+ self.log(m);+ }++ /// Menu / pane identifiers present in the shell (for structural tests).+ pub fn shell_menus() -> &'static [&'static str] {+ &[+ "File",+ "Edit",+ "Analysis",+ "Navigation",+ "Search",+ "Select",+ "Tools",+ "Window",+ "Help",+ ]+ }++ pub fn shell_panes() -> &'static [&'static str] {+ &[+ "Project Tree",+ "Program Tree",+ "Symbol Tree",+ "Overview",+ "Listing",+ "Decompiler",+ "Data Type Manager",+ "Console",+ ]+ }++ fn ui_startup_picker(&mut self, ctx: &egui::Context) {+ let t = m3_tokens(self.theme);+ let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);+ let muted =+ Color32::from_rgb(t.on_surface_variant[0], t.on_surface_variant[1], t.on_surface_variant[2]);+ let surface = Color32::from_rgb(t.surface_container[0], t.surface_container[1], t.surface_container[2]);++ // Fixed card size — never wider than the window, never stretch off-screen.+ let card_w = 440.0_f32+ .min(ctx.screen_rect().width() - 48.0)+ .max(280.0);++ egui::CentralPanel::default().show(ctx, |ui| {+ ui.vertical_centered(|ui| {+ ui.add_space(32.0);+ ui.heading(egui::RichText::new("Ghidrust").size(26.0).color(primary));+ ui.label(+ egui::RichText::new("Open a project to reverse engineer")+ .color(muted)+ .size(14.0),+ );+ ui.add_space(20.0);++ egui::Frame::group(ui.style())+ .fill(surface)+ .inner_margin(egui::Margin::same(16))+ .corner_radius(egui::CornerRadius::same(8))+ .show(ui, |ui| {+ ui.set_width(card_w);+ ui.set_max_width(card_w);++ // ── Recent projects (IDE-style list) ──+ ui.label(egui::RichText::new("Recent projects").strong().size(13.0));+ ui.add_space(6.0);++ let recents = self.recent_projects.clone();+ let list_h = if recents.is_empty() { 48.0 } else { 200.0 };++ egui::Frame::NONE+ .stroke(ui.visuals().widgets.noninteractive.bg_stroke)+ .inner_margin(egui::Margin::same(4))+ .corner_radius(egui::CornerRadius::same(4))+ .show(ui, |ui| {+ ui.set_width(card_w - 8.0);+ egui::ScrollArea::vertical()+ .id_salt("startup_recent")+ .max_height(list_h)+ .auto_shrink([false, false])+ .show(ui, |ui| {+ ui.set_min_width(card_w - 24.0);+ if recents.is_empty() {+ ui.add_space(8.0);+ ui.weak("No recent projects — open or create one below.");+ ui.add_space(8.0);+ } else {+ let mut open_path: Option<String> = None;+ for path in &recents {+ let name = Path::new(path)+ .file_name()+ .map(|s| s.to_string_lossy().into_owned())+ .unwrap_or_else(|| path.clone());+ // IDE-style row: project name + path, full-width click+ let row_w = (card_w - 24.0).max(200.0);+ let row_h = 44.0;+ let (rect, resp) = ui.allocate_exact_size(+ egui::vec2(row_w, row_h),+ egui::Sense::click(),+ );+ if resp.hovered() || resp.has_focus() {+ ui.painter().rect_filled(+ rect,+ egui::CornerRadius::same(4),+ primary.gamma_multiply(0.15),+ );+ }+ let mut child = ui.new_child(+ egui::UiBuilder::new()+ .max_rect(rect.shrink2(egui::vec2(10.0, 6.0)))+ .layout(egui::Layout::top_down(egui::Align::LEFT)),+ );+ child.label(+ egui::RichText::new(&name)+ .strong()+ .color(primary)+ .size(14.0),+ );+ child.label(+ egui::RichText::new(path).small().color(muted),+ );+ if resp.clicked() {+ open_path = Some(path.clone());+ }+ resp.on_hover_text(format!("Open project: {path}"));+ }+ if let Some(path) = open_path {+ self.project_dir_input = path;+ if let Err(e) = self.open_project() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ self.show_startup_picker = true;+ }+ }+ }+ });+ });++ ui.add_space(14.0);+ ui.separator();+ ui.add_space(10.0);++ // Buttons fit card width only (no off-screen stretch)+ let btn_w = card_w - 8.0;+ if ui+ .add_sized(+ [btn_w, 32.0],+ egui::Button::new("Open existing project…"),+ )+ .clicked()+ {+ self.browse_and_open_project();+ if self.project.is_none() {+ self.show_startup_picker = true;+ }+ }+ ui.add_space(8.0);+ ui.horizontal(|ui| {+ ui.label("Name:");+ ui.add(+ egui::TextEdit::singleline(&mut self.project_name_input)+ .desired_width((btn_w - 56.0).max(120.0))+ .hint_text("MyProject"),+ );+ });+ ui.add_space(4.0);+ if ui+ .add_sized([btn_w, 32.0], egui::Button::new("Create new project…"))+ .clicked()+ {+ self.browse_and_create_project();+ if self.project.is_none() {+ self.show_startup_picker = true;+ }+ }+ ui.add_space(12.0);+ if ui.link("Continue without a project").clicked() {+ self.show_startup_picker = false;+ self.status =+ "No project — Browse/Load a binary, or File → Open Project".into();+ }+ ui.add_space(4.0);+ ui.small(+ egui::RichText::new(+ "Click a recent project name to open it. Analysis uses analysis.bin for fast load.",+ )+ .color(muted),+ );+ });+ });+ });+ }++ fn ui_overview(&mut self, ui: &mut egui::Ui) {+ let t = m3_tokens(self.theme);+ let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);+ let muted =+ Color32::from_rgb(t.on_surface_variant[0], t.on_surface_variant[1], t.on_surface_variant[2]);+ let ok = Color32::from_rgb(0x4C, 0xAF, 0x50);++ ui.heading("Overview");+ let Some(prog) = self.program.as_ref() else {+ ui.weak("No program open.");+ ui.label("Project Tree: double-click a file (or Open) to load it into this view.");+ ui.label("If the file is Analyzed, RTTI / functions load from results/ automatically.");+ return;+ };++ ui.horizontal(|ui| {+ ui.heading(&prog.name);+ if !self.rtti.classes.is_empty() || !prog.analysis.functions.is_empty() {+ status_badge(ui, true, ok, muted);+ } else {+ status_badge(ui, false, ok, muted);+ }+ });+ ui.label(egui::RichText::new(format!(+ "{} · image base {:#x}{}",+ prog.format,+ prog.image_base,+ prog.entry+ .map(|e| format!(" · entry {e:#x}"))+ .unwrap_or_default()+ )).color(muted));++ ui.add_space(8.0);+ ui.horizontal(|ui| {+ let card = |ui: &mut egui::Ui, title: &str, value: String| {+ ui.group(|ui| {+ ui.set_min_width(120.0);+ ui.label(egui::RichText::new(title).small().color(muted));+ ui.label(egui::RichText::new(value).strong().color(primary).size(18.0));+ });+ };+ card(ui, "Functions", format!("{}", prog.analysis.functions.len()));+ card(ui, "RTTI classes", format!("{}", self.rtti.classes.len()));+ card(ui, "Strings", format!("{}", self.strings.len()));+ card(ui, "Listing lines", format!("{}", self.listing.len()));+ card(ui, "Sections", format!("{}", prog.sections.len()));+ });++ ui.add_space(10.0);+ if !self.last_analyzers_run.is_empty() {+ ui.label(egui::RichText::new("Analyzers last run / saved").strong());+ ui.horizontal_wrapped(|ui| {+ for a in &self.last_analyzers_run {+ ui.small(format!("[{a}]"));+ }+ });+ } else {+ ui.weak("No analyzer list saved for this session — run Analyze to record one.");+ }++ if !self.rtti.notes.is_empty() {+ ui.add_space(6.0);+ ui.label(egui::RichText::new("RTTI notes").strong());+ for n in &self.rtti.notes {+ ui.small(n);+ }+ }++ ui.add_space(12.0);+ ui.separator();+ ui.label(egui::RichText::new("What to do next").strong());+ ui.label("• Symbol Tree (right): expand Classes / RTTI, type a filter, scroll the list.");+ ui.label("• Listing tab: entry disassembly.");+ ui.label("• Analyze: re-run analyzers (shows options + progress).");+ if self.rtti.classes.len() > 1000 {+ ui.label(+ egui::RichText::new(format!(+ "• Large RTTI set ({} classes) — always filter; the list is virtualized so it stays smooth.",+ self.rtti.classes.len()+ ))+ .color(primary),+ );+ }++ // Sample of first few RTTI hits for confidence without opening the full drawer+ if !self.rtti.classes.is_empty() {+ ui.add_space(10.0);+ ui.label(egui::RichText::new("RTTI sample (first 12)").strong());+ egui::ScrollArea::vertical().max_height(160.0).show(ui, |ui| {+ for c in self.rtti.classes.iter().take(12) {+ let va = c+ .type_info_va+ .map(|v| format!("{v:#x}"))+ .unwrap_or_else(|| "—".into());+ ui.monospace(format!("{va} {}", c.name));+ }+ });+ if ui.button("Focus Symbol Tree → RTTI").clicked() {+ self.show_symbol_tree = true;+ }+ }+ }+}++impl eframe::App for GhidrustApp {+ fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {+ self.apply_theme(ctx);++ // Startup: choose project before the empty shell+ if self.show_startup_picker {+ self.ui_startup_picker(ctx);+ return;+ }++ // Step analysis one analyzer per frame so M3 progress can paint.+ if self.analysis_job.is_some() {+ if let Err(e) = self.step_analysis_job() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ self.analysis_job = None;+ set_preferred_bulk_mode(BulkScanMode::ParallelCpu);+ }+ ctx.request_repaint();+ }++ egui::TopBottomPanel::top("menubar").show(ctx, |ui| {+ egui::menu::bar(ui, |ui| {+ ui.menu_button("File", |ui| {+ if ui.button("New Project…").clicked() {+ self.browse_and_create_project();+ ui.close_menu();+ }+ if ui.button("Open Project…").clicked() {+ self.browse_and_open_project();+ ui.close_menu();+ }+ ui.separator();+ if ui.button("Import binary into project…").clicked() {+ self.browse_and_import();+ ui.close_menu();+ }+ if ui.button("Open / Load binary…").clicked() {+ self.browse_and_load_binary();+ ui.close_menu();+ }+ if ui.button("Save analysis results…").clicked() {+ if let Err(e) = self.save_results() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ ui.close_menu();+ }+ if ui.button("Close program").clicked() {+ self.program = None;+ self.listing.clear();+ self.active_file_id = None;+ self.status = "Program closed".into();+ ui.close_menu();+ }+ ui.separator();+ if ui.button("Exit").clicked() {+ ctx.send_viewport_cmd(egui::ViewportCommand::Close);+ }+ });+ ui.menu_button("Edit", |ui| {+ if ui.button("Undo").clicked() {+ self.nyi("Edit → Undo");+ ui.close_menu();+ }+ if ui.button("Redo").clicked() {+ self.nyi("Edit → Redo");+ ui.close_menu();+ }+ if ui.button("Clear selection").clicked() {+ self.nyi("Edit → Clear selection");+ ui.close_menu();+ }+ });+ ui.menu_button("Analysis", |ui| {+ if ui.button("Auto Analyze…").clicked() {+ self.pending_analyze_file_id = None;+ self.show_analysis_dialog = true;+ ui.close_menu();+ }+ if ui.button("Run selected analyzers").clicked() {+ self.pending_analyze_file_id = None;+ self.show_analysis_dialog = true;+ ui.close_menu();+ }+ });+ ui.menu_button("Navigation", |ui| {+ if ui.button("Go to entry").clicked() {+ self.center = CenterPane::Listing;+ ui.close_menu();+ }+ if ui.button("Go to address…").clicked() {+ self.nyi("Navigation → Go to address");+ ui.close_menu();+ }+ });+ ui.menu_button("Search", |ui| {+ if ui.button("Search memory…").clicked() {+ self.nyi("Search → Search memory");+ ui.close_menu();+ }+ if ui.button("Search program text…").clicked() {+ self.nyi("Search → Search program text");+ ui.close_menu();+ }+ });+ ui.menu_button("Select", |ui| {+ if ui.button("Select all").clicked() {+ self.nyi("Select → Select all");+ ui.close_menu();+ }+ });+ ui.menu_button("Tools", |ui| {+ if ui.button("Processor options…").clicked() {+ self.nyi("Tools → Processor options");+ ui.close_menu();+ }+ });+ ui.menu_button("Window", |ui| {+ ui.checkbox(&mut self.show_project_tree, "Project Tree");+ ui.checkbox(&mut self.show_program_tree, "Program Tree");+ ui.checkbox(&mut self.show_symbol_tree, "Symbol Tree");+ ui.checkbox(&mut self.show_console, "Console");+ ui.separator();+ ui.selectable_value(&mut self.center, CenterPane::Overview, "Overview");+ ui.selectable_value(&mut self.center, CenterPane::Listing, "Listing");+ ui.selectable_value(&mut self.center, CenterPane::Decompiler, "Decompiler");+ ui.selectable_value(&mut self.center, CenterPane::DataTypes, "Data Type Manager");+ });+ ui.menu_button("Help", |ui| {+ if ui.button("About Ghidrust").clicked() {+ self.status =+ "Ghidrust — Rust RE foundation (Material 3 CodeBrowser shell)".into();+ self.log(self.status.clone());+ ui.close_menu();+ }+ if ui.button("Roadmap…").clicked() {+ self.log("See local development notes under dev/ (roadmap / parity)");+ ui.close_menu();+ }+ });++ ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {+ let label = match self.theme {+ ThemeMode::Dark => "Theme: Dark",+ ThemeMode::Light => "Theme: Light",+ };+ if ui.button(label).clicked() {+ self.theme = self.theme.toggle();+ self.apply_theme(ctx);+ self.log(format!("Theme → {:?}", self.theme));+ }+ });+ });+ });++ egui::TopBottomPanel::top("toolbar").show(ctx, |ui| {+ ui.horizontal(|ui| {+ ui.label("Project dir:");+ ui.add(+ egui::TextEdit::singleline(&mut self.project_dir_input)+ .desired_width(240.0)+ .hint_text("folder for New/Open project"),+ );+ if ui.button("Browse…").on_hover_text("Choose project folder").clicked() {+ self.browse_project_dir();+ }+ ui.label("Name:");+ ui.add(+ egui::TextEdit::singleline(&mut self.project_name_input).desired_width(100.0),+ );+ if ui.button("New").on_hover_text("Create project (browse if dir empty)").clicked() {+ if self.project_dir_input.trim().is_empty() {+ self.browse_and_create_project();+ } else if let Err(e) = self.create_project() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ if ui.button("Open").on_hover_text("Open project (browse if dir empty)").clicked() {+ if self.project_dir_input.trim().is_empty() {+ self.browse_and_open_project();+ } else if let Err(e) = self.open_project() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ });+ ui.horizontal(|ui| {+ ui.label("Binary:");+ ui.add(+ egui::TextEdit::singleline(&mut self.path_input)+ .desired_width(320.0)+ .hint_text("PE/ELF — or use Browse"),+ );+ if ui.button("Browse…").on_hover_text("Choose binary file").clicked() {+ self.browse_binary_path();+ }+ if ui.button("Import").on_hover_text("Import into project (browse if empty)").clicked() {+ if self.path_input.trim().is_empty() {+ self.browse_and_import();+ } else if let Err(e) = self.import_into_project() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ if ui.button("Load").on_hover_text("Load binary without project (browse if empty)").clicked() {+ if self.path_input.trim().is_empty() {+ self.browse_and_load_binary();+ } else {+ let p = self.path_input.clone();+ if let Err(e) = self.load_binary(p) {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ }+ if ui+ .button("Analyze…")+ .on_hover_text("Open analysis options (analyzers + GPU)")+ .clicked()+ {+ self.pending_analyze_file_id = self.active_file_id.clone();+ self.show_analysis_dialog = true;+ }+ if ui.button("Save").clicked() {+ if let Err(e) = self.save_results() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ });+ let file_chips: Vec<(String, String, String)> = self+ .project+ .as_ref()+ .map(|p| {+ let pname = p.meta.name.clone();+ let files = p+ .meta+ .files+ .iter()+ .map(|f| (f.id.clone(), f.display_name.clone()))+ .collect::<Vec<_>>();+ files+ .into_iter()+ .map(|(id, name)| (pname.clone(), id, name))+ .collect()+ })+ .unwrap_or_default();+ if !file_chips.is_empty() {+ let pname = file_chips[0].0.clone();+ ui.horizontal(|ui| {+ ui.label(format!("Open: {pname} | files:"));+ for (_, id, name) in &file_chips {+ let selected = self.active_file_id.as_deref() == Some(id.as_str());+ if ui.selectable_label(selected, name).clicked() {+ if let Err(e) = self.open_project_file(id) {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ }+ });+ }+ });++ egui::TopBottomPanel::bottom("status").show(ctx, |ui| {+ if let Some(frac) = self.analysis_progress_fraction() {+ let t = m3_tokens(self.theme);+ let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);+ let track = Color32::from_rgb(+ t.surface_container[0],+ t.surface_container[1],+ t.surface_container[2],+ )+ .gamma_multiply(1.4);+ let (label, pct) = self+ .analysis_job+ .as_ref()+ .map(|j| {+ let n = j.names.len().max(1);+ let cur = j+ .names+ .get(j.index)+ .cloned()+ .unwrap_or_else(|| "finishing…".into());+ (+ format!(+ "Analyzing {} — {}/{} {cur}{}",+ j.file_label,+ (j.index + 1).min(n),+ n,+ if j.use_gpu { " · GPU experimental" } else { "" }+ ),+ (frac * 100.0) as u32,+ )+ })+ .unwrap_or_else(|| ("Analyzing…".into(), 0));+ ui.label(egui::RichText::new(label).color(primary));+ m3_linear_progress(ui, frac, primary, track);+ ui.small(format!("{pct}%"));+ } else {+ ui.horizontal(|ui| {+ ui.label(&self.status);+ if let Some(n) = &self.nyi_note {+ ui.separator();+ ui.weak(n);+ }+ });+ }+ });++ if self.show_console {+ egui::TopBottomPanel::bottom("console")+ .resizable(true)+ .default_height(120.0)+ .show(ctx, |ui| {+ ui.heading("Console");+ egui::ScrollArea::vertical()+ .stick_to_bottom(true)+ .show(ui, |ui| {+ for line in &self.console {+ ui.monospace(line);+ }+ });+ });+ }++ // Ghidra Project Window–style dock: Project → binaries (upgraded badges + actions)+ if self.show_project_tree {+ egui::SidePanel::left("project_tree")+ .resizable(true)+ .default_width(240.0)+ .show(ctx, |ui| {+ ui.heading("Project");+ ui.small(+ egui::RichText::new(+ "Click = select · Double-click / Open = load into main view · Analyze = options",+ )+ .weak(),+ );+ ui.separator();+ if self.project.is_none() {+ ui.weak("No project open.");+ ui.label("New/Open a project, then Import binaries.");+ } else {+ let model = self.project_tree_model().unwrap();+ let t = m3_tokens(self.theme);+ let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);+ let muted =+ Color32::from_rgb(t.on_surface_variant[0], t.on_surface_variant[1], t.on_surface_variant[2]);+ let ok_green = Color32::from_rgb(0x4C, 0xAF, 0x50);+ let root_open = {+ ui.horizontal(|ui| {+ m3_icon(ui, M3Icon::Folder, 18.0, primary);+ ui.strong(&model.project_name);+ });+ egui::CollapsingHeader::new("Project files")+ .default_open(self.project_tree_expanded)+ .show(ui, |ui| {+ ui.small(egui::RichText::new(&model.project_root).weak());+ ui.add_space(4.0);+ if model.files.is_empty() {+ ui.weak("Empty — Import a binary.");+ }+ let mut open_id: Option<String> = None;+ let mut analyze_id: Option<String> = None;+ let mut delete_id: Option<String> = None;+ let mut select_id: Option<String> = None;+ for row in &model.files {+ let selected = self.tree_selected_id.as_deref() == Some(row.id.as_str());+ let viewing = self.active_file_id.as_deref() == Some(row.id.as_str())+ && self.program.is_some();+ ui.group(|ui| {+ ui.horizontal(|ui| {+ if viewing {+ m3_icon(ui, M3Icon::PlayArrow, 14.0, primary);+ } else {+ ui.add_space(14.0);+ }+ let resp = ui.selectable_label(selected || viewing, &row.display_name);+ if resp.double_clicked() {+ open_id = Some(row.id.clone());+ } else if resp.clicked() {+ select_id = Some(row.id.clone());+ }+ });+ ui.horizontal(|ui| {+ status_badge(ui, row.has_saved_analysis, ok_green, muted);+ if viewing {+ ui.small(egui::RichText::new("viewing").color(primary));+ } else if row.has_saved_analysis {+ ui.small(egui::RichText::new("double-click to open").weak());+ }+ });+ ui.horizontal(|ui| {+ ui.with_layout(+ egui::Layout::right_to_left(egui::Align::Center),+ |ui| {+ if ui+ .small_button("Delete")+ .on_hover_text("Remove from project (confirmation)")+ .clicked()+ {+ delete_id = Some(row.id.clone());+ }+ if ui+ .small_button("Analyze")+ .on_hover_text("Analysis options (analyzers + GPU)")+ .clicked()+ {+ analyze_id = Some(row.id.clone());+ }+ if ui+ .small_button("Open")+ .on_hover_text("Load into Overview / Listing / Symbol Tree")+ .clicked()+ {+ open_id = Some(row.id.clone());+ }+ },+ );+ });+ ui.small(+ egui::RichText::new(&row.imported_rel)+ .weak()+ .italics(),+ );+ });+ ui.add_space(2.0);+ }+ (open_id, analyze_id, delete_id, select_id)+ })+ };+ let expanded = root_open.fully_open();+ if let Some((open_id, analyze_id, delete_id, select_id)) = root_open.body_returned {+ if let Some(id) = select_id {+ self.tree_selected_id = Some(id);+ }+ if let Some(id) = delete_id {+ self.request_delete_file(&id);+ } else if let Some(id) = analyze_id {+ if let Err(e) = self.analyze_from_tree(&id) {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ } else if let Some(id) = open_id {+ if let Err(e) = self.open_from_tree(&id) {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ }+ self.project_tree_expanded = expanded;+ }+ });+ }++ // Delete confirmation modal+ if let Some((ref id, ref name)) = self.pending_delete.clone() {+ let id = id.clone();+ let name = name.clone();+ egui::Window::new("Delete from project?")+ .collapsible(false)+ .resizable(false)+ .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])+ .show(ctx, |ui| {+ ui.label(format!(+ "Remove \"{name}\" from this project?\n\n\+ Deletes the imported copy and saved analysis for this file.\n\+ This cannot be undone."+ ));+ ui.add_space(8.0);+ ui.horizontal(|ui| {+ if ui.button("Cancel").clicked() {+ self.cancel_delete_file();+ }+ if ui+ .button(egui::RichText::new("Delete").color(Color32::from_rgb(0xB3, 0x26, 0x1E)))+ .clicked()+ {+ let _ = id;+ if let Err(e) = self.confirm_delete_file() {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ });+ });+ }++ if self.show_program_tree {+ egui::SidePanel::left("program_tree")+ .resizable(true)+ .default_width(200.0)+ .show(ctx, |ui| {+ ui.heading("Program Tree");+ ui.weak("Memory map (current program)");+ ui.separator();+ if let Some(prog) = &self.program {+ for b in &prog.blocks {+ ui.monospace(format!(+ "{} {:#x} {:#x}",+ b.name, b.va, b.size+ ));+ }+ if let Some(e) = prog.entry {+ ui.separator();+ ui.label(format!("Entry {e:#x}"));+ }+ } else {+ ui.weak("No program loaded.");+ }+ });+ }++ if self.show_symbol_tree {+ egui::SidePanel::right("symbol_tree")+ .resizable(true)+ .default_width(280.0)+ .min_width(200.0)+ .show(ctx, |ui| {+ let t = m3_tokens(self.theme);+ let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);+ ui.heading("Symbol Tree");+ if self.program.is_none() {+ ui.weak("Open a project file to browse symbols.");+ return;+ }+ ui.small(egui::RichText::new(self.analysis_summary_line()).color(primary));+ ui.separator();++ // Functions (virtualized)+ let fn_count = self+ .program+ .as_ref()+ .map(|p| p.analysis.functions.len())+ .unwrap_or(0);+ egui::CollapsingHeader::new(format!("Functions ({fn_count})"))+ .default_open(fn_count > 0 && fn_count <= 500)+ .show(ui, |ui| {+ let entry = self.program.as_ref().and_then(|p| p.entry);+ let fns: Vec<(u64, String)> = self+ .program+ .as_ref()+ .map(|p| {+ p.analysis+ .functions+ .iter()+ .map(|f| (f.entry, f.name.clone()))+ .collect()+ })+ .unwrap_or_default();+ if let Some(e) = entry {+ ui.monospace(format!("entry @ {e:#x}"));+ }+ if fns.is_empty() {+ ui.weak("Run Function Start Search.");+ } else {+ ui.add(+ egui::TextEdit::singleline(&mut self.fn_filter)+ .desired_width(f32::INFINITY)+ .hint_text("Filter functions…"),+ );+ let q = self.fn_filter.to_ascii_lowercase();+ let rows: Vec<(u64, String)> = fns+ .into_iter()+ .filter(|(_, name)| {+ q.is_empty() || name.to_ascii_lowercase().contains(&q)+ })+ .collect();+ let row_h = ui.text_style_height(&egui::TextStyle::Monospace);+ let n = rows.len();+ egui::ScrollArea::vertical()+ .id_salt("fn_scroll")+ .max_height(220.0)+ .show_rows(ui, row_h, n, |ui, range| {+ for i in range {+ let (va, name) = &rows[i];+ ui.monospace(format!("{va:#x} {name}"));+ }+ });+ ui.small(format!("{n} shown"));+ }+ });++ ui.collapsing("Imports", |ui| {+ ui.weak("Not yet implemented.");+ });+ ui.collapsing("Exports", |ui| {+ ui.weak("Not yet implemented.");+ });++ // RTTI — virtualized + filter (handles 70k+ classes)+ let rtti_n = self.rtti.classes.len();+ egui::CollapsingHeader::new(format!("Classes / RTTI ({rtti_n})"))+ .default_open(false)+ .show(ui, |ui| {+ if rtti_n == 0 {+ ui.weak("Run WindowsPE x86 PE RTTI Analyzer, then Open the file.");+ return;+ }+ ui.add(+ egui::TextEdit::singleline(&mut self.rtti_filter)+ .desired_width(f32::INFINITY)+ .hint_text("Filter class names…"),+ );+ if ui.button("Apply filter").clicked()+ || ui.input(|i| i.key_pressed(egui::Key::Enter))+ {+ self.rtti_filter_cache.clear();+ }+ self.rebuild_rtti_filter_cache();+ let n_show = self.rtti_filtered_idx.len();+ ui.small(format!("{n_show} / {rtti_n} classes"));+ let row_h = ui.text_style_height(&egui::TextStyle::Body) + 2.0;+ // Clone indices to avoid borrow issues in show_rows+ let idxs = self.rtti_filtered_idx.clone();+ egui::ScrollArea::vertical()+ .id_salt("rtti_scroll")+ .auto_shrink([false, false])+ .show_rows(ui, row_h, idxs.len(), |ui, range| {+ for i in range {+ let c = &self.rtti.classes[idxs[i]];+ let va = c+ .type_info_va+ .map(|v| format!("{v:#x}"))+ .unwrap_or_else(|| "—".into());+ ui.horizontal(|ui| {+ ui.monospace(&va);+ ui.label(&c.name)+ .on_hover_text(format!(+ "kind={} col={:?} vtable={:?}",+ c.kind, c.col_va, c.vtable_va+ ));+ });+ }+ });+ });++ let str_n = self.strings.len();+ egui::CollapsingHeader::new(format!("Strings ({str_n})"))+ .default_open(false)+ .show(ui, |ui| {+ if str_n == 0 {+ ui.weak("Run ASCII Strings (session) or re-analyze.");+ return;+ }+ let row_h = ui.text_style_height(&egui::TextStyle::Monospace);+ egui::ScrollArea::vertical()+ .id_salt("str_scroll")+ .max_height(200.0)+ .show_rows(ui, row_h, str_n.min(5000), |ui, range| {+ for i in range {+ if let Some(s) = self.strings.get(i) {+ let val: String =+ s.value.chars().take(48).collect();+ ui.monospace(format!("{:#x}: {val}", s.va));+ }+ }+ });+ if str_n > 5000 {+ ui.small(format!("Showing first 5000 of {str_n}"));+ }+ });+ });+ }++ // Analysis complete banner (top of frame content)+ if let Some(banner) = self.analysis_done_banner.clone() {+ egui::TopBottomPanel::top("analysis_done_banner").show(ctx, |ui| {+ let t = m3_tokens(self.theme);+ let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);+ let ok = Color32::from_rgb(0x4C, 0xAF, 0x50);+ ui.horizontal(|ui| {+ m3_icon(ui, M3Icon::CheckCircle, 18.0, ok);+ ui.label(egui::RichText::new(banner).color(primary).strong());+ ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {+ if ui.button("Dismiss").clicked() {+ self.analysis_done_banner = None;+ }+ if ui.button("Open Overview").clicked() {+ self.center = CenterPane::Overview;+ self.analysis_done_banner = None;+ }+ });+ });+ });+ }++ egui::CentralPanel::default().show(ctx, |ui| {+ ui.horizontal(|ui| {+ ui.selectable_value(&mut self.center, CenterPane::Overview, "Overview");+ ui.selectable_value(&mut self.center, CenterPane::Listing, "Listing");+ ui.selectable_value(&mut self.center, CenterPane::Decompiler, "Decompiler");+ ui.selectable_value(&mut self.center, CenterPane::DataTypes, "Data Type Manager");+ });+ ui.separator();+ match self.center {+ CenterPane::Overview => {+ self.ui_overview(ui);+ }+ CenterPane::Listing => {+ ui.heading("Listing");+ egui::ScrollArea::vertical().show(ui, |ui| {+ if self.listing.is_empty() {+ ui.weak("No listing — double-click a project file to open.");+ }+ for insn in &self.listing {+ ui.monospace(insn.text());+ }+ });+ }+ CenterPane::Decompiler => {+ ui.heading("Decompiler");+ ui.weak(+ "Not yet implemented — Phase 3 production decompiler (structure present).",+ );+ if let Some(prog) = &self.program {+ if let Some(e) = prog.entry {+ ui.monospace(format!("// placeholder for function at {e:#x}"));+ }+ }+ }+ CenterPane::DataTypes => {+ ui.heading("Data Type Manager");+ ui.weak("Not yet implemented — structure reserved for built-in / user types.");+ let n = self.rtti.classes.len();+ if n > 0 {+ ui.label(format!(+ "RTTI recovered {n} class record(s) — browse Symbol Tree → Classes / RTTI (filter + scroll)."+ ));+ }+ }+ }+ });++ if self.show_analysis_dialog && self.analysis_job.is_none() {+ let t = m3_tokens(self.theme);+ let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);+ egui::Window::new("Analysis options")+ .collapsible(false)+ .resizable(true)+ .default_width(460.0)+ .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])+ .show(ctx, |ui| {+ if let Some(ref id) = self.pending_analyze_file_id {+ let name = self+ .project+ .as_ref()+ .and_then(|p| p.meta.files.iter().find(|f| f.id == *id))+ .map(|f| f.display_name.as_str())+ .unwrap_or(id.as_str());+ ui.label(+ egui::RichText::new(format!("Target: {name}"))+ .strong()+ .color(primary),+ );+ ui.add_space(4.0);+ }+ ui.label("Select analyzers (Ghidra-compatible labels):");+ ui.horizontal(|ui| {+ if ui.small_button("Select defaults").clicked() {+ for (i, info) in self.analyzer_infos.iter().enumerate() {+ self.analyzer_enabled[i] = info.default_enabled;+ }+ }+ if ui.small_button("Select all").clicked() {+ for e in &mut self.analyzer_enabled {+ *e = true;+ }+ }+ if ui.small_button("Clear all").clicked() {+ for e in &mut self.analyzer_enabled {+ *e = false;+ }+ }+ });+ egui::ScrollArea::vertical().max_height(320.0).show(ui, |ui| {+ for (i, info) in self.analyzer_infos.iter().enumerate() {+ ui.horizontal(|ui| {+ ui.checkbox(&mut self.analyzer_enabled[i], &info.name);+ match info.status {+ ghidrust_core::AnalyzerStatus::Implemented => {+ ui.weak("ready");+ }+ ghidrust_core::AnalyzerStatus::NotImplemented => {+ ui.weak("stub");+ }+ }+ });+ }+ });+ ui.separator();+ ui.checkbox(+ &mut self.use_gpu_experimental,+ "GPU (strings bulk + per-analyzer seed kernels)",+ );+ ui.small(+ "wgpu when available: GPU bulk for ASCII Strings and SIMT seed enrich \+ for each selected analyzer (rtti_scan, prologue, …). Falls back to CPU. \+ PCIe/setup can dominate small files; GPU decompile is a separate tool.",+ );+ ui.add_space(8.0);+ ui.horizontal(|ui| {+ let can_run = self.analyzer_enabled.iter().any(|e| *e)+ && (self.program.is_some() || self.pending_analyze_file_id.is_some());+ if ui+ .add_enabled(can_run, egui::Button::new("Run Analysis"))+ .clicked()+ {+ match self.begin_analysis_job() {+ Ok(()) => {+ self.show_analysis_dialog = false;+ }+ Err(e) => {+ self.status = format!("error: {e}");+ self.log(self.status.clone());+ }+ }+ }+ if ui.button("Cancel").clicked() {+ self.pending_analyze_file_id = None;+ self.show_analysis_dialog = false;+ }+ });+ });+ }++ // Floating M3 progress card while analysis runs+ if let Some(frac) = self.analysis_progress_fraction() {+ let t = m3_tokens(self.theme);+ let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);+ let on_surface = Color32::from_rgb(t.on_surface[0], t.on_surface[1], t.on_surface[2]);+ let track = Color32::from_rgb(+ t.surface_container[0],+ t.surface_container[1],+ t.surface_container[2],+ )+ .gamma_multiply(1.4);+ egui::Window::new("Analysis progress")+ .collapsible(false)+ .resizable(false)+ .anchor(egui::Align2::CENTER_BOTTOM, [0.0, -48.0])+ .title_bar(true)+ .show(ctx, |ui| {+ ui.set_min_width(360.0);+ if let Some(job) = &self.analysis_job {+ let n = job.names.len().max(1);+ let step = (job.index + 1).min(n);+ let cur = job+ .names+ .get(job.index)+ .map(|s| s.as_str())+ .unwrap_or("finishing…");+ ui.label(+ egui::RichText::new(format!("{} — {step}/{n}", job.file_label))+ .color(on_surface)+ .strong(),+ );+ ui.label(egui::RichText::new(cur).color(primary).small());+ if job.use_gpu {+ ui.small("GPU experimental bulk path enabled");+ }+ }+ ui.add_space(6.0);+ m3_linear_progress(ui, frac, primary, track);+ ui.add_space(2.0);+ ui.small(format!("{:.0}%", frac * 100.0));+ });+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use ghidrust_core::{fixture_path, ANALYZER_NAMES};++ #[test]+ fn shell_has_required_menus_and_panes() {+ let menus = GhidrustApp::shell_menus();+ for m in [+ "File",+ "Edit",+ "Analysis",+ "Navigation",+ "Search",+ "Window",+ "Help",+ ] {+ assert!(menus.contains(&m), "missing menu {m}");+ }+ let panes = GhidrustApp::shell_panes();+ for p in [+ "Project Tree",+ "Program Tree",+ "Symbol Tree",+ "Overview",+ "Listing",+ "Decompiler",+ "Console",+ ] {+ assert!(panes.contains(&p), "missing pane {p}");+ }+ // Project Tree ≠ Program Tree+ assert_ne!(+ panes.iter().position(|p| *p == "Project Tree"),+ panes.iter().position(|p| *p == "Program Tree")+ );+ }++ #[test]+ fn project_tree_open_and_status_via_shipped_apis() {+ let dir = std::env::temp_dir().join(format!(+ "ghidrust_ptree_{}",+ std::process::id()+ ));+ let _ = std::fs::remove_dir_all(&dir);+ let mut app = GhidrustApp::headless();+ app.project_dir_input = dir.display().to_string();+ app.project_name_input = "TreeUX".into();+ app.create_project().expect("create");+ assert!(app.show_project_tree);++ app.path_input = fixture_path("tiny_x64.pe").display().to_string();+ app.import_into_project().expect("import tiny");+ app.path_input = fixture_path("analysis_lab.pe").display().to_string();+ app.import_into_project().expect("import lab");++ let tree = app.project_tree_model().expect("tree model");+ assert_eq!(tree.project_name, "TreeUX");+ assert_eq!(tree.files.len(), 2);+ assert!(tree.files.iter().any(|f| f.active));+ assert!(tree.files.iter().all(|f| !f.has_saved_analysis));+ assert_eq!(tree.files[0].status_label(), "Not analyzed");++ let lab_id = tree+ .files+ .iter()+ .find(|f| f.display_name.contains("analysis_lab"))+ .map(|f| f.id.clone())+ .expect("lab id");+ app.open_from_tree(&lab_id).expect("open from tree");+ assert_eq!(app.active_file_id.as_deref(), Some(lab_id.as_str()));+ assert!(app.program.is_some());+ let tree2 = app.project_tree_model().unwrap();+ assert!(tree2.files.iter().any(|f| f.id == lab_id && f.active));++ for (i, info) in app.analyzer_infos.iter().enumerate() {+ app.analyzer_enabled[i] =+ matches!(info.name.as_str(), "Function Start Search" | "Embedded Media");+ }+ // Analyze from tree opens options dialog (does not run yet).+ app.analyze_from_tree(&lab_id).expect("open analyze options");+ assert!(app.show_analysis_dialog);+ assert_eq!(app.pending_analyze_file_id.as_deref(), Some(lab_id.as_str()));+ app.use_gpu_experimental = true;+ app.begin_analysis_job().expect("begin");+ assert!(app.analysis_job.is_some());+ assert!(app.analysis_progress_fraction().is_some());+ while app.analysis_job.is_some() {+ app.step_analysis_job().expect("step");+ }+ assert!(app.analysis_progress_fraction().is_none());+ let tree3 = app.project_tree_model().unwrap();+ let lab_row = tree3.files.iter().find(|f| f.id == lab_id).unwrap();+ assert!(lab_row.has_saved_analysis, "{lab_row:?}");+ assert_eq!(lab_row.status_label(), "Analyzed");++ // Second run of status query consistent+ let tree4 = app.project_tree_model().unwrap();+ assert_eq!(+ tree3.files.iter().map(|f| f.has_saved_analysis).collect::<Vec<_>>(),+ tree4.files.iter().map(|f| f.has_saved_analysis).collect::<Vec<_>>()+ );++ // Delete requires confirm: request only sets pending; confirm removes.+ app.request_delete_file(&lab_id);+ assert!(app.pending_delete.is_some());+ app.cancel_delete_file();+ assert!(app.pending_delete.is_none());+ assert_eq!(app.project_tree_model().unwrap().files.len(), 2);+ app.request_delete_file(&lab_id);+ app.confirm_delete_file().expect("confirm delete");+ assert!(app.pending_delete.is_none());+ let after = app.project_tree_model().unwrap();+ assert_eq!(after.files.len(), 1);+ assert!(!after.files.iter().any(|f| f.id == lab_id));++ let _ = std::fs::remove_dir_all(&dir);+ }++ #[test]+ fn headless_load_and_analyze_uses_core() {+ let mut app = GhidrustApp::headless();+ assert_eq!(app.theme, ThemeMode::Dark);+ app.theme = app.theme.toggle();+ assert_eq!(app.theme, ThemeMode::Light);++ let pe = fixture_path("tiny_x64.pe");+ app.load_binary(&pe).expect("load");+ assert!(app.listing.iter().any(|i| i.mnemonic == "push"));++ for (i, info) in app.analyzer_infos.iter().enumerate() {+ app.analyzer_enabled[i] = matches!(+ info.name.as_str(),+ "ASCII Strings" | "WindowsPE x86 PE RTTI Analyzer"+ );+ }+ app.run_selected_analysis().expect("analyze");+ assert!(app.rtti.classes.iter().any(|c| c.name == "Widget"));+ assert!(!app.strings.is_empty());+ assert_eq!(app.analyzer_infos.len(), ANALYZER_NAMES.len());+ }++ #[test]+ fn headless_project_import_analyze_save() {+ let dir = std::env::temp_dir().join(format!("ghidrust_gui_proj_{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&dir);+ let mut app = GhidrustApp::headless();+ app.project_dir_input = dir.display().to_string();+ app.project_name_input = "GuiTest".into();+ app.create_project().expect("create");+ app.path_input = fixture_path("analysis_lab.pe").display().to_string();+ app.import_into_project().expect("import");+ assert!(app.program.is_some());+ for (i, info) in app.analyzer_infos.iter().enumerate() {+ app.analyzer_enabled[i] =+ matches!(info.name.as_str(), "Function Start Search" | "Embedded Media");+ }+ app.run_selected_analysis().expect("analyze");+ app.save_results().expect("save");+ let id = app.active_file_id.clone().unwrap();+ let proj = app.project.as_ref().unwrap();+ assert!(proj.analysis_path(&id).is_file());+ assert!(proj.listing_export_path(&id).is_file());+ // reopen+ let mut app2 = GhidrustApp::headless();+ app2.project_dir_input = dir.display().to_string();+ app2.open_project().expect("reopen");+ assert!(app2.program.is_some());+ let _ = std::fs::remove_dir_all(&dir);+ }++ #[test]+ fn source_embeds_m3_and_menus() {+ // Structural: shipped source contains theme toggle + menus (fallback evidence).+ let src = include_str!("main.rs");+ assert!(src.contains("Theme: Dark") || src.contains("ThemeMode"));+ assert!(src.contains("menu_button(\"File\""));+ assert!(src.contains("Program Tree"));+ assert!(src.contains("Project Tree") || src.contains("project_tree"));+ assert!(src.contains("Decompiler"));+ assert!(src.contains("ASCII Strings"));+ assert!(src.contains("Analyzed") || src.contains("has_saved_analysis"));+ assert!(src.contains("analyze_from_tree") || src.contains("small_button(\"Analyze\")"));+ assert!(src.contains("Browse") || src.contains("browse_binary_path") || src.contains("rfd::"));+ assert!(src.contains("pending_delete") || src.contains("Delete from project"));+ assert!(src.contains("use_gpu_experimental") || src.contains("GPU experimental"));+ assert!(src.contains("m3_linear_progress") || src.contains("Analysis progress"));+ assert!(src.contains("begin_analysis_job") || src.contains("Run Analysis"));+ assert!(src.contains("Overview") || src.contains("ui_overview"));+ assert!(src.contains("show_rows") || src.contains("rtti_filtered_idx"));+ assert!(src.contains("analysis_done_banner") || src.contains("Analysis complete"));+ assert!(src.contains("double_clicked") && src.contains("open_id"));+ assert!(src.contains("show_startup_picker") || src.contains("ui_startup_picker"));+ assert!(src.contains("recent_projects") || src.contains("Open existing project"));+ // No emoji codepoints in this file (Material geometry lives in icons.rs)+ // U+1F4C1 folder, U+25CF/U+25CB bullets, U+25B6 play — use escapes so the+ // forbidden glyphs themselves never appear in source.+ assert!(!src.contains('\u{1F4C1}'));+ assert!(!src.contains('\u{25CF}'));+ assert!(!src.contains('\u{25CB}'));+ assert!(!src.contains('\u{25B6}'));+ }++ #[test]+ fn icons_module_is_material_not_emoji() {+ let icons = include_str!("icons.rs");+ assert!(icons.contains("Material"));+ assert!(icons.contains("Folder") || icons.contains("folder"));+ assert!(!icons.contains('\u{1F4C1}'));+ assert!(!icons.contains('\u{25CF}'));+ }+}diff --git a/docs/GPU_ANALYZER_MATRIX.md b/docs/GPU_ANALYZER_MATRIX.mdnew file mode 100644index 0000000..d4c2d5b--- /dev/null+++ b/docs/GPU_ANALYZER_MATRIX.md@@ -0,0 +1,68 @@+# GPU strategy matrix — all Auto Analysis types + decompile++Each analyzer has a **dedicated GPU method class** (not one printable kernel labeled 20 ways).+CPU remains the correctness oracle. Timing always splits **PCIe** (upload+download) vs **on-device** (kernels).++**Research write-up with measured tables:** [PARALLEL_RE_RESEARCH.md](PARALLEL_RE_RESEARCH.md) (lab fixture, 8 MiB pad, ~175 MB RTTI seed, decompile multipass).++| Analyzer | Strategy class | GPU method (novel kernel / multipass) |+|----------|----------------|----------------------------------------|+| ASCII Strings | `printable_run` | Parallel printable-byte mark + host run compact |+| Aggressive Instruction Finder | `code_density` | Non-int3 / code-like density windows over exec image |+| Call Convention ID | `prologue_abi` | Scan push/mov/sub-rsp / ret patterns → ABI hint seeds |+| Call-Fixup Installer | `cstr_multi` | Multi-needle cstr for security_cookie / known fixups |+| Create Address Tables | `ptr_chain` | Parallel LE u64 “in-image-looking” density seeds |+| Decompiler Parameter ID | `spill_scan` | Scan rcx/rdx/r8/r9 spill encodings (48 89 4c/54/…) |+| Decompiler Switch Analysis | `ptr_chain` | Jump-table density (same family as address tables) |+| Demangler Microsoft | `cstr_multi` | `.?AV` / `?` mangled prefix multi-needle |+| Embedded Media | `magic_media` | PNG/JPEG/GIF/RIFF magic parallel match |+| Function ID | `hash_window` | Fixed-window rolling hash over exec prologues |+| Function Start Search | `prologue_seed` | `55 48 89 e5` and `48 83 ec` start seeds |+| Non-Returning Functions - Discovered | `cstr_multi` | ExitProcess / abort-style API name needles |+| PDB MSDIA | `cstr_multi` | MSF / PDB signature strings |+| PDB Universal | `cstr_multi` | Same portable MSF/signature family (distinct needle set id) |+| Shared Return Calls | `ret_epilogue` | `c3` / `c2` epilogue sites in exec |+| Stack | `stack_frame` | `sub rsp` / `mov [rbp+…]` frame markers |+| Variadic Function Signature Override | `cstr_multi` | printf/scanf family needles |+| WindowsPE x86 PE RTTI Analyzer | `rtti_scan` | `.?AV` / `.?AU` / `_ZTS` type-info name scan |+| Windows x86 Propagate External Parameters | `cstr_multi` | Known WinAPI name needles |+| WindowsResourceReference | `magic_res` | `VS_VERSION_INFO` / resource markers |+| **GPU Decompile** (not Auto Analysis) | `decomp_multipass` | VRAM multipass decode→leaders→blocks→emit |++## Timing model++```+pcie_ms = t_upload + t_download (host↔device for that run)+device_ms = t_kernels (on-chip / VRAM pipeline; SIMT workgroup_size=256)+wall_ms ≈ setup + pcie_ms + device_ms (setup reported separately when cold)+```++GPU decompile VRAM multipass reports the same split (`pcie_upload_ms` / `device_ms` / `pcie_download_ms`) via `bench_vram_decompile_vs_cpu`, which also records **CPU multipass wall** (`cpu_ms`) and oracle equality.++## Equality model (honest)++Analyzers — `equal` is **seed-stage** on the **same haystack** (including `--large` tiled pad):++- CPU: `cpu_emulate_kernel` (algorithm twin of WGSL)+- GPU: SIMT kernel atomic hit total + offset multiset (when under cap)++Not compared for analyzer `equal`: filtered Auto Analysis oracle counts (`analyzer_oracle`).+Host merge applies GPU seeds into `Program` analysis fields (`merged_primary`).++VRAM decompile — `equal` requires:++- `mid_pipeline_host_reads == 0`+- `normalize_pseudo(GPU) == normalize_pseudo(CPU multipass)`+- `ir_count` match++Large mode does **not** force `equal=true`.++## CLI++```bash+# fixture baseline (non-large)+ghidrust analyzer-bench fixtures/analysis_lab.pe --out metrics_fixture.json+# large tiled workload (≥8 MiB)+ghidrust analyzer-bench fixtures/analysis_lab.pe --large --out metrics_large.json+ghidrust analyzer-bench-matrix # print strategy matrix+```diff --git a/docs/GPU_DECOMPILER_RESEARCH.md b/docs/GPU_DECOMPILER_RESEARCH.mdnew file mode 100644index 0000000..62fff11--- /dev/null+++ b/docs/GPU_DECOMPILER_RESEARCH.md@@ -0,0 +1,236 @@+# GPU-Resident Multipass Decompilation for Reverse Engineering+### A practical method implemented in Ghidrust++**Authors:** Ghidrust project+**Date:** July 2026+**Status:** Implemented and tested in-tree (`crates/ghidrust-decomp`)+**Related:** [GPU_DECOMPILE_PROCESS.md](GPU_DECOMPILE_PROCESS.md), [PARALLEL_RE_RESEARCH.md](PARALLEL_RE_RESEARCH.md)++---++## Abstract++Classical decompilation (linear decode → basic blocks / CFG → structured emit) is usually considered a **CPU-only** workload because control-flow recovery is irregular and poorly matched to pure SIMT. This paper describes a **discovered, implemented process** that still performs the *full decompile pipeline on the GPU*, keeping intermediate IR, leader marks, block tables, edges, and emit buffers in **device memory (VRAM)** so that mid-pipeline work does not round-trip over PCIe. Host participation is limited to (1) a single upload of the function code region and (2) a single download of the final dump, written as a compact, greppable `.gdecomp` file for later scanning.++We report correctness results against a multipass CPU oracle and wall-clock timings on a real NVIDIA GeForce RTX 5090 (Vulkan via wgpu). On small fixtures, GPU multipass is **correct** and **VRAM-resident mid-pipeline**, but **not wall-clock faster** than a lightweight CPU decompile of the same region—overhead is dominated by device setup and host↔device transfers, not by lack of residency during kernels.++---++## 1. Introduction++### 1.1 Motivation++Reverse-engineering tools (Ghidra, IDA, Binary Ninja) run decompilation almost entirely on the CPU. GPUs have been used successfully for **bulk** RE tasks—multi-pattern string matching [Zha & Sahni], DPI/Aho–Corasick ports [Çelebi et al. 2023], Rabin–Karp NIDS [Abbas et al. 2024]—but those kernels do **not** produce structured pseudo-C for a function.++The open question for Ghidrust was:++> Can the *same logical decompile stages* that a hand-rolled CPU decompiler runs (decode → leaders → blocks/edges → emit) execute **on GPU**, with intermediates **only in VRAM**, and a **single** final dump to disk?++### 1.2 Contributions++1. A **fixed-shape multipass SIMT formulation** of decompile that maps each stage to a compute kernel.+2. An implementation (`ghidrust-decomp::gpu_decompile` + WGSL) with instrumented **mid-pipeline host-read count = 0** on the success path.+3. A **scan-friendly dump format** (`.gdecomp`) for grepping and tooling.+4. **Correctness oracles**: multipass text equality (GPU vs CPU multipass) and structural opcode match vs classic `decompile_instructions`.+5. Honest **performance measurements** on production hardware (no fabricated speedups).++### 1.3 Non-claims++This is **not** Hex-Rays / Ghidra parity (SSA, rich types, multi-ISA SLEIGH, recompilable C). It is **not** full x86 ISA emulation on the GPU as a general-purpose CPU substitute. It **is** full *Ghidrust* decompile stages on device with VRAM residency and a file dump.++---++## 2. Related work++| Area | Relevance |+|------|-----------|+| Cifuentes / classical decompilation | CPU pipeline: lift, CFG, structuring, emit |+| GPU multi-pattern matching [Zha & Sahni] | SIMT bulk scan; PCIe can erase wins |+| GPU DPI / AC [Çelebi 2023, Kouzinopoulos] | Packet/byte-parallel, not CFG emit |+| Ghidrust bulk_scan / gpu_analyzers | Orthogonal seed kernels for all 20 Auto Analysis types |+| [PARALLEL_RE_RESEARCH.md](PARALLEL_RE_RESEARCH.md) | PCIe vs on-device metrics; ~175 MB RTTI seed bench; large pad matrix |++Prior Ghidrust notes correctly stated that **branchy structuring** is a poor fit for “drop control flow on SIMT.” The method here **re-factors** that work into multipass fixed buffers rather than abandoning GPU decompile entirely. Analyzer-class SIMT seeds (printable, RTTI, prologue, …) are covered in the parallel RE research note; this paper focuses on **function-region multipass decompile in VRAM**.++---++## 3. Method: multipass VRAM decompile++### 3.1 Design principle++Map decompile to a **pipeline of device buffers**:++| Buffer | Role |+|--------|------|+| `buf_code` | Raw function bytes (uploaded once) |+| `buf_ir` | Fixed IR slots (offset, length, opcode, imm) |+| `buf_leaders` | Leader flags per IR slot |+| `buf_blocks` / `buf_edges` | Compact CFG tables |+| `buf_emit` | Final ASCII pseudo-C (downloaded once) |++**Invariant:** after the code upload, kernels only read/write device storage. Host does not download full IR between stages.++### 3.2 Kernels (WGSL / wgpu)++| Kernel | Work distribution | Effect |+|--------|-------------------|--------|+| `decode_walk` | Single active walker | Sequential x86 walk → IR slots (stops at `ret`) |+| `mark_leaders` | 1 thread / IR slot | Race-free leaders (only write `1` into zeroed buffer) |+| `build_blocks` | Single thread | Compact blocks + jmp/jcc/fall edges |+| `emit_text` | Single thread | Emit multipass normal-form pseudo-C using edges for `goto` / fall |++Opcode subset aligns with Ghidrust’s hand-rolled decoder for common prologues and control flow: push/pop/mov/xor/ret/int3/jmp/jcc (rel8/rel32 patterns).++### 3.3 Dump format (`.gdecomp`)++```+magic "GDEC" + version+entry u64+name (len + utf8)+n_ir, n_blocks, n_edges+emit (len + utf8 pseudo-C)+```++Header is binary-friendly; body is greppable for scanners and humans.++### 3.4 Correctness model++1. **Multipass normal form** — GPU emit and CPU `multipass_emit_from_ir` share the same template text.+2. **Classic structural oracle** — mnemonics from `decompile_instructions` map to the same opcode sequence as multipass IR until first `ret`.+3. **Branchy regions** — synthetic `jcc` shells exercise multi-block edges; GPU path must match multipass on the **same bytes** (not only on linear PE entry).++---++## 4. Implementation in Ghidrust++| Artifact | Path |+|----------|------|+| Kernels | `crates/ghidrust-decomp/src/gpu_decompile.wgsl` |+| Host orchestration | `crates/ghidrust-decomp/src/gpu_decompile.rs` |+| CPU classic decompile | `crates/ghidrust-decomp/src/lib.rs` |+| CLI | `ghidrust gpu-decompile …` |++```bash+ghidrust gpu-decompile fixtures/tiny_x64.pe --out entry.gdecomp --metrics metrics.log+```++API surface:++- `gpu_decompile_to_file(prog, va, path, max_bytes)` — PE-backed region+- `gpu_decompile_code_to_file(name, entry, code, path)` — raw bytes (tests / synthetic shells)++Residency: `mid_pipeline_host_reads` increments only on mid-pipeline maps (`HostReadKind::MidPipeline`). Final emit/meta maps use `FinalDump` and do not increment.++---++## 5. Experimental results++### 5.1 Test suite (shipped)++`cargo test -p ghidrust-decomp` — **11/11 passed** (representative run, debug build), including:++| Test | What it proves |+|------|----------------|+| `gpu_or_fallback_writes_dump_and_residency` | Real PE → dump; `mid_reads=0`; `backend=gpu_vram_multipass`; multipass text equality; classic structural match |+| `gpu_branchy_code_region_equivalence` | **GPU kernels on branchy jcc bytes**; multi-block; GPU text == multipass |+| `shipped_entry_twice_consistent` | Double-run determinism on GPU |+| `residency_counter_detects_mid_pipeline_reads` | Counter is real (increments when mid-pipeline path used) |+| Classic / multipass unit tests | CPU oracles and dump codec |++CLI integration: `cargo test -p ghidrust-cli --test re_bench` includes `gpu_decompile_dump_and_metrics`.++### 5.2 Live metrics (RTX 5090, Vulkan)++Captured via shipped CLI on `fixtures/tiny_x64.pe` (debug `ghidrust`):++| Metric | Value |+|--------|--------|+| Device | NVIDIA GeForce RTX 5090 (Vulkan) |+| Backend | `gpu_vram_multipass` |+| Kernels | decode_walk, mark_leaders, build_blocks, emit_text |+| Mid-pipeline host IR reads | **0** |+| IR / blocks / edges | 5 / 1 / 0 |+| Dump size | 187 bytes |+| Multipass equivalence | **true** |+| CPU classic decompile time | ~0.2–2 ms (order of magnitude; includes process noise) |+| GPU multipass wall time | **~450–520 ms** (includes adapter pipeline setup + transfers) |++Example dump content (abbreviated):++```c+// GPU decompile+void FUN(void) {+ // block_0+ block_0:+ /* push */;+ /* mov */;+ /* xor */;+ /* pop */;+ return;+}+```++### 5.3 Was the GPU faster?++**On this fixture size: no — not in wall-clock milliseconds.**++| Observation | Interpretation |+|-------------|----------------|+| `mid_pipeline_host_reads = 0` | Intermediate decompile state stayed in **GPU memory** between kernels (residency goal **met**) |+| GPU ~500 ms vs CPU ~1–2 ms | Wall-clock dominated by **device setup + H→D/D→H**, not by mid-pipeline PCIe thrashing |+| Equal multipass text | GPU decompile **correct** relative to the multipass algorithm |+| Branchy GPU path | Multi-block control flow also runs on GPU and matches multipass |++So:++- **Yes:** decompile stages ran **on the GPU**, with IR/CFG/emit in **VRAM**, single dump at the end.+- **No:** that does **not** imply “always faster than CPU” for tiny functions. For small regions, a pure CPU walk wins on latency. The architecture is designed so larger regions can amortize transfer cost without re-downloading IR every instruction—latency wins require larger workloads and/or persistent device context (future work: keep a warm pipeline).++Bulk RE (`bulk-bench` / `re-bench`) similarly shows parallel CPU often beating cold GPU on multi-MiB padded haystacks when PCIe is in the critical path—consistent with Zha & Sahni host-to-host findings.++---++## 6. Discussion++### 6.1 Why residency still matters if GPU is “slower”++Naïve designs that download IR after every instruction multiply PCIe cost by *N*. Multipass residency fixes that scaling law: cost is **O(1) transfers** + kernel time, not **O(N) transfers**. Small-N benchmarks hide that win.++### 6.2 Limitations++- Opcode coverage is a deliberate subset of the hand-rolled decoder (not full x86-64).+- Emit is multipass normal form, not Hex-Rays-quality C.+- Cold-start wgpu pipeline cost is large relative to a 5-instruction function.+- Some stages remain single-threaded *on device* (decode walk, emit); parallelization of those stages is future work without abandoning residency.++### 6.3 Future work++- Persistent device/pipeline reuse across many functions+- Larger IR capacity and multi-function batch upload+- Wider opcode coverage shared with `ghidrust-core::disasm`+- Optional SSA-lite passes still fully device-resident++---++## 7. Conclusion++Ghidrust implements a **novel multipass GPU decompile process**: custom WGSL kernels execute full decompile stages with intermediates in VRAM, then dump a scan-friendly `.gdecomp` file. Tests prove **correctness** (including branchy regions) and **residency** (`mid_pipeline_host_reads = 0`) on real NVIDIA hardware. Wall-clock GPU times on small fixtures are **higher** than CPU due to setup/transfer overhead—not because intermediates left the GPU mid-pipeline. The method is therefore best understood as **correct GPU-memory-resident decompile with O(1) PCIe**, with latency competitiveness expected as region size and pipeline reuse grow.++---++## References (selected)++1. Cifuentes, C. — reverse compilation / decompilation foundations.+2. Zha & Sahni — *Multipattern String Matching On A GPU*.+3. Çelebi et al. (2023) — GPU pattern matching / DPI (MDPI Applied Sciences).+4. Kouzinopoulos et al. — Multiple string matching on GPU (CUDA).+5. Abbas et al. (2024) — Multi-pattern GPU Rabin–Karp (NIDS).+6. Ghidrust in-tree: `docs/PARALLEL_RE_RESEARCH.md`, `docs/GPU_DECOMPILE_PROCESS.md`.++## How to reproduce++```bash+cargo test -p ghidrust-decomp+cargo run -p ghidrust-cli --release -- gpu-decompile fixtures/tiny_x64.pe \+ --out entry.gdecomp --metrics metrics.log --json+```diff --git a/docs/GPU_DECOMPILE_PROCESS.md b/docs/GPU_DECOMPILE_PROCESS.mdnew file mode 100644index 0000000..2da5bca--- /dev/null+++ b/docs/GPU_DECOMPILE_PROCESS.md@@ -0,0 +1,75 @@+# GPU-resident full decompile process (discovered multi-pass SIMT method)++**Status:** implemented in `ghidrust-decomp::gpu_decompile`+**Date:** 2026-07++## Problem this solves++Classical decompilation is branchy (CFG, structuring). Prior notes treated “decompile on GPU” as impossible.+**Discovery:** decompile can be **re-factored into fixed-shape multi-pass stages** that run entirely in **VRAM**:++1. Host uploads the function **code region once** (single PCIe H→D).+2. On-device kernels transform device buffers only (no mid-pipeline full-IR download).+3. Host downloads **only the final dump buffer once** (D→H) and writes a scan-friendly file.++This avoids PCIe per-instruction / per-block round-trips that make naïve “GPU helper” decompilers lose.++## Dataflow (residency)++```+HOST DEVICE (VRAM)+───── ─────────────+code_bytes ──upload──► buf_code+ │+ [K1 decode_walk] → buf_ir[MAX_IR]+ │+ [K2 mark_leaders] → buf_leaders[MAX_IR]+ │+ [K3 build_blocks] → buf_blocks[MAX_BLOCKS], buf_edges[MAX_EDGES]+ │+ [K4 emit_text] → buf_emit[MAX_EMIT] (ASCII pseudo-C dump)+ │+host ◄──single map/read──┘+ write file .gdecomp+```++**Invariant:** `mid_pipeline_host_reads == 0` (instrumented). Only the final emit buffer is read back.++## Kernel roles (custom WGSL compute)++| Kernel | SIMT shape | Input (device) | Output (device) |+|--------|------------|----------------|----------------|+| `decode_walk` | 1 active walker (or workgroup) walks x86 stream into fixed IR slots | `buf_code` | `buf_ir` |+| `mark_leaders` | 1 thread per IR slot | `buf_ir` | `buf_leaders` |+| `build_blocks` | compact leaders → block table + edges | `buf_ir`, `buf_leaders` | `buf_blocks`, `buf_edges` |+| `emit_text` | walk blocks/insns into byte buffer | all tables | `buf_emit` |++x86 decode uses the **same opcode subset** as Ghidrust’s hand-rolled CPU decoder for fixture/common prologue patterns (push/mov/xor/pop/ret/int3/jmp/jcc). Bounded multi-pass, not commercial Hex-Rays parity.++## Dump format (`.gdecomp` — scan-friendly)++```+magic: "GDEC" + version u8=1+entry: u64 LE+name_len: u32 LE + utf8 name+n_ir / n_blocks / n_edges: u32 LE each+emit_len: u32 LE + utf8 pseudo-C+```++Text section is greppable; header is compact for tooling.++## Correctness++1. **Multipass normal form:** GPU `emit_text` and CPU `multipass_emit_from_ir` share the same template (`void FUN`, `block_N`, `if (/* jcc */) { goto … }`, `// fall block_N`, `return;`).+2. **Classic structural oracle:** `decompile_instructions` mnemonics (until first `ret`) map to the same opcode sequence as multipass IR (`structural_ops_match_classic`).+3. **Leaders are race-free:** `mark_leaders` only writes `1` into a zero-initialized buffer (never writes `0`), so branch targets cannot lose leader status.++## Relation to bulk scan++`bulk_scan` printable/pattern GPU kernels are **orthogonal**. This process is **full decompile stages on GPU**, not a rebranded string scan.++## CLI++```bash+ghidrust gpu-decompile fixtures/tiny_x64.pe --out entry.gdecomp --metrics metrics.json+```diff --git a/docs/PARALLEL_RE_RESEARCH.md b/docs/PARALLEL_RE_RESEARCH.mdnew file mode 100644index 0000000..b290075--- /dev/null+++ b/docs/PARALLEL_RE_RESEARCH.md@@ -0,0 +1,240 @@+# Parallel CPU + GPU reverse engineering in Ghidrust+### Research note: bulk scan, per-analyzer SIMT kernels, and VRAM multipass decompile++**Status:** implemented in-tree (`ghidrust-core`, `ghidrust-decomp`, `ghidrust-cli`)+**Date:** 2026-07+**Hardware used for metrics:** NVIDIA GeForce RTX 5090 (Vulkan via wgpu), Windows host+**Related:** [GPU_ANALYZER_MATRIX.md](GPU_ANALYZER_MATRIX.md), [GPU_DECOMPILER_RESEARCH.md](GPU_DECOMPILER_RESEARCH.md), [GPU_DECOMPILE_PROCESS.md](GPU_DECOMPILE_PROCESS.md)++---++## Abstract++Ghidrust separates reverse-engineering work into (1) **branchy / graph-heavy** stages that stay on the CPU and (2) **byte-parallel seed stages** that map to SIMT compute. This note records the **implemented** CPU work-stealing path, the **experimental GPU path for all twenty Auto Analysis types** (dedicated kernels, not one printable kernel rebranded), **VRAM-resident multipass decompile**, and **honest timings** that split **PCIe transfer** from **on-device kernel** time.++**Primary finding:** on large images, on-device GPU seed kernels are often **tens of times faster** than the matching CPU seed loop. End-to-end GPU wall time is usually dominated by **cold adapter/pipeline setup** and **host↔device transfer**, not by kernel arithmetic. A real **~175 MB** PE RTTI seed scan measured **~1.6 ms on-device** vs **~102 ms** for the CPU seed twin and **~84 s** for full CPU RTTI recovery—while PCIe for that image was only **~24 ms**. Transfer cost scales with size; it is not evidence that “GPU compute is slow.”++---++## 1. Defining split (do not blur)++| Role | Work shape | Fits GPU? | Ghidrust approach |+|------|------------|-----------|-------------------|+| **CPU work-stealing pool** | Independent bulk chunks, CFG/type merge, full RTTI graph, analyzer orchestration | Branchy / irregular | `rayon` / available_parallelism; product analyzers on host |+| **Bulk / seed SIMT kernels** | Printable runs, magic bytes, prologues, RTTI name marks, pointer density, multi-needle cstr | Yes when transfer amortized | WGSL `@workgroup_size(256)` + multi-dispatch for large *n* |+| **Decompile multipass** | Fixed IR/CFG/emit buffers | Partial (fixed-shape multipass) | VRAM pipeline; mid-pipeline host IR reads = 0 |++**GPU is not a hyper-thread.** Hyper-threading is CPU SMT. A GPU is a wide SIMT accelerator. Treating warps as “more hyper-threads for sequential decompile” is a category error. Ghidrust uses the GPU where the algorithm is **data-parallel seeds** or a **fixed multipass layout**, then **host-merges** into the program model.++---++## 2. Related work (external)++1. **Zha & Sahni — Multipattern String Matching On A GPU** — host↔device transfer often erases wins on moderate sizes.+2. **Çelebi et al. (2023) — GPU DPI multi-pattern** — memory/throughput tradeoffs for byte streams.+3. **Kouzinopoulos et al. — multi-string on CUDA** — AC / Set Horspool class layouts.+4. **Abbas et al. (2024) — multi-pattern GPU Rabin–Karp** — rolling hashes map cleanly when dictionaries grow.+5. **Classical:** Aho–Corasick, Wu–Manber as CPU multi-pattern foundations.++**External takeaway:** GPUs win on **large haystacks + simple predicates** when data is resident or transfer is amortized. Ghidrust’s measurements match that literature: small fixtures lose end-to-end to setup; multi-MiB and ~100 MB+ images show clear **on-device** wins.++---++## 3. Analyzer coverage: twenty Auto Analysis types + decompile++Every registered Auto Analysis name has a **strategy class** and a **dedicated kernel entry** (see [GPU_ANALYZER_MATRIX.md](GPU_ANALYZER_MATRIX.md)). Strategies are **not** a single printable kernel with twenty labels.++| Strategy class | Kernel (WGSL) | Typical analyzers | Algorithm sketch |+|----------------|---------------|-------------------|------------------|+| `printable_run` | `k_printable` | ASCII Strings | SIMT run starts of printable length ≥ 4 |+| `code_density` | `k_code_density` | Aggressive Instruction Finder | 16-byte windows, non-`0xCC`/zero density |+| `prologue_abi` / `prologue_seed` | `k_prologue` | Call Convention ID, Function Start Search | `55 48 89 e5` / `48 83 ec` seeds |+| `cstr_multi` | `k_cstr` (per needle) | Call-Fixup, Demangler, PDB*, Noreturn, Variadic, External params | Multi-dispatch multi-needle ≤16 B |+| `ptr_chain` | `k_ptr_u64` | Address Tables, Switch Analysis | 8-byte-aligned in-image u64 runs ≥ 3 |+| `spill_scan` | `k_spill` | Decompiler Parameter ID | rcx/rdx/r8/r9 spill encodings |+| `magic_media` | `k_magic_media` | Embedded Media | PNG / JPEG / GIF / RIFF magics |+| `hash_window` | `k_hash_win` | Function ID | FNV-1a over 8 B at prologue-like starts (aux hash buffer) |+| `ret_epilogue` | `k_ret` | Shared Return Calls | `c3` / `c2` |+| `stack_frame` / `sub_rsp` | `k_stack` / `k_sub_rsp` | Stack | `sub rsp` / frame mov markers |+| `rtti_scan` | `k_rtti` | WindowsPE x86 PE RTTI Analyzer | `.?AV` / `.?AU` / `_ZTS` |+| `magic_res` | `k_magic_res` | WindowsResourceReference | `VS` / `RS` resource markers |+| `decomp_multipass` | `decode_walk` → `mark_leaders` → `build_blocks` → `emit_text` | GPU decompile (not Auto Analysis) | VRAM multipass; final dump only |++### 3.1 Execution mechanics (analyzer kernels)++- **SIMT:** `@workgroup_size(256)`; one invocation per byte or candidate (ptr/density use strided candidates).+- **Hit compact:** device `atomicAdd` into a hit buffer; optional **aux** buffer (hashes for Function ID).+- **Large images:** wgpu limits **65535 workgroups per dimension**. Full-image scans chunk invocations with a **`base_inv`** uniform and multi-dispatch (e.g. ~12 chunks for ~188 MB of mapped image).+- **PCIe timing:** upload (haystack + buffers) vs device (kernels only) vs download (hit buffer map) are **separate clocks**.+- **Equality:** seed multiset / count match between CPU `cpu_emulate_kernel` and GPU on the **same haystack** (including tiled large pad). Filtered Auto Analysis counts (`analyzer_oracle`) are informational, not the equality oracle.+- **Host merge:** GPU seeds write into `Program` analysis fields (`gpu_enrich_analyzers` / `merge_seeds_into_program`).++### 3.2 User-facing activation++| Surface | Per-analyzer selection | GPU |+|---------|------------------------|-----|+| CLI | `--analyzers a,b` or repeatable `--analyzer NAME` | `--gpu` on `analyze` / `project analyze` |+| GUI | Checkboxes in Analysis options | GPU checkbox (bulk strings + per-analyzer seed enrich) |+| MCP | `analyzers[]` | `gpu: true` on `analyze` |+| Bench | — | `analyzer-bench`, `rtti-gpu-bench`, `gpu-decompile` |++`--gpu` sets bulk mode to GPU-or-fallback for ASCII Strings **and** runs each selected analyzer’s strategy kernel + host merge after the CPU analyzer pass.++---++## 4. Decompile multipass (VRAM)++Separate from Auto Analysis seeds: function-region **decode → leaders → blocks → emit** with mid-pipeline IR remaining on device. Documented fully in [GPU_DECOMPILER_RESEARCH.md](GPU_DECOMPILER_RESEARCH.md). Fixture runs report `backend=gpu_vram_multipass`, `mid_pipeline_host_reads=0`, multipass text equality vs CPU multipass oracle, and PCIe/device split on the multipass row of `analyzer-bench`.++---++## 5. Timing model++```+pcie_ms = t_upload + t_download # host↔device for that run+device_ms = t_kernels # on-chip / VRAM only+wall_ms ≈ setup_ms + pcie_ms + device_ms # cold setup often dominates wall+```++**Interpretation rule:** never report a single wall number as “GPU speed.” Always split **setup**, **PCIe**, and **device**.++---++## 6. Measured metrics (current)++All GPU rows used a real adapter (`gpu_analyzer_kernel` / `gpu_vram_multipass`, RTX 5090 / Vulkan) unless noted. Times in **milliseconds**. Seed equality `true` means CPU kernel twin matched GPU on the same haystack.++### 6.1 Lab fixture PE (small; ~KB image)++Representative `analyzer-bench` rows (fixture, not padded). **Wall is setup-heavy**; on-device is sub-millisecond to a few tenths of a ms.++| Analyzer / row | Strategy | cpu seed ms | pcie_up | device | pcie_dn | gpu wall | hits | equal |+|----------------|----------|------------:|--------:|-------:|-------:|---------:|-----:|:-----:|+| ASCII Strings | printable_run | ~0.01–0.02 | ~5.3 | ~0.2 | ~0.6 | ~400–550 | 11 | true |+| Function Start Search | prologue_seed | ~0.004 | ~5.5 | ~0.15 | ~0.5 | ~290 | 6 | true |+| WindowsPE x86 PE RTTI | rtti_scan | ~0.005–0.01 | ~5–7 | ~0.15–0.23 | ~0.6 | ~265–420 | 1 | true |+| Function ID | hash_window | ~0.002 | ~5.6 | ~0.15 | ~0.5 | ~280 | 9 | true |+| Shared Return Calls | ret_epilogue | ~0.002 | ~5–9 | ~0.15 | ~0.5 | ~270 | 5 | true |+| GPU Decompile VRAM multipass | decomp_multipass | cpu multipass ~0.02–0.03 | ~7–8 | ~0.2 | ~0.5–0.8 | ~290–470 | ir=5 | true* |++\*Decompile equality: `mid_pipeline_host_reads==0` + multipass pseudo-C + IR count vs CPU multipass.++**Reading:** on tiny images, **GPU wall loses** to pure CPU seed time; the interesting columns are **device** and **PCIe**, not wall.++### 6.2 Large tiled workload (8 MiB pad of lab image)++`ghidrust analyzer-bench <lab.pe> --large` tiles the image to ≥ 8 MiB for throughput comparison (same seed algorithms; equality still on the **padded** haystack).++| Analyzer | Strategy | cpu seed ms | device_ms | pcie_ms | gpu hits | equal | on-device vs CPU seed |+|----------|----------|------------:|----------:|--------:|---------:|:-----:|----------------------|+| ASCII Strings | printable_run | ~3.1 | ~0.20 | ~8 | 11264 | true | ~15× |+| Aggressive Instr. Finder | code_density | ~0.6–2.8 | ~0.16–0.31 | ~7–13 | 6144 | true | ~4–10× |+| Call Convention ID | prologue_abi | ~4–6 | ~0.16–0.41 | ~7–8 | 12288 | true | ~15–30× |+| Function Start Search | prologue_seed | ~4–6 | ~0.17–0.19 | ~7–9 | 12288 | true | ~25–35× |+| Function ID | hash_window | ~2.6–3.3 | ~0.15–0.17 | ~6–7 | 18432 | true | ~15–20× |+| Shared Return Calls | ret_epilogue | ~2.3 | ~0.15–0.18 | ~7–12 | 10240 | true | ~12–15× |+| Stack | stack_frame | ~3.1–3.3 | ~0.15–0.17 | ~6–7 | 6144 | true | ~20× |+| RTTI Analyzer | rtti_scan | ~4.7 | ~0.16–0.17 | ~7–8 | 1024 | true | ~28× |+| Embedded Media | magic_media | ~6.3–6.6 | ~0.15 | ~6–7 | 1024 | true | ~40× |+| Multi-needle cstr family | cstr_multi | ~30–66 | ~0.3–1.0† | ~14–57† | 1024–2048 | true | device still ≪ CPU; wall multi-needle |++†Multi-needle runs one kernel dispatch **per needle** (upload/setup repeated per needle in current harness → higher wall; device per needle still low).++**Reading:** at multi-MiB scale, **device_ms** consistently beats the CPU seed twin. **gpu_wall** remains hundreds of ms when each analyzer **cold-inits** the GPU—a harness artifact; product paths that reuse a device would amortize setup.++### 6.3 Large real PE (~175 MB file, ~188 MB mapped image) — RTTI focus++Measured with shipped `ghidrust rtti-gpu-bench` (CPU full `recover_rtti` + GPU `rtti_scan` seed path). **No product-specific claims**—size and metrics only.++| Metric | Value |+|--------|------:|+| File size | **~175 MB** (~183.6 M bytes) |+| Mapped image scanned | **~188 MB** |+| GPU dispatch chunks | **12** (65535 workgroup limit) |+| PE load | **~79 ms** |+| CPU full RTTI recover | **~84 300 ms** (~84.3 s) |+| CPU RTTI classes (oracle) | **~71 400** |+| CPU seed twin (`rtti_scan` algorithm) | **~102 ms**, **~92 070** hits |+| GPU PCIe upload | **~23.6 ms** |+| **GPU on-device** | **~1.61 ms** |+| GPU PCIe download | **~0.70 ms** |+| GPU PCIe total | **~24.3 ms** |+| GPU wall (incl. cold setup ~464 ms) | **~490 ms** |+| Seed equal (CPU twin vs GPU) | **true** |+| On-device speedup vs seed CPU | **~64×** |+| PCIe / device | **~15×** (transfer still > kernel, still ≪ full RTTI) |+| Full CPU RTTI / GPU wall | **~172×** |++**Conclusion for ~175 MB:**++1. **On-device GPU seed scan wins decisively** (~1.6 ms vs ~102 ms seed CPU).+2. **Uploading ~188 MB is real (~24 ms)** but is **not** “the GPU is slow”—it is bandwidth cost, and it is tiny next to **~84 s** full CPU RTTI recovery.+3. **Cold setup** (~0.5 s) dominates GPU **wall** for a single one-shot run; reusing a device or batching kernels would change wall without changing device_ms.+4. Seed hit count (~92k) is **raw markers**; full recovery (~71k classes) is a **host graph/filter** step—GPU accelerates the bulk mark stage, not the entire semantic RTTI product alone.++### 6.4 Correctness posture++| Check | Result |+|-------|--------|+| Strategy matrix covers all 20 `ANALYZER_NAMES` | yes |+| Seed equality fixture + large pad | tests green; `equal=true` on measured rows |+| GPU decompile mid-pipeline host IR reads | **0** on success path |+| Multipass pseudo equality | fixture / VRAM bench rows |+| Fallback without adapter | `cpu_kernel_fallback` / multipass CPU; same algorithms |++---++## 7. What we deliberately do **not** claim++- GPU always wins **end-to-end wall** on small binaries (setup + PCIe often lose).+- Full Hex-Rays / Ghidra SSA decompile on GPU.+- Full RTTI class graph *only* on GPU (seeds + host merge/recover).+- Fabricated “faster than Ghidra” without a captured head-to-head on the same binary and analyzer set.+- That PCIe is free for 100 MB+ images—**it is measured and named**.++---++## 8. Implementation map++| Component | Location |+|-----------|----------|+| Analyzer SIMT kernels | `crates/ghidrust-core/src/gpu_analyzers/kernels.wgsl` |+| Engine (PCIe split, multi-dispatch) | `…/gpu_analyzers/engine.rs` |+| Strategy matrix + merge + bench | `…/gpu_analyzers/strategies.rs`, `mod.rs` |+| `run_analyzers_opts(..., use_gpu)` | `crates/ghidrust-core/src/analyzers/mod.rs` |+| Bulk printable (rayon + GPU) | `crates/ghidrust-core/src/bulk_scan.rs` |+| VRAM decompile | `crates/ghidrust-decomp` |+| CLI | `analyze --gpu`, `analyzer-bench`, `rtti-gpu-bench`, `gpu-decompile`, `bulk-bench` |++Reproduce:++```bash+ghidrust analyzer-bench-matrix+ghidrust analyzer-bench fixtures/analysis_lab.pe --out fixture_metrics.txt+ghidrust analyzer-bench fixtures/analysis_lab.pe --large --out large_metrics.txt+ghidrust rtti-gpu-bench <large.pe> --out rtti_metrics.txt --json+ghidrust gpu-decompile fixtures/analysis_lab.pe --metrics gdec.json+ghidrust analyze <path> --analyzer "WindowsPE x86 PE RTTI Analyzer" --gpu --json+```++---++## 9. Alignment with product goals++| Goal | Status |+|------|--------|+| Work-stealing bulk CPU | shipped (`bulk_scan`, rayon) |+| GPU optional for bulk / seeds | shipped; all 20 analyzers + decompile multipass |+| Honest PCIe vs on-device | shipped in engine + benches |+| Per-analyzer activation + GPU flag | CLI `--analyzer` / `--gpu`, GUI checkbox, MCP `gpu` |+| No myth “GPU = hyper-threading” | documented and measured |++---++## 10. Summary++Ghidrust treats the GPU as a **SIMT seed and multipass-decompile accelerator**, not a substitute for CPU hyper-threads on irregular RE graphs. Twenty Auto Analysis types each have a **named kernel strategy**; large haystacks use **chunked dispatch**. Metrics show:++- **On-device** seed work is often **much** faster than CPU on multi-MiB and **~175 MB** images.+- **PCIe + cold setup** explain most GPU **wall** time on one-shot runs.+- For a **~175 MB** PE, **~24 ms** PCIe and **~1.6 ms** RTTI seed device time sit next to **~84 s** full CPU RTTI—supporting the model that **transfer is a tax, not a proof of slow GPU compute**.diff --git a/fixtures/analysis_lab.meta.txt b/fixtures/analysis_lab.meta.txtnew file mode 100644index 0000000..e6f8452--- /dev/null+++ b/fixtures/analysis_lab.meta.txt@@ -0,0 +1,15 @@+image_base=0x140000000+entry=0x140001000+func_stack=0x140001030+func_nr=0x140001050+func_a=0x140001070+func_b=0x140001090+aif_orphan=0x140001018+png_va=0x140002050+addr_table=0x140002070+rsrc_va=0x140002090+pdb_va=0x1400020a8+api_exit=0x140002000+api_printf=0x140002010+api_cookie=0x140002018+mangled=0x140002030diff --git a/fixtures/analysis_lab.pe b/fixtures/analysis_lab.penew file mode 100644index 0000000..5c4081aBinary files /dev/null and b/fixtures/analysis_lab.pe differdiff --git a/fixtures/tiny_x64.elf b/fixtures/tiny_x64.elfnew file mode 100644index 0000000..dc9d431Binary files /dev/null and b/fixtures/tiny_x64.elf differdiff --git a/fixtures/tiny_x64.pe b/fixtures/tiny_x64.penew file mode 100644index 0000000..7a7f989Binary files /dev/null and b/fixtures/tiny_x64.pe differdiff --git a/fixtures/tiny_x64_elf.meta.txt b/fixtures/tiny_x64_elf.meta.txtnew file mode 100644index 0000000..fd5e9b2--- /dev/null+++ b/fixtures/tiny_x64_elf.meta.txt@@ -0,0 +1,2 @@+entry=0x401000+code_hex=554889e531c05dc3diff --git a/fixtures/tiny_x64_pe.meta.txt b/fixtures/tiny_x64_pe.meta.txtnew file mode 100644index 0000000..2ebb795--- /dev/null+++ b/fixtures/tiny_x64_pe.meta.txt@@ -0,0 +1,9 @@+image_base=0x140000000+entry=0x140001000+text_va=0x140001000+rdata_va=0x140002000+td_va=0x140002000+col_va=0x140002050+vtable_va=0x140002070+class=Widget+code_hex=554889e531c05dc3diff --git a/scripts/gen_analysis_lab.py b/scripts/gen_analysis_lab.pynew file mode 100644index 0000000..704b83d--- /dev/null+++ b/scripts/gen_analysis_lab.py@@ -0,0 +1,201 @@+#!/usr/bin/env python3+"""Build fixtures/analysis_lab.pe — PE32+ with real patterns for all analyzers."""+from __future__ import annotations+import struct+from pathlib import Path++ROOT = Path(__file__).resolve().parents[1]+FIX = ROOT / "fixtures"+FIX.mkdir(exist_ok=True)++IMAGE_BASE = 0x140000000+FILE_ALIGN = 0x200+SECT_ALIGN = 0x1000+++def align(n: int, a: int) -> int:+ return (n + a - 1) & ~(a - 1)+++def build() -> bytes:+ # --- .text layout (RVA 0x1000) ---+ # entry @ 0: standard FID prologue+ entry = bytes([0x55, 0x48, 0x89, 0xE5, 0x31, 0xC0, 0x5D, 0xC3])+ # gap then second function (AIF target) with same start hash+ pad = b"\xCC" * 8+ # func_stack @ offset 0x20: push rbp; mov rbp,rsp; sub rsp,0x20; mov [rbp+10h],rcx; ret+ func_stack = bytes(+ [+ 0x55,+ 0x48,+ 0x89,+ 0xE5,+ 0x48,+ 0x83,+ 0xEC,+ 0x20,+ 0x48,+ 0x89,+ 0x4D,+ 0x10,+ 0xC3,+ ]+ )+ # func_nr @ 0x40: no ret, ends in int3 (noreturn body)+ func_nr = bytes([0x48, 0x83, 0xEC, 0x28, 0xFF, 0x15, 0x00, 0x00, 0x00, 0x00, 0xCC, 0xCC])+ # shared epilogue pattern twice for shared-return (add rsp; pop rbp; ret)+ shared_ep = bytes([0x48, 0x83, 0xC4, 0x20, 0x5D, 0xC3])+ # func_a ends with shared_ep; func_b ends with same+ func_a = bytes([0x55, 0x48, 0x89, 0xE5, 0x90, 0x90]) + shared_ep+ func_b = bytes([0x55, 0x48, 0x89, 0xE5, 0x31, 0xC9]) + shared_ep++ text = bytearray(0x200)+ text[0:8] = entry+ text[0x10:0x10 + len(pad)] = pad+ # orphan code for AIF at 0x18 (gap from entry which ends 0x8)+ text[0x18:0x18 + 8] = bytes([0x55, 0x48, 0x89, 0xE5, 0x90, 0x90, 0x5D, 0xC3])+ text[0x30 : 0x30 + len(func_stack)] = func_stack+ text[0x50 : 0x50 + len(func_nr)] = func_nr+ text[0x70 : 0x70 + len(func_a)] = func_a+ text[0x90 : 0x90 + len(func_b)] = func_b++ # --- .rdata (RVA 0x2000) ---+ rdata = bytearray()+ text_va = IMAGE_BASE + 0x1000++ def rva_here() -> int:+ return 0x2000 + len(rdata)++ def va_here() -> int:+ return IMAGE_BASE + rva_here()++ # API name strings (scanned by call_fixup / varargs / noreturn / external_params)+ api_names = [+ b"ExitProcess\0",+ b"printf\0",+ b"__security_check_cookie\0",+ b"?MyFunc@@YAXXZ\0",+ b".?AVLabClass@@\0",+ ]+ api_vas = []+ for name in api_names:+ api_vas.append(va_here())+ rdata += name+ while len(rdata) % 8:+ rdata += b"\0"++ # PNG+ png_va = va_here()+ rdata += bytes([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])+ rdata += bytes([0, 0, 0, 0x0D, ord("I"), ord("H"), ord("D"), ord("R")]) + b"\0" * 16++ # Address / switch table: 4 pointers into .text+ while len(rdata) % 8:+ rdata += b"\0"+ at_va = va_here()+ targets = [text_va + 0x30, text_va + 0x50, text_va + 0x70, text_va + 0x90]+ for t in targets:+ rdata += struct.pack("<Q", t)++ # Resource marker+ rsrc_va = va_here()+ rdata += b"RS\0\0" + struct.pack("<I", 16) + b"VS_VERSION_INFO\0"+ while len(rdata) % 8:+ rdata += b"\0"++ # Mini-PDB: MSF7 magic + page size + symbol stream (hand format)+ pdb_va = va_here()+ pdb = bytearray(b"Microsoft C/C++ MSF 7.00\r\n\x1aDS\0\0\0")+ pdb += struct.pack("<I", 0x1000) # page size+ # stream: u32 count, then (u64 va, u16 len, name bytes)+ syms = [+ (text_va, b"LabEntry"),+ (text_va + 0x30, b"LabStackFrame"),+ (text_va + 0x50, b"LabNoReturn"),+ ]+ stream = struct.pack("<I", len(syms))+ for va, nm in syms:+ stream += struct.pack("<QH", va, len(nm)) + nm+ pdb += stream+ rdata += pdb++ # --- assemble PE ---+ text_rva, rdata_rva = 0x1000, 0x2000+ entry_rva = text_rva+ size_of_headers = 0x200+ text_raw_size = align(len(text), FILE_ALIGN)+ rdata_raw_size = align(len(rdata), FILE_ALIGN)+ text_file = size_of_headers+ rdata_file = text_file + text_raw_size+ size_of_image = align(rdata_rva + align(len(rdata), SECT_ALIGN), SECT_ALIGN)++ dos = bytearray(0x80)+ dos[0:2] = b"MZ"+ struct.pack_into("<I", dos, 0x3C, 0x80)++ coff = struct.pack("<HHIIIHH", 0x8664, 2, 0, 0, 0, 0xF0, 0x22)+ opt = bytearray(0xF0)+ struct.pack_into("<H", opt, 0, 0x20B)+ opt[2] = 14+ struct.pack_into("<I", opt, 16, entry_rva)+ struct.pack_into("<Q", opt, 24, IMAGE_BASE)+ struct.pack_into("<I", opt, 32, SECT_ALIGN)+ struct.pack_into("<I", opt, 36, FILE_ALIGN)+ struct.pack_into("<H", opt, 40, 6)+ struct.pack_into("<I", opt, 56, size_of_image)+ struct.pack_into("<I", opt, 60, size_of_headers)+ struct.pack_into("<H", opt, 68, 3)+ struct.pack_into("<H", opt, 70, 0x160)+ struct.pack_into("<Q", opt, 72, 0x100000)+ struct.pack_into("<Q", opt, 80, 0x1000)+ struct.pack_into("<Q", opt, 88, 0x100000)+ struct.pack_into("<Q", opt, 96, 0x1000)+ struct.pack_into("<I", opt, 108, 0x10)++ def sec(name, vsize, va, raw_size, raw_ptr, chars):+ return name[:8].ljust(8, b"\0") + struct.pack(+ "<IIIIIIHHI", vsize, va, raw_size, raw_ptr, 0, 0, 0, 0, chars+ )++ sh = sec(b".text", SECT_ALIGN, text_rva, text_raw_size, text_file, 0x60000020)+ sh += sec(b".rdata", SECT_ALIGN, rdata_rva, rdata_raw_size, rdata_file, 0x40000040)++ out = bytearray()+ out += dos + b"PE\0\0" + coff + opt + sh+ out += b"\0" * (size_of_headers - len(out))+ out += bytes(text).ljust(text_raw_size, b"\0")+ out += bytes(rdata).ljust(rdata_raw_size, b"\0")++ meta = {+ "image_base": hex(IMAGE_BASE),+ "entry": hex(IMAGE_BASE + entry_rva),+ "func_stack": hex(text_va + 0x30),+ "func_nr": hex(text_va + 0x50),+ "func_a": hex(text_va + 0x70),+ "func_b": hex(text_va + 0x90),+ "aif_orphan": hex(text_va + 0x18),+ "png_va": hex(png_va),+ "addr_table": hex(at_va),+ "rsrc_va": hex(rsrc_va),+ "pdb_va": hex(pdb_va),+ "api_exit": hex(api_vas[0]),+ "api_printf": hex(api_vas[1]),+ "api_cookie": hex(api_vas[2]),+ "mangled": hex(api_vas[3]),+ }+ (FIX / "analysis_lab.meta.txt").write_text(+ "\n".join(f"{k}={v}" for k, v in meta.items()) + "\n", encoding="utf-8"+ )+ return bytes(out)+++def main():+ pe = build()+ path = FIX / "analysis_lab.pe"+ path.write_bytes(pe)+ print(f"wrote {path} ({len(pe)} bytes)")+ print((FIX / "analysis_lab.meta.txt").read_text())+++if __name__ == "__main__":+ main()diff --git a/scripts/gen_fixtures.py b/scripts/gen_fixtures.pynew file mode 100644index 0000000..ac1bc94--- /dev/null+++ b/scripts/gen_fixtures.py@@ -0,0 +1,303 @@+#!/usr/bin/env python3+"""Generate tiny PE32+ / ELF64 fixtures with known code and MSVC-style RTTI."""+from __future__ import annotations+import struct+from pathlib import Path++ROOT = Path(__file__).resolve().parents[1]+FIX = ROOT / "fixtures"+FIX.mkdir(exist_ok=True)++# x86-64 prologue used as ground truth:+# 55 push rbp+# 48 89 e5 mov rbp, rsp+# 31 c0 xor eax, eax+# 5d pop rbp+# c3 ret+CODE = bytes([0x55, 0x48, 0x89, 0xE5, 0x31, 0xC0, 0x5D, 0xC3])+++def align(n: int, a: int) -> int:+ return (n + a - 1) & ~(a - 1)+++def build_pe_with_rtti() -> bytes:+ """Minimal PE32+ with .text + .rdata containing MSVC RTTI for class Widget."""+ image_base = 0x140000000+ file_align = 0x200+ sect_align = 0x1000++ # Section layout (RVAs)+ text_rva = 0x1000+ rdata_rva = 0x2000+ entry_rva = text_rva++ # --- build .rdata content with RTTI ---+ # Layout in .rdata:+ # 0x00: TypeDescriptor for Widget+ # +0: vfptr (8) = 0 (placeholder)+ # +8: spare (8) = 0+ # +16: name ".?AVWidget@@\0"+ # then pad to 8+ # COL at known offset+ # signature=1, offset=0, cdOffset=0, pTypeDescriptor=RVA, pClassDescriptor=RVA, pSelf=COL_RVA+ # ClassHierarchyDescriptor minimal+ # vtable: [COL_ptr][fn0]++ name = b".?AVWidget@@\0"+ # We'll compute RVAs as we assemble a bytearray for rdata+ rdata = bytearray()++ def rva_here() -> int:+ return rdata_rva + len(rdata)++ # TypeDescriptor+ td_rva = rva_here()+ rdata += struct.pack("<QQ", 0, 0) # vfptr, spare+ rdata += name+ while len(rdata) % 8:+ rdata += b"\0"++ # ClassHierarchyDescriptor: signature, attributes, numBaseClasses, pBaseClassArray+ chd_rva = rva_here()+ # pBaseClassArray filled later+ chd_placeholder = len(rdata)+ rdata += struct.pack("<IIII", 0, 0, 1, 0) # last is pBaseClassArray RVA++ # BaseClassDescriptor: pTypeDescriptor, numContained, mdisp, pdisp, vdisp, attributes, pClassDescriptor+ bcd_rva = rva_here()+ rdata += struct.pack("<IIIIIII", td_rva, 0, 0, -1 & 0xFFFFFFFF, 0, 0, chd_rva)++ # Base class array: one pointer (RVA) to BCD+ bca_rva = rva_here()+ rdata += struct.pack("<I", bcd_rva)+ while len(rdata) % 8:+ rdata += b"\0"++ # fix CHD pBaseClassArray+ struct.pack_into("<I", rdata, chd_placeholder + 12, bca_rva)++ # Complete Object Locator+ col_rva = rva_here()+ rdata += struct.pack(+ "<IIIIII",+ 1, # signature x64+ 0, # offset+ 0, # cdOffset+ td_rva,+ chd_rva,+ col_rva, # pSelf+ )+ while len(rdata) % 8:+ rdata += b"\0"++ # meta pointer slot then vtable[0] = entry (as fake virtfn)+ # MSVC: object -> vtable; vtable[-1] = COL*+ col_va = image_base + col_rva+ vtable_meta_rva = rva_here()+ rdata += struct.pack("<Q", col_va) # COL pointer (vtable[-1])+ vtable_rva = rva_here()+ rdata += struct.pack("<Q", image_base + entry_rva) # vtable[0]++ # also embed a pure Itanium-style name for second class recovery path+ itanium = b"_ZTS6Gadget\0"+ rdata += itanium+ while len(rdata) % 16:+ rdata += b"\0"++ text_raw = bytearray(CODE)+ while len(text_raw) < 0x40:+ text_raw += b"\xCC"+ rdata_raw = bytes(rdata)++ # headers+ dos = bytearray(0x80)+ dos[0:2] = b"MZ"+ struct.pack_into("<I", dos, 0x3C, 0x80)++ pe_offset = 0x80+ # COFF+ coff = struct.pack(+ "<HHIIIHH",+ 0x8664, # Machine+ 2, # NumberOfSections+ 0, # TimeDateStamp+ 0, # PointerToSymbolTable+ 0, # NumberOfSymbols+ 0xF0, # SizeOfOptionalHeader PE32++ 0x22, # Characteristics EXECUTABLE | LARGE_ADDRESS_AWARE+ )++ # Optional header PE32++ size_of_headers = align(pe_offset + 4 + 20 + 0xF0 + 2 * 40, file_align)+ text_file = size_of_headers+ rdata_file = text_file + align(len(text_raw), file_align)+ size_of_image = align(rdata_rva + align(len(rdata_raw), sect_align), sect_align)++ opt = bytearray(0xF0)+ struct.pack_into("<H", opt, 0, 0x20B) # magic+ opt[2] = 14 # major linker+ struct.pack_into("<I", opt, 16, entry_rva) # AddressOfEntryPoint+ struct.pack_into("<Q", opt, 24, image_base)+ struct.pack_into("<I", opt, 32, sect_align)+ struct.pack_into("<I", opt, 36, file_align)+ struct.pack_into("<H", opt, 40, 6) # major OS+ struct.pack_into("<H", opt, 48, 6) # major subsystem ver? actually MajorImageVersion at 44+ struct.pack_into("<I", opt, 56, size_of_image)+ struct.pack_into("<I", opt, 60, size_of_headers)+ struct.pack_into("<H", opt, 68, 3) # subsystem console+ struct.pack_into("<H", opt, 70, 0x160) # dll characteristics+ struct.pack_into("<Q", opt, 72, 0x100000) # stack reserve+ struct.pack_into("<Q", opt, 80, 0x1000)+ struct.pack_into("<Q", opt, 88, 0x100000)+ struct.pack_into("<Q", opt, 96, 0x1000)+ struct.pack_into("<I", opt, 108, 0x10) # number of RVA/sizes+ # data directories leave zero++ # Section headers+ def sec_hdr(name: bytes, vsize, va, raw_size, raw_ptr, chars) -> bytes:+ nb = name[:8].ljust(8, b"\0")+ return nb + struct.pack("<IIIIIIHHI", vsize, va, raw_size, raw_ptr, 0, 0, 0, 0, chars)++ text_chars = 0x60000020 # CODE | EXECUTE | READ+ rdata_chars = 0x40000040 # INIT_DATA | READ+ text_raw_size = align(len(text_raw), file_align)+ rdata_raw_size = align(len(rdata_raw), file_align)+ sh_text = sec_hdr(b".text", align(len(text_raw), sect_align), text_rva, text_raw_size, text_file, text_chars)+ sh_rdata = sec_hdr(b".rdata", align(len(rdata_raw), sect_align), rdata_rva, rdata_raw_size, rdata_file, rdata_chars)++ out = bytearray()+ out += dos+ out += b"PE\0\0"+ out += coff+ out += opt+ out += sh_text+ out += sh_rdata+ assert len(out) <= size_of_headers+ out += b"\0" * (size_of_headers - len(out))+ out += text_raw.ljust(text_raw_size, b"\0")+ out += rdata_raw.ljust(rdata_raw_size, b"\0")++ # write a sidecar of expected addresses for tests+ meta = {+ "image_base": hex(image_base),+ "entry": hex(image_base + entry_rva),+ "text_va": hex(image_base + text_rva),+ "rdata_va": hex(image_base + rdata_rva),+ "td_va": hex(image_base + td_rva),+ "col_va": hex(image_base + col_rva),+ "vtable_va": hex(image_base + vtable_rva),+ "class": "Widget",+ "code_hex": CODE.hex(),+ }+ (FIX / "tiny_x64_pe.meta.txt").write_text(+ "\n".join(f"{k}={v}" for k, v in meta.items()) + "\n", encoding="utf-8"+ )+ return bytes(out)+++def build_elf() -> bytes:+ """Minimal ELF64 ET_EXEC with one PT_LOAD + .text-like content at 0x401000."""+ entry = 0x401000+ # We'll use section headers for named .text+ # Simple approach: ELF header + program header + section headers + data++ # Layout in file:+ # 0x00: ELF header (64)+ # 0x40: program header (56)+ # 0x78: section headers — null, .text, .shstrtab+ # then data++ ehdr_size = 64+ phdr_size = 56+ shdr_size = 64+ phoff = 64+ # put section data after headers+ shnum = 3+ shstrtab = b"\0.text\0.shstrtab\0"+ # file layout after ehdr+phdr:+ text_off = 0x200+ text = CODE + b"\xCC" * 8+ shstr_off = text_off + 0x100+ shoff = shstr_off + align(len(shstrtab), 16)++ # section 0 NULL+ # section 1 .text name at 1+ # section 2 .shstrtab name at 7++ def shdr(name_off, typ, flags, addr, offset, size, link=0, info=0, addralign=16, entsize=0):+ return struct.pack(+ "<IIQQQQIIQQ",+ name_off,+ typ,+ flags,+ addr,+ offset,+ size,+ link,+ info,+ addralign,+ entsize,+ )++ sh_null = shdr(0, 0, 0, 0, 0, 0)+ sh_text = shdr(1, 1, 6, entry, text_off, len(text), addralign=16) # PROGBITS, ALLOC|EXEC+ sh_shstr = shdr(7, 3, 0, 0, shstr_off, len(shstrtab)) # STRTAB++ # program header PT_LOAD covering text+ phdr = struct.pack(+ "<IIQQQQQQ",+ 1, # PT_LOAD+ 5, # PF_R|PF_X+ text_off,+ entry,+ entry,+ len(text),+ len(text),+ 0x1000,+ )++ ehdr = bytearray(64)+ ehdr[0:4] = b"\x7fELF"+ ehdr[4] = 2 # ELFCLASS64+ ehdr[5] = 1 # little+ ehdr[6] = 1+ struct.pack_into("<H", ehdr, 16, 2) # ET_EXEC+ struct.pack_into("<H", ehdr, 18, 0x3E) # EM_X86_64+ struct.pack_into("<I", ehdr, 20, 1)+ struct.pack_into("<Q", ehdr, 24, entry)+ struct.pack_into("<Q", ehdr, 32, phoff)+ struct.pack_into("<Q", ehdr, 40, shoff)+ struct.pack_into("<H", ehdr, 52, ehdr_size)+ struct.pack_into("<H", ehdr, 54, phdr_size)+ struct.pack_into("<H", ehdr, 56, 1) # phnum+ struct.pack_into("<H", ehdr, 58, shdr_size)+ struct.pack_into("<H", ehdr, 60, shnum)+ struct.pack_into("<H", ehdr, 62, 2) # shstrndx++ out = bytearray(shoff + shnum * shdr_size)+ out[0:64] = ehdr+ out[phoff : phoff + phdr_size] = phdr+ out[text_off : text_off + len(text)] = text+ out[shstr_off : shstr_off + len(shstrtab)] = shstrtab+ shblob = sh_null + sh_text + sh_shstr+ out[shoff : shoff + len(shblob)] = shblob++ (FIX / "tiny_x64_elf.meta.txt").write_text(+ f"entry={hex(entry)}\ncode_hex={CODE.hex()}\n", encoding="utf-8"+ )+ return bytes(out)+++def main():+ pe = build_pe_with_rtti()+ (FIX / "tiny_x64.pe").write_bytes(pe)+ elf = build_elf()+ (FIX / "tiny_x64.elf").write_bytes(elf)+ print(f"wrote {FIX / 'tiny_x64.pe'} ({len(pe)} bytes)")+ print(f"wrote {FIX / 'tiny_x64.elf'} ({len(elf)} bytes)")+ print((FIX / "tiny_x64_pe.meta.txt").read_text())+++if __name__ == "__main__":+ main()diff --git a/scripts/verify_rtti_saved.py b/scripts/verify_rtti_saved.pynew file mode 100644index 0000000..4e0ebec--- /dev/null+++ b/scripts/verify_rtti_saved.py@@ -0,0 +1,118 @@+#!/usr/bin/env python3+"""Prove saved RTTI hits map to real bytes in the PE (not invented names)."""+import json+import struct+import sys+from collections import Counter+++def pe_sections(blob: bytes):+ if blob[:2] != b"MZ":+ raise SystemExit("not pe")+ e_lfanew = struct.unpack_from("<I", blob, 0x3C)[0]+ if blob[e_lfanew : e_lfanew + 4] != b"PE\0\0":+ raise SystemExit("bad pe")+ coff = e_lfanew + 4+ num_sec = struct.unpack_from("<H", blob, coff + 2)[0]+ size_opt = struct.unpack_from("<H", blob, coff + 16)[0]+ opt = coff + 20+ magic = struct.unpack_from("<H", blob, opt)[0]+ if magic == 0x20B:+ image_base = struct.unpack_from("<Q", blob, opt + 24)[0]+ else:+ image_base = struct.unpack_from("<I", blob, opt + 28)[0]+ sec_off = opt + size_opt+ secs = []+ for i in range(num_sec):+ o = sec_off + i * 40+ name = blob[o : o + 8].split(b"\0")[0].decode("ascii", "replace")+ vsz, va, rsz, raw = struct.unpack_from("<IIII", blob, o + 8)+ secs.append((name, va, vsz, raw, rsz))+ return image_base, secs+++def main():+ analysis = sys.argv[1] if len(sys.argv) > 1 else r"F:\ghidrust\fh6\results\forzahorizon6_exe\analysis.json"+ exe = sys.argv[2] if len(sys.argv) > 2 else r"F:\ghidrust\fh6\imports\forzahorizon6_exe_forzahorizon6.exe"++ print("loading", analysis)+ d = json.load(open(analysis, encoding="utf-8"))+ rtti = d.get("rtti") or {}+ classes = rtti.get("classes") or []+ print("program", d.get("program_name"), d.get("format"), hex(d.get("image_base") or 0))+ print("saved_analyzers", d.get("saved_analyzers"))+ print("class_count", len(classes))+ print("notes", rtti.get("notes"))+ print("kinds", Counter(c.get("kind") for c in classes).most_common(10))++ named = [+ c+ for c in classes+ if c.get("name") and "lambda" not in c["name"].lower() and len(c["name"]) > 4+ ]+ print("non_lambda_count", len(named))+ for c in named[:8]:+ print(+ f" {c['name']!r} type_info_va={c.get('type_info_va')} kind={c.get('kind')}"+ )++ data = open(exe, "rb").read()+ print("exe_bytes", len(data))+ ib, secs = pe_sections(data)+ print("image_base", hex(ib), "nsecs", len(secs))++ def va_to_off(va: int):+ rva = va - ib+ for name, sva, vsz, raw, rsz in secs:+ if sva <= rva < sva + max(vsz, rsz):+ return raw + (rva - sva), name+ return None, None++ ok = bad = 0+ samples = []+ for c in named[:80]:+ va = c.get("type_info_va")+ if not va:+ continue+ off, sec = va_to_off(va)+ if off is None or off < 0 or off >= len(data):+ bad += 1+ if len(samples) < 10:+ samples.append(("MISS", c["name"], hex(va), None, None))+ continue+ chunk = data[off : off + 96]+ text = chunk.split(b"\0")[0][:70]+ try:+ t = text.decode("ascii")+ except Exception:+ t = repr(text)+ has_m = chunk[:8].startswith(b".?A") or b".?A" in chunk[:16]+ if has_m or len(text) >= 4:+ ok += 1+ tag = "OK" if has_m else "NEAR"+ else:+ bad += 1+ tag = "EMPTY"+ if len(samples) < 10:+ samples.append((tag, c["name"], hex(va), sec, t))++ print("spot_ok", ok, "spot_bad", bad)+ for row in samples:+ print(row)++ n_av = data.count(b".?AV")+ n_au = data.count(b".?AU")+ print("raw_file_.?AV_count", n_av)+ print("raw_file_.?AU_count", n_au)+ print(+ "recovered_msvc",+ sum(1 for c in classes if c.get("kind") == "msvc_type_descriptor"),+ )+ # Pass if majority of spot checks map+ if ok < 1 or bad > ok:+ raise SystemExit(2)+ print("VERDICT: RTTI data is grounded in real PE bytes")+++if __name__ == "__main__":+ main()diff --git a/skill/README.md b/skill/README.mdnew file mode 100644index 0000000..70b3add--- /dev/null+++ b/skill/README.md@@ -0,0 +1,56 @@+# Ghidrust — agent skill++## What Ghidrust is++Ghidrust is a **Rust** reverse-engineering toolkit inspired by [Ghidra](https://github.com/NationalSecurityAgency/ghidra) — not a fork. It loads PE/ELF, disassembles x86-64, runs Auto Analysis, decompiles to pseudo-C, and supports durable projects via **CLI**, **MCP** (stdio), and an **egui** CodeBrowser-style GUI.++**Aims:** a freestanding, auditable RE core; CPU-correct analysis first; optional experimental GPU bulk scan + VRAM-resident decompile; agent-friendly headless use.++**Experimental GPU:** wgpu/Vulkan kernels for bulk RE and multipass decompile (`.gdecomp`). Correctness vs CPU is the bar; wall-clock speedups are not guaranteed on small binaries. See [docs/GPU_DECOMPILER_RESEARCH.md](../docs/GPU_DECOMPILER_RESEARCH.md).++## Build and smoke-test++From the repo root (Rust stable):++```bash+cargo build --workspace --release++./target/release/ghidrust help+./target/release/ghidrust load fixtures/tiny_x64.pe+./target/release/ghidrust disasm fixtures/tiny_x64.pe --count 16+./target/release/ghidrust decompile fixtures/tiny_x64.pe+./target/release/ghidrust gpu-decompile fixtures/tiny_x64.pe --out entry.gdecomp --json++cargo run -p ghidrust-gui --release+```++Windows: `.\target\release\ghidrust.exe` / `.\target\release\ghidrust-gui.exe`.++MCP for agents:++```bash+./target/release/ghidrust mcp+```++## Skill install++Canonical skill file: [`SKILL.md`](SKILL.md). Point any skill-aware agent at it, or copy it into that tool’s skills directory:++| Agent / tool | Typical location |+|--------------|------------------|+| Cursor | project or user skills / rules (see Cursor docs) |+| Grok | `~/.grok/skills/ghidrust/` or `<repo>/.grok/skills/ghidrust/` |+| MCP clients | register `ghidrust mcp` as a stdio server |++```bash+# example: copy into a local skills dir+mkdir -p .skills/ghidrust+cp skill/SKILL.md .skills/ghidrust/SKILL.md+```++```powershell+New-Item -ItemType Directory -Force .skills\ghidrust | Out-Null+Copy-Item skill\SKILL.md .skills\ghidrust\SKILL.md -Force+```++Slash command where supported: `/ghidrust`. Keep installed copies in sync with this `SKILL.md` when editing.diff --git a/skill/SKILL.md b/skill/SKILL.mdnew file mode 100644index 0000000..569fb0a--- /dev/null+++ b/skill/SKILL.md@@ -0,0 +1,240 @@+---+name: ghidrust+description: >+ Use Ghidrust (Rust RE toolkit: PE/ELF load, x86-64 disasm, Auto Analysis, projects,+ CLI/MCP, egui GUI, GPU analyzer kernels + multipass decompile) to reverse-engineer+ binaries without Ghidra. Exhaustive feature catalog with when-to-use guidance.+ Triggers: /ghidrust, reverse engineer, RE a PE/ELF, disassemble, RTTI, auto analysis,+ analyze binary, Ghidrust project, MCP ghidrust, strings/functions, GPU decompile,+ analyzer-bench, rtti-gpu-bench, bulk-bench.+metadata:+ short-description: "Ghidrust RE — CLI, MCP, analyzers, GPU, projects"+---++# Ghidrust — agent skill++Hand-rolled **Rust** reverse-engineering core (Ghidra-inspired labels). Prefer **CLI or MCP** for agents; GUI is for humans. **Never invent analysis** — if a fixture has no evidence, outputs are empty/honest.++## Paths & binaries++| Item | Path / command |+|------|----------------|+| Workspace root | repo root (`Cargo.toml` with `ghidrust-core`, `ghidrust-cli`, `ghidrust-gui`, `ghidrust-decomp`) |+| CLI | `cargo run -p ghidrust-cli --release -- <cmd>` or `target/release/ghidrust.exe` |+| GUI | `cargo run -p ghidrust-gui --release` |+| Fixtures | `fixtures/tiny_x64.pe`, `fixtures/analysis_lab.pe`, `fixtures/tiny_x64.elf` |+| Docs | `README.md`, `docs/GPU_ANALYZER_MATRIX.md`, `docs/PARALLEL_RE_RESEARCH.md` (local parity notes under `dev/`) |+| Core API | `load_path`, `run_analyzers` / `run_analyzers_opts`, `Project`, `gpu_analyzers`, `bulk_scan` |++CLI always builds with `gpu` feature on deps. On Windows PowerShell: `.\target\release\ghidrust.exe …`.++```bash+cargo build -p ghidrust-cli --release+cargo build -p ghidrust-gui --release+```++---++## Decision tree++```+Need durable workspace?+ YES → project create → import → analyze [--analyzer …] [--gpu] → export+ NO → load | disasm | rtti | analyze [--analyzer …] [--gpu]++Need machine-readable?+ → --json OR ghidrust mcp++Need GPU for selected analyzers (not just bench)?+ → analyze … --gpu OR GUI checkbox OR MCP analyze gpu:true+ → bulk mode for ASCII Strings + SIMT seed enrich per selected name++Need GPU decompile dump?+ → gpu-decompile <path>++Need RTTI CPU vs GPU timings (PCIe split)?+ → rtti-gpu-bench <path>++Need full matrix bench?+ → analyzer-bench / analyzer-bench-matrix++Full Hex-Rays C decompiler?+ → NOT AVAILABLE. Use gpu-decompile multipass pseudo-C + listing.+```++---++## Select analyzers + GPU (CLI / GUI / MCP)++### CLI — one-shot++```bash+# Comma list+ghidrust analyze PATH --analyzers "ASCII Strings,Function Start Search" --json++# Individual flags (repeatable)+ghidrust analyze PATH --analyzer "ASCII Strings" --analyzer "Stack" --json++# Defaults (catalog default_enabled) + GPU enrich+ghidrust analyze PATH --gpu --json++# Subset + GPU+ghidrust analyze PATH --analyzer "WindowsPE x86 PE RTTI Analyzer" --gpu --json+```++### CLI — project++```bash+ghidrust project analyze PROJ_DIR --file ID \+ --analyzer "Function Start Search" \+ --analyzer "ASCII Strings" \+ --gpu+# or: --analyzers "a,b,c" --gpu+```++### What `--gpu` does++1. Sets bulk scan mode to **GPU-or-fallback** (ASCII Strings uses wgpu when available).+2. After each CPU analyzer run, runs that analyzer’s **GPU strategy kernel** (`rtti_scan`, `printable_run`, …) and **host-merges** seeds into the program.+3. Annotates result messages with `gpu_enrich hits_merged=… backend=…`.+4. Restores previous bulk mode after the run.++**Not** the same as `gpu-decompile` (VRAM multipass decompile of entry).++### GUI++**Analysis options** dialog:++- Checkbox per analyzer (Defaults / All / None).+- **GPU (strings bulk + per-analyzer seed kernels)** checkbox.+- **Run Analysis** runs only checked analyzers; GPU flag applies as above.++### MCP (`ghidrust mcp`)++| Tool | Args |+|------|------|+| `list_analyzers` | — |+| `list_gpu_strategies` | — (name → strategy matrix) |+| `analyze` | `path`, optional `analyzers[]`, optional **`gpu`: bool** |+| `gpu_decompile` | `path`, optional `out` |+| `rtti_gpu_bench` | `path` |+| `load` / `disassemble` / `rtti` | as before |++---++## CLI features (exhaustive)++Add `--json` for structured stdout.++| Feature | Command |+|---------|---------|+| Help | `ghidrust help` |+| Load | `ghidrust load <path>` |+| Disasm | `ghidrust disasm <path> [--addr HEX] [--count N]` |+| RTTI only | `ghidrust rtti <path>` |+| List analyzers | `ghidrust analyzers` |+| **Analyze** | `ghidrust analyze <path> [--analyzers a,b \| --analyzer NAME …] [--gpu]` |+| Bulk bench | `ghidrust bulk-bench <path>` |+| Decompile (CPU multipass-style) | `ghidrust decompile <path>` |+| **GPU decompile** | `ghidrust gpu-decompile <path> [--out F] [--metrics F]` |+| RE bench | `ghidrust re-bench <path>` |+| Analyzer CPU/GPU matrix bench | `ghidrust analyzer-bench <path> [--large] [--out F]` |+| Strategy matrix | `ghidrust analyzer-bench-matrix` |+| **RTTI GPU bench** | `ghidrust rtti-gpu-bench <path> [--out F]` |+| Project | `create\|open\|import\|list\|analyze\|export` (analyze supports `--analyzer` / `--gpu`) |+| MCP | `ghidrust mcp` |++### Recipes++```bash+# Quick triage+ghidrust load PATH --json+ghidrust analyze PATH --analyzer "ASCII Strings" --analyzer "Function Start Search" --json++# GPU RTTI seed path on one analyzer+ghidrust analyze PATH --analyzer "WindowsPE x86 PE RTTI Analyzer" --gpu --json++# Project case+ghidrust project create PROJ --name Case+ghidrust project import PROJ PATH+ghidrust project analyze PROJ --analyzers "Function Start Search,ASCII Strings,WindowsPE x86 PE RTTI Analyzer" --gpu++# Performance+ghidrust bulk-bench PATH --json+ghidrust analyzer-bench PATH --large --out metrics.txt+ghidrust rtti-gpu-bench PATH --out rtti_metrics.txt --json+ghidrust gpu-decompile PATH --metrics gdec.json+```++---++## GPU strategy matrix (all 20 + decompile)++See `docs/GPU_ANALYZER_MATRIX.md`. Every Auto Analysis name has a dedicated strategy class (not one printable kernel rebranded). Examples:++| Analyzer | Strategy |+|----------|----------|+| ASCII Strings | `printable_run` |+| Function Start Search | `prologue_seed` |+| WindowsPE x86 PE RTTI Analyzer | `rtti_scan` |+| Embedded Media | `magic_media` |+| Function ID | `hash_window` |+| … | `ghidrust analyzer-bench-matrix` |++Timing model: **pcie_upload / device_ms / pcie_download** split. On large binaries, on-device is often ≫ CPU seed; wall may still be setup+PCIe.++---++## Library / core++| API | When |+|-----|------|+| `run_analyzers(prog, names)` | CPU Auto Analysis (empty names → defaults) |+| **`run_analyzers_opts(prog, names, use_gpu)`** | Same + GPU bulk/enrich |+| `gpu_enrich_analyzers` | Seed merge only |+| `Project::analyze_file` / **`analyze_file_opts(..., use_gpu)`** | Project analyze |+| `set_preferred_bulk_mode` | Low-level bulk backend |+| `bench_analyzer` / `bench_all_analyzers` | Matrix harness |+| Feature `gpu` | wgpu; CLI enables it |++---++## Auto Analysis — all 20 names++Exact strings (use `ghidrust analyzers --json`):++ASCII Strings · Aggressive Instruction Finder · Call Convention ID · Call-Fixup Installer · Create Address Tables · Decompiler Parameter ID · Decompiler Switch Analysis · Demangler Microsoft · Embedded Media · Function ID · Function Start Search · Non-Returning Functions - Discovered · PDB MSDIA · PDB Universal · Shared Return Calls · Stack · Variadic Function Signature Override · WindowsPE x86 PE RTTI Analyzer · Windows x86 Propagate External Parameters · WindowsResourceReference++**Defaults** (empty selection): ASCII Strings, RTTI, Function Start Search, Create Address Tables, Embedded Media, Demangler Microsoft.++---++## GUI features++| Feature | Notes |+|---------|--------|+| Per-analyzer checkboxes | Individual enable |+| **GPU checkbox** | Bulk strings + per-analyzer GPU seed kernels |+| Progress | One analyzer per frame |+| Project tree | Open / Analyze / Delete |+| Decompiler pane | Placeholder / GPU dump via CLI preferred |++---++## Agent rules++**Do:** exact analyzer names; `--analyzer` or `--analyzers`; `--gpu` when GPU enrich wanted; `--json` for scripts; `analyzer-bench-matrix` for strategy list.++**Don't:** invent decompiled C; claim Ghidra MCP is Ghidrust; skip empty-result honesty; conflate PCIe with on-device time.++---++## Quick verification++```bash+cargo test -p ghidrust-core --features gpu+ghidrust analyzers --json+ghidrust analyze fixtures/analysis_lab.pe --analyzer "ASCII Strings" --gpu --json+ghidrust gpu-decompile fixtures/analysis_lab.pe --json+ghidrust analyzer-bench-matrix+```