add a handful of features and some testing

idalib-build/Cargo.toml

@@ -16,3 +16,5 @@ build = "build.rs"
 [dependencies]
 anyhow = "1"
 idalib-sys = { version = "0.7", path = "../idalib-sys" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"

idalib-build/src/lib.rs

@@ -1,7 +1,61 @@
 use std::env;
+use std::fs;
 use std::path::{Path, PathBuf};
 
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+struct IdaConfig {
+    #[serde(rename = "Paths")]
+    paths: Option<IdaConfigPaths>,
+}
+
+#[derive(Deserialize)]
+struct IdaConfigPaths {
+    #[serde(rename = "ida-install-dir")]
+    ida_install_dir: Option<String>,
+}
+
+/// Try to read the IDA installation path from the IDA configuration file
+fn read_ida_config() -> Option<PathBuf> {
+    let config_dir = if let Ok(ida_usr) = env::var("IDAUSR") {
+        PathBuf::from(ida_usr)
+    } else {
+        #[cfg(target_os = "windows")]
+        {
+            PathBuf::from(env::var("APPDATA").ok()?)
+                .join("Hex-Rays")
+                .join("IDA Pro")
+        }
+        #[cfg(any(target_os = "linux", target_os = "macos"))]
+        {
+            PathBuf::from(env::var("HOME").ok()?).join(".idapro")
+        }
+        #[cfg(not(any(target_os = "windows", target_os = "linux", target_os = "macos")))]
+        {
+            return None;
+        }
+    };
+
+    let config_path = config_dir.join("ida-config.json");
+    let contents = fs::read_to_string(&config_path).ok()?;
+    let config: IdaConfig = serde_json::from_str(&contents).ok()?;
+    let path_str = config.paths?.ida_install_dir?;
+    Some(PathBuf::from(path_str))
+}
+
 fn link_path() -> PathBuf {
+    // First try to read from ida-config.json
+    if let Some(mut path) = read_ida_config() {
+        #[cfg(target_os = "macos")]
+        if path.extension().map_or(false, |ext| ext == "app") {
+            path.push("Contents");
+            path.push("MacOS");
+        }
+        return path;
+    }
+
+    // Fall back to platform-specific defaults
     #[cfg(target_os = "macos")]
     return PathBuf::from("/Applications/IDA Professional 9.2.app/Contents/MacOS");
 

idalib-sys/src/bytes_extras.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "bytes.hpp"
+#include "segment.hpp"
 
 #include "cxx.h"
 
@@ -17,3 +18,24 @@ std::size_t idalib_get_bytes(ea_t ea, rust::Vec<rust::u8> &buf) {
     return 0;
   }
 }
+
+bool idalib_is_loaded(ea_t ea) { 
+  return is_loaded(ea); 
+}
+
+bool idalib_is_mapped(ea_t ea) {
+  return getseg(ea) != nullptr;
+}
+
+bool idalib_is_stkvar(flags64_t flags, int operand_index) {
+  if (operand_index == 0) {
+    return is_stkvar0(flags);
+  } else if (operand_index == 1) {
+    return is_stkvar1(flags);
+  }
+  return false;
+}
+
+bool idalib_is_off(flags64_t flags, int operand_index) {
+    return is_off(flags, operand_index);
+}

idalib-sys/src/entry_extras.h

@@ -14,3 +14,14 @@ rust::String idalib_entry_name(uval_t ord) {
     return rust::String();
   }
 }
+
+rust::String idalib_entry_forwarder(uval_t ord) {
+  auto forwarder = qstring();
+
+  ssize_t result = get_entry_forwarder(&forwarder, ord);
+  if (result > 0 && !forwarder.empty()) {
+    return rust::String(forwarder.c_str());
+  } else {
+    return rust::String();
+  }
+}

idalib-sys/src/inf_extras.h

@@ -393,3 +393,5 @@ rust::String idalib_inf_get_strlit_pref() {
 bool idalib_inf_get_cc(compiler_info_t *out)  { return inf_get_cc(out); }
 
 bool idalib_inf_get_privrange(range_t *out)  { return inf_get_privrange(out); }
+
+ea_t idalib_inf_get_imagebase()  { return get_imagebase(); }

idalib-sys/src/insn_extras.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "intel.hpp"
+#include "ua.hpp"
+#include "idp.hpp"
+
+#include "cxx.h"
+
+// SIB Decoding Functions (from intel.hpp)
+// These extract individual fields from the SIB byte
+
+int idalib_sib_base(const insn_t *insn, const op_t *op) {
+  return sib_base(*insn, *op);
+}
+
+int idalib_sib_index(const insn_t *insn, const op_t *op) {
+  return sib_index(*insn, *op);
+}
+
+int idalib_sib_scale(const op_t *op) {
+  return sib_scale(*op);
+}
+
+// High-level Helper Functions (also from intel.hpp)
+// These handle both SIB and non-SIB cases automatically
+
+int idalib_x86_base_reg(const insn_t *insn, const op_t *op) {
+  return x86_base_reg(*insn, *op);
+}
+
+int idalib_x86_index_reg(const insn_t *insn, const op_t *op) {
+  return x86_index_reg(*insn, *op);
+}
+
+int idalib_x86_scale(const op_t *op) {
+  return x86_scale(*op);
+}
+
+bool idalib_has_displ(const op_t *op) {
+  return has_displ(*op);
+}
+
+// Check for SIB byte presence
+bool idalib_has_sib(const op_t *op) {
+  return op->hasSIB;
+}
+
+// Get the raw SIB byte value
+uint8_t idalib_get_sib_byte(const op_t *op) {
+  return op->sib;
+}
+
+// Get instruction features from processor using itype
+uint32_t idalib_get_canon_feature(uint16_t itype) {
+  processor_t *ph = (processor_t*)get_ph();
+  return ph->get_canon_feature(itype);
+}
+
+// Check if instruction modifies operand (wrapper for has_cf_chg)
+bool idalib_has_cf_chg(uint32_t feature, uint32_t opnum) {
+  return has_cf_chg(feature, opnum);
+}
+
+// Check if instruction uses operand (wrapper for has_cf_use)
+bool idalib_has_cf_use(uint32_t feature, uint32_t opnum) {
+  return has_cf_use(feature, opnum);
+}