Struct Address 

pub struct Address(/* private fields */);

A validated address, any real value other than the invalid sentinel.

The invalid-address sentinel maps to None, and a niche keeps Option<Address> the same size as a bare u64.

Ordering is by the real address: the niche stores !raw, so a derived Ord would compare inverted bits and reverse the order. Callers expect an Address to sort like the raw address it wraps (linear walks, chunk bounds, BTreeMap keys), so Ord/PartialOrd are hand-written over get.

Implementations

impl Address

pub const fn try_new(raw: u64) -> Option<Self>

Wrap a raw address. None only when raw == BADADDR.

pub const fn new_const(raw: u64) -> Self

Const constructor for literals.

Panics

At compile time, if raw == BADADDR.

Examples found in repository

examples/edits.rs (line 109)

fn function_types(idb: &mut Database, ea: Address) -> Result<(), Error> {
    println!("\n== function_mut: prototypes ==");
    println!("  prototype before: {:?}", idb.function(ea).prototype());

    // Acquire by key (a two-phase borrow keeps it a one-liner). `function_mut` is an `Option`: an
    // address in no function yields `None`, never a cursor over nothing.
    if let Some(mut f) = idb.function_mut(ea) {
        f.set_type("int edits_probe(int a, int b)")?;
    }
    println!("  prototype after:  {:?}", idb.function(ea).prototype());

    // The scoped-closure form returns `Option<Result<_>>` (None = no function, then the write's own
    // Result). `.transpose()?` collapses both layers at once, the idiom for that shape.
    idb.with_function_mut(ea, |f| f.set_type("void edits_probe(void)"))
        .transpose()?;
    println!("  prototype now:    {:?}", idb.function(ea).prototype());

    // An address inside no function: the cursor is simply absent.
    let nowhere = Address::new_const(0xffff_ffff_f000);
    println!(
        "  function_mut(unmapped) is_some: {}",
        idb.function_mut(nowhere).is_some()
    );

    // For the entry address, `function_mut(ea).set_type` and `at_mut(ea).set_type` are the same
    // apply today; `FunctionEdit` earns its own weight when signature surgery (return/arg edits)
    // arrives.

    // `clear_type` is the inverse of `set_type`; it removes the prototype and is idempotent.
    idb.at_mut(ea).clear_type()?;
    println!(
        "  prototype after clear: {:?}",
        idb.function(ea).prototype()
    );
    Ok(())
}

pub const fn get(self) -> u64

The raw address.

Examples found in repository

examples/probe_names.rs (line 53)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = std::env::args().skip(1);
    let bin = args
        .next()
        .expect("usage: probe_names <db.i64> [max-names]");
    let max: usize = args.next().and_then(|s| s.parse().ok()).unwrap_or(50_000);

    Ida::run(move |ida| -> Result<(), Error> {
        ida.call(move |idb| -> Result<(), Error> {
            idb.open(&bin).call()?;

            let (mut total, mut weak, mut public, mut mangled) = (0usize, 0usize, 0usize, 0usize);
            let mut demangles = 0usize;
            let mut substitutes = 0usize;
            let mut short_differs = 0usize;
            let mut short_vs_long = 0usize;
            let mut samples: Vec<String> = Vec::new();
            let mut first_weak: Option<usize> = None;
            let mut first_public: Option<usize> = None;

            for Name { address, name } in idb.names().take(max) {
                total += 1;
                let is_weak = idb.is_weak_name(address);
                weak += usize::from(is_weak);
                if is_weak && first_weak.is_none() {
                    first_weak = Some(total - 1);
                }
                if idb.is_public_name(address) && first_public.is_none() {
                    first_public = Some(total - 1);
                }
                public += usize::from(idb.is_public_name(address));
                if name.starts_with("_Z") {
                    mangled += 1;
                }
                if idb.demangle(&name).is_some() {
                    demangles += 1;
                }

                let raw = idb.name_with(address, NameFlags::empty());
                let visible = idb.visible_name(address);
                if raw != visible {
                    substitutes += 1;
                    if samples.len() < 4 {
                        samples.push(format!(
                            "  subst {:#x}\n    raw     {raw:?}\n    visible {visible:?}",
                            address.get()
                        ));
                    }
                }

                // The mutant that survives collapses `short_name` to plain VISIBLE, so this is
                // the exact comparison that has to differ somewhere for a test to catch it.
                let short = idb.short_name(address);
                if short != visible {
                    short_differs += 1;
                }
                if short != idb.long_name(address) {
                    short_vs_long += 1;
                }

                if is_weak && name.starts_with("_Z") && samples.len() < 8 {
                    samples.push(format!(
                        "  weak+mangled {:#x}\n    raw   {name:?}\n    short {short:?}",
                        address.get()
                    ));
                }
            }

            println!("=== {total} names scanned");
            println!("weak            {weak}  (first at index {first_weak:?})");
            println!("public          {public}  (first at index {first_public:?})");
            println!("raw '_Z' prefix {mangled}");
            println!("demangle(name)  {demangles}");
            println!("raw != visible  {substitutes}");
            println!("short != visible {short_differs}   <- kills the short_name mutant");
            println!("short != long    {short_vs_long}");
            println!("=== samples");
            for s in &samples {
                println!("{s}");
            }

            idb.close(false);
            Ok(())
        })??;
        Ok(())
    })??;

    println!("PROBE_NAMES OK");
    Ok(())
}

impl Address

pub const fn distance_to(self, end: Self) -> u64

The non-negative byte span end - self, saturating to 0 when end is below self.

The natural length of a [self, end) range, so a caller reads start.distance_to(end) rather than an unsigned-cast subtraction.

Trait Implementations

impl Add<u64> for Address

fn add(self, bytes: u64) -> Self

Advance by a byte count, saturating into [0, BADADDR) so the result is always a valid Address, never the sentinel.

type Output = Address

The resulting type after applying the + operator.

impl Clone for Address

fn clone(&self) -> Address

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Address

impl Debug for Address

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Address

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Address

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Address

impl From<Address> for u64

fn from(address: Address) -> Self

Converts to this type from the input type.

impl Hash for Address

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for Address

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Ord for Address

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Address

fn eq(&self, other: &Address) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Address

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Address

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Address

impl UpperHex for Address

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.