Struct Module

pub struct Module {
    pub name: Ident,
    pub docs: Option<String>,
    /* private fields */
}

Represents a SSA IR module

These correspond to MASM modules.

This module is largely a container for functions, but it also provides as the owner for pooled resources available to functions:

• Mapping from Signature to FuncRef
• Mapping from FunctionName to FuncRef

Fields

name: Ident

The name of this module

docs: Option<String>

Documentation attached to this module, to be passed through to Miden Assembly during code generation.

Implementations

impl Module

pub fn new<S: Into<Ident>>(name: S) -> Self

Create a new, empty Module

pub fn new_with_span<S: AsRef<str>>(name: S, span: SourceSpan) -> Self

Create a new, empty Module with the given source location

pub fn new_kernel<S: Into<Ident>>(name: S) -> Self

Create a new, empty kernel Module

pub fn new_kernel_with_span<S: AsRef<str>>(name: S, span: SourceSpan) -> Self

Create a new, empty kernel Module with the given source location

pub const fn page_size(&self) -> u32

Get the page size to use by default for this module.

pub const fn reserved_memory_pages(&self) -> u32

Get the size (in pages) of the linear memory address space (starting from offset 0), which is reserved for use by the caller.

pub const fn reserved_memory_bytes(&self) -> u32

Get the size (in bytes) of the linear memory address space (starting from offset 0), which is reserved for use by the caller.

pub fn set_reserved_memory_size(&mut self, size: u32)

Set the size of the reserved linear memory region.

NOTE: Declared data segments can be placed in the reserved area, but global variables will never be allocated in the reserved area.

pub const fn is_kernel(&self) -> bool

Returns true if this module is a kernel module

pub fn is_detached(&self) -> bool

Returns true if this module has yet to be attached to a Program

pub fn segments(&self) -> &DataSegmentTable

Return the table of data segments for this module

pub fn declare_data_segment( &mut self, offset: Offset, size: u32, init: ConstantData, readonly: bool, ) -> Result<(), DataSegmentError>

Declare a new DataSegment in this module, with the given offset, size, and data.

Returns Err if the segment declaration is invalid, or conflicts with an existing segment

Data segments are ordered by the address at which they are allocated, at link-time, all segments from all modules are linked together, and they must either be disjoint, or exactly identical in order to overlap - it is not permitted to have partially overlapping segments with different views of the memory represented by that segment.

pub fn globals(&self) -> &GlobalVariableTable

Return the table of global variables for this module

pub fn declare_global_variable( &mut self, name: Ident, ty: Type, linkage: Linkage, init: Option<ConstantData>, ) -> Result<GlobalVariable, GlobalVariableError>

Declare a new GlobalVariable in this module, with the given name, type, linkage, and optional initializer.

Returns Err if a symbol with the same name but conflicting declaration already exists, or if the specification of the global variable is invalid in any way.

NOTE: The GlobalVariable returned here is scoped to this module only, it cannot be used to index into the global variable table of a Program, which is constructed at link-time.

pub fn set_global_initializer( &mut self, gv: GlobalVariable, init: ConstantData, ) -> Result<(), GlobalVariableError>

Set the initializer for a GlobalVariable to init.

Returns Err if the initializer conflicts with the current definition of the global in any way.

pub fn global(&self, id: GlobalVariable) -> &GlobalVariableData

Get the data associated with the given GlobalVariable

pub fn find_global(&self, name: Ident) -> Option<&GlobalVariableData>

Look up a global by name.

pub fn entrypoint(&self) -> Option<FunctionIdent>

Find the first function in this module marked with the entrypoint attribute

pub fn functions<'a, 'b: 'a>(&'b self) -> Iter<'a, FunctionListAdapter>

Return an iterator over the functions in this module

The iterator is double-ended, so can be used to traverse the module body in either direction

pub fn function<'a, 'b: 'a>(&'b self, id: Ident) -> Option<&'a Function>

Get a Function in this module by name, if available

pub fn imports(&self) -> ModuleImportInfo

Compute the set of imports for this module, automatically aliasing modules when there are namespace conflicts

pub fn contains(&self, name: Ident) -> bool

Returns true if this module contains the function name

pub fn unlink(&mut self, id: Ident) -> Box<Function>

Unlinks the given function from this module

pub fn push( &mut self, function: Box<Function>, ) -> Result<(), SymbolConflictError>

Append function to the end of this module’s body, returning the [FuncId] assigned to it within this module.

NOTE: This function will panic if either of the following rules are violated:

• If this module is a kernel module, public functions must use the kernel calling convention, however private functions can use any convention.
• If this module is not a kernel module, functions may not use the kernel calling convention

pub fn insert_before( &mut self, function: Box<Function>, before: Ident, ) -> Result<(), SymbolConflictError>

Insert function in the module body before the function with id before

If before is no longer attached to this module, function is added to the end of the module body.

pub fn insert_after( &mut self, function: Box<Function>, after: Ident, ) -> Result<(), SymbolConflictError>

Insert function in the module body after the function with id after

If after is no longer attached to this module, function is added to the end of the module body.

pub fn pop_front(&mut self) -> Option<Box<Function>>

Remove the first function in the module, and return it, if present

pub fn cursor_mut<'a, 'b: 'a>(&'b mut self) -> ModuleCursor<'a>

Returns a mutable cursor to the module body, starting at the first function.

If the module body is empty, the returned cursor will point to the null object.

NOTE: If one uses this cursor to insert a function that is invalid

pub fn cursor_at<'a, 'b: 'a>( &'b self, id: Ident, ) -> Cursor<'a, FunctionListAdapter>

Returns a cursor to the module body, located at the function indicated by id.

If no function with id is in the list, the returned cursor will point to the null object.

pub fn cursor_mut_at<'a, 'b: 'a>(&'b mut self, id: Ident) -> ModuleCursor<'a>

Returns a mutable cursor to the module body, located at the function indicated by id.

If no function with id is in the list, the returned cursor will point to the null object.

Trait Implementations

impl AnalysisKey for Module

type Key = Ident

The type of the unique identifier associated with Self

fn key(&self) -> Self::Key

Get the key to associate with the current entity

impl Debug for Module

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

Formats the value using the given formatter.

impl Display for Module

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

Formats the value using the given formatter.

impl Emit for Module

fn name(&self) -> Option<Symbol>

The name of this item, if applicable

fn output_type(&self, _mode: OutputMode) -> OutputType

The output type associated with this item and the given mode

fn write_to<W: Write>( &self, writer: W, mode: OutputMode, _session: &Session, ) -> Result<()>

Write this item to the given std::io::Write handle, using mode to determine the output type

fn write_to_stdout(&self, session: &Session) -> Result<(), Error>

Write this item to standard output, inferring the best OutputMode based on whether or not stdout is a tty or not

fn write_to_file( &self, path: &Path, mode: OutputMode, session: &Session, ) -> Result<(), Error>

Write this item to the given file path, using mode to determine the output type

impl Parse for Module

type Grammar = ModuleParser

fn parse_tokens( parser: &Parser<'_>, source: Arc<SourceFile>, tokens: impl IntoIterator<Item = Result<(ByteIndex, Token, ByteIndex), ParseError>>, ) -> ParseResult<Self>

fn parse(parser: &Parser<'_>, source: Arc<SourceFile>) -> ParseResult<Self>

impl PartialEq for Module

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PrettyPrint for Module

fn render(&self) -> Document

The core of the PrettyPrint functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.

impl Spanned for Module

fn span(&self) -> SourceSpan

impl Eq for Module