Struct ValueRegistry 

pub struct ValueRegistry<'str> {
    pub literals: LiteralInterner,
    pub bytes: Interner<BytesId, Bytes>,
    pub poisons: Interner<PoisonId, Poison>,
    pub varnodes: Registry<VarnodeId, Varnode<'str>>,
    /* private fields */
}

Central storage arena for all IR values in a Context.

Each field is a typed arena (Registry) keyed by the corresponding ID type. Values are append-only: once pushed, their ID is stable for the lifetime of the registry and their data is never moved.

Invariants

• push_insn is final. Instructions are immutable after insertion. The owning function’s users map is populated at push time from the instruction’s operands and is not updated if operands are later altered via interior mutation. Use Context::replace_all_uses_with to rewrite operands while keeping users consistent.

• users is managed internally. The reverse use-def map now lives in each FunctionBody (function-scoped; see FunctionBody::users_of). Do not mutate it directly. Read it through FunctionRef::users_of / Context::users, and remove dead instructions via Context::remove_instructions.

Fields

literals: LiteralInterner

Literal (constant) interner. Behind an RwLock (see LiteralInterner) so constants can be minted through a shared &; the dedup cache lives inside it.

bytes: Interner<BytesId, Bytes>

Opaque byte-blob constant interner (constants wider than a u64).

poisons: Interner<PoisonId, Poison>

Poison-value interner (argpromote v2). Each poison is a distinct interned value (never deduped), so two poisons are never congruent.

varnodes: Registry<VarnodeId, Varnode<'str>>

Varnode storage.

Implementations

impl<'str> ValueRegistry<'str>

pub fn get_or_make_typed_literal( &self, value: u64, type_id: TypeId, size: usize, ) -> LiteralId

Returns a canonical LiteralId for the given typed constant.

The value is masked to type_id’s size before lookup. Symbolic literals (created via push_literal) are not included in the intern cache and will not alias with constants produced here.

Call Context::get_const for the common Int(size) case; use this method directly when you need to preserve a non-Int type (e.g. StackAddress) through folding.

pub fn push_literal(&self, literal: Literal) -> LiteralId

Pushes a Literal with arbitrary fields (e.g. with a symbolic ref) without interning. Use get_or_make_typed_literal for plain integer constants.

pub fn add_synthetic_callee( &mut self, caller: FunctionId, callee_addr: u64, ) -> bool

Records a synthetic forward call-graph edge caller → callee_addr (see synthetic_callees). Returns true if the edge was newly added, so callers can drive a fixpoint without spinning.

pub fn synthetic_callees_of( &self, caller: FunctionId, ) -> impl Iterator<Item = u64> + '_

Returns the synthetic callee entry addresses recorded for caller.

pub fn push_varnode(&mut self, varnode: Varnode<'str>) -> VarnodeId

pub fn push_poison(&self, type_id: TypeId) -> PoisonId

Mints a fresh typed poison value. Never deduped: each call yields a distinct PoisonId so GVN keeps every poison in its own congruence class.

Trait Implementations

impl<'str> Clone for ValueRegistry<'str>

fn clone(&self) -> ValueRegistry<'str>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'str> Default for ValueRegistry<'str>

fn default() -> ValueRegistry<'str>

Returns the “default value” for a type.

impl<'de, 'str> Deserialize<'de> for ValueRegistry<'str>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'str> Serialize for ValueRegistry<'str>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.