feat: introduce r3solvr

Author: Mufanc

Cargo.lock

@@ -26,17 +26,16 @@ futures = "0.3"
 glob = "0.3"
 jni = "0.21"
 log = "0.4"
-lzma-rs = "0.3"
 memfd = "0.6"
 nix = { version = "0.31" }
 notify = "9.0.0-rc.1"
-object = "0.38"
 parking_lot = "0.12"
 once_cell = "1.21"
 once_map = "0.4"
 procfs = "0.18"
 prost = "0.14"
 prost-build = "0.14"
+r3solvr = { git = "https://github.com/Mufanc/r3solvr" }
 regex-lite = "0.1"
 scopeguard = "1.2"
 serde = { version = "1.0", features = ["derive"] }

Cargo.toml

@@ -21,16 +21,15 @@ env_logger = { workspace = true }
 futures = { workspace = true }
 jni = { workspace = true }
 log = { workspace = true }
-lzma-rs = { workspace = true }
 memfd = { workspace = true }
 nix = { workspace = true, features = ["feature", "fs", "process", "ptrace", "resource", "signal", "socket", "uio", "user"] }
 notify = { workspace = true }
-object = { workspace = true }
 once_cell = { workspace = true }
 once_map = { workspace = true }
 parking_lot = { workspace = true }
 procfs = { workspace = true }
 prost = { workspace = true }
+r3solvr = { workspace = true }
 regex-lite = { workspace = true }
 scopeguard = { workspace = true }
 serde = { workspace = true }

src/core/Cargo.toml

@@ -1,3 +1,2 @@
 pub mod cpp;
 pub mod library;
-pub mod symbol;

src/core/src/binary.rs

@@ -1,12 +1,12 @@
-use crate::binary::symbol::{CachedSymbolResolver, Symbol};
 use anyhow::Result;
 use once_cell::sync::Lazy;
 use once_map::OnceMap;
+use r3solvr::{CachedResolver, Symbol, SymbolResolver};
 
 static SYSTEM_LIBRARY_RESOLVER: Lazy<SystemLibraryResolver> = Lazy::new(SystemLibraryResolver::new);
 
 pub struct SystemLibraryResolver<'a> {
-    resolvers: OnceMap<String, CachedSymbolResolver<'a>>,
+    resolvers: OnceMap<String, CachedResolver<'a>>,
 }
 
 impl SystemLibraryResolver<'_> {
@@ -16,12 +16,12 @@ impl SystemLibraryResolver<'_> {
         }
     }
 
-    pub fn resolve(&self, name: &str, pattern: &str) -> Result<Symbol> {
-        self.resolvers.map_try_insert(
-            name.into(),
-            |name| CachedSymbolResolver::from_file(format!("/system/lib64/{name}.so")),
-            |_, v| v.resolve(pattern),
-        )?
+    pub fn resolve(&self, library_name: &str, symbol_name: &str) -> Result<Symbol> {
+        Ok(self.resolvers.map_try_insert(
+            library_name.into(),
+            |name| CachedResolver::from_file(format!("/system/lib64/{name}.so")),
+            |_, v| v.lookup_symbol(symbol_name),
+        )??)
     }
 
     pub fn instance() -> &'static Self {

src/core/src/binary/library.rs

@@ -1,10 +1,11 @@
 use crate::binary::cpp::ArgCounter;
-use crate::binary::symbol::{Section, Symbol, SymbolResolver};
 use anyhow::{Context, Result};
 use log::info;
 use once_cell::sync::Lazy;
+use r3solvr::{BasicResolver, Query, Section, Symbol, SymbolResolver};
 use strum::IntoEnumIterator;
 use zynx_bridge_shared::zygote::SpecializeVersion;
+use zynx_misc::ext::ResultExt;
 
 mod embryo;
 pub mod policy;
@@ -24,13 +25,22 @@ pub struct SpecializeCommonConfig {
 
 impl SpecializeCommonConfig {
     fn resolve() -> Result<Self> {
-        let resolver = SymbolResolver::from_file(SC_LIBRARY_PATH)?;
+        let resolver = BasicResolver::from_file(SC_LIBRARY_PATH)?;
 
         let (sym, ver) = SpecializeVersion::iter()
-            .find_map(|ver| resolver.find_symbol(ver.as_ref()).map(|sym| (sym, ver)))
+            .find_map(|ver| {
+                resolver
+                    .lookup_symbol(
+                        Query::new(ver.as_ref())
+                            .with_prefix(true)
+                            .with_debugdata(true),
+                    )
+                    .map(|sym| (sym, ver))
+                    .ok_or_warn()
+            })
             .context("no known SpecializeCommon symbol found in libandroid_runtime.so")?;
 
-        let sec = resolver.find_section(sym.section_index)?;
+        let sec = resolver.lookup_section(sym.section_index)?;
         let args_count = ArgCounter::count_args_for_symbol(&sym.name)?;
 
         Ok(Self {