Struct AsmCompiler

pub struct AsmCompiler<C: Config> {
    pub next_addr: C::F,
    pub virtual_to_physical: VecMap<Address<C::F>>,
    pub consts: HashMap<Imm<C::F, C::EF>, (Address<C::F>, C::F)>,
    pub addr_to_mult: VecMap<C::F>,
}

The backend for the circuit compiler.

Fields

next_addr: C::F

virtual_to_physical: VecMap<Address<C::F>>

Map the frame pointers of the variables to the “physical” addresses.

consts: HashMap<Imm<C::F, C::EF>, (Address<C::F>, C::F)>

Map base or extension field constants to “physical” addresses and mults.

addr_to_mult: VecMap<C::F>

Map each “physical” address to its read count.

Implementations

impl<C: Config> AsmCompiler<C>

where C::F: PrimeField64,

pub fn alloc(next_addr: &mut C::F) -> Address<C::F>

Allocate a fresh address. Checks that the address space is not full.

pub fn read_ghost_vaddr(&mut self, vaddr: usize) -> Address<C::F>

Map fp to its existing address without changing its mult.

Ensures that fp has already been assigned an address.

pub fn read_vaddr(&mut self, vaddr: usize) -> Address<C::F>

Map fp to its existing address and increment its mult.

Ensures that fp has already been assigned an address.

pub fn read_vaddr_internal( &mut self, vaddr: usize, increment_mult: bool, ) -> Address<C::F>

pub fn write_fp(&mut self, vaddr: usize) -> Address<C::F>

Map fp to a fresh address and initialize the mult to 0.

Ensures that fp has not already been written to.

pub fn read_addr(&mut self, addr: Address<C::F>) -> &mut C::F

Increment the existing mult associated with addr.

Ensures that addr has already been assigned a mult.

pub fn read_ghost_addr(&mut self, addr: Address<C::F>) -> &mut C::F

Retrieves mult associated with addr.

Ensures that addr has already been assigned a mult.

pub fn write_addr(&mut self, addr: Address<C::F>) -> &mut C::F

Associate a mult of zero with addr.

Ensures that addr has not already been written to.

pub fn read_const(&mut self, imm: Imm<C::F, C::EF>) -> Address<C::F>

Read a constant (a.k.a. immediate).

Increments the mult, first creating an entry if it does not yet exist.

pub fn read_ghost_const(&mut self, imm: Imm<C::F, C::EF>) -> Address<C::F>

Read a constant (a.k.a. immediate).

Does not increment the mult. Creates an entry if it does not yet exist.

impl<C> AsmCompiler<C>

where C: Config<N = <C as Config>::F> + Debug, C::F: PrimeField64 + TwoAdicField,

pub fn compile_one( &mut self, ir_instr: DslIr<C>, consumer: impl FnMut(Result<Instruction<C::F>, CompileOneErr<C>>), )

Compiles one instruction, passing one or more instructions to consumer.

We do not simply return a Vec for performance reasons — results would be immediately fed to flat_map, so we employ fusion/deforestation to eliminate intermediate data structures.

pub fn compile(&mut self, program: DslIrProgram<C>) -> RecursionProgram<C::F>

Compile a DslIrProgram that is definitionally assumed to be well-formed.

Returns a well-formed program.

pub fn compile_inner(&mut self, root_block: DslIrBlock<C>) -> RootProgram<C::F>

Compile a root DslIrBlock that has not necessarily been validated.

Returns a program that may be ill-formed.

Trait Implementations

impl<C: Clone + Config> Clone for AsmCompiler<C>

where C::F: Clone, C::EF: Clone,

fn clone(&self) -> AsmCompiler<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug + Config> Debug for AsmCompiler<C>

where C::F: Debug, C::EF: Debug,

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

Formats the value using the given formatter.

impl<C: Default + Config> Default for AsmCompiler<C>

where C::F: Default, C::EF: Default,

fn default() -> AsmCompiler<C>

Returns the “default value” for a type.