Struct CapabilityVtable 

pub struct CapabilityVtable { /* private fields */ }

The LLVM backend’s capability grant surface.

On the cranelift side the equivalent CapabilityVtable is a heap array of extern "C" host-fn pointers whose non-null-ness at slots[cap_bit] is what lets an Op::CheckCap { cap_bit } pass. On the LLVM side the granted set is carried as an i64 bitmask the buffer-protocol entry receives as its trailing caps param, so this type is a thin builder around that mask plus the dynamic host-fn registry the import_idx-keyed Op::CallNative dispatch resolves against.

Two halves (same split as cranelift)

• caps_mask — the granted-capability bitmask. A set bit at index cap_bit is what lets an Op::CheckCap { cap_bit } pass (the LLVM analogue of cranelift’s “non-null slot at cap_bit”). Built via Self::grant / Self::register_via_gate; consumed by the host as the caps word it hands to the linked entry (or to LlvmAotEvaluator::with_caps).
• host_fns — the import_idx-keyed dynamic callable registry (HostFnRegistry). A source-lowered Op::CallNative { cap_bit: NO_CAPABILITY_BIT } resolves through it via relon_llvm_call_native. Keyed off import_idx (a private namespace) so it never collides with the cap_bit-indexed mask — exactly cranelift’s host_fns split.

Implementations

impl CapabilityVtable

pub fn with_capacity(_n: usize) -> Self

Build an empty vtable: no capabilities granted, no host fns registered. The n argument is accepted for source-shape parity with cranelift’s with_capacity(n); the LLVM mask is fixed at 64 bits so the value is only used to assert the caller does not ask for more bits than the i64 mask can hold.

pub fn grant(&mut self, cap_bit: u32)

Grant a capability bit by setting it in the caps mask. An Op::CheckCap { cap_bit } only tests the bit, so a set bit is enough to let the guard pass; the actual call dispatches through the import_idx-keyed host_fns registry. Mirrors cranelift’s CapabilityVtable::grant (which parks a non-null sentinel).

Bits >= 64 are silently ignored (the i64 mask cannot carry them); the matching Op::CheckCap lowering rejects an out-of- range bit at compile time, so a too-large grant can never satisfy a gate either way.

pub fn register_via_gate<G: CapabilityGate>( &mut self, gate: &G, cap_bit: CapabilityBit, ) -> bool

Capability-gated grant. Consults gate for cap_bit via the shared relon_eval_api::CapabilityGate trait; if the gate denies the bit, the mask bit stays clear so the IR-level Op::CheckCap traps with SandboxTrapKind::CapabilityDenied. This is the LLVM backend’s half of the unified-enforcement design: the same policy the tree-walker consults at dispatch time and the cranelift backend consults at vtable-build time is consulted here when folding the bit into the caps mask, so denying a bit on the host side produces the same outcome class (RuntimeError::CapabilityDenied) on all three backends.

Returns true if the bit was granted; false if the gate denied it (mask bit left clear).

pub fn is_granted(&self, cap_bit: u32) -> bool

true when cap_bit is granted in the mask. The LLVM analogue of cranelift’s lookup(cap_bit).is_some().

pub fn caps_mask(&self) -> i64

The granted-capability bitmask, ready to hand to the linked entry as its trailing caps param (or to LlvmAotEvaluator::with_caps). This is the runtime carrier the Op::CheckCap gate baked into the emitted object reads.

pub fn register_host_fn( &mut self, import_idx: u32, func: Arc<dyn RelonFunction>, )

Register a dynamic Arc<dyn RelonFunction> host fn at the given import_idx. Mirrors cranelift’s CapabilityVtable::register_host_fn; delegates to the existing HostFnRegistry so the JIT-side relon_llvm_call_native dispatch resolves against the same map.

pub fn resolve_host_fn( &self, import_idx: u32, ) -> Option<&Arc<dyn RelonFunction>>

Resolve the dynamic host fn registered at import_idx. Mirrors cranelift’s CapabilityVtable::resolve_host_fn.

pub fn host_fns(&self) -> &HostFnRegistry

Borrow the underlying HostFnRegistry so the evaluator can install it on a per-call [crate::state::ArenaState] via ArenaState::install_host_fns.

pub fn host_fn_count(&self) -> usize

Number of registered dynamic host fns.

Trait Implementations

impl Clone for CapabilityVtable

fn clone(&self) -> CapabilityVtable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CapabilityVtable

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

Formats the value using the given formatter.

impl Default for CapabilityVtable

fn default() -> CapabilityVtable

Returns the “default value” for a type.