Enum ExternalName

pub enum ExternalName {
    User(UserExternalNameRef),
    TestCase(TestcaseName),
    LibCall(LibCall),
    KnownSymbol(KnownSymbol),
}

The name of an external is either a reference to a user-defined symbol table, or a short sequence of ascii bytes so that test cases do not have to keep track of a symbol table.

External names are primarily used as keys by code using Cranelift to map from a cranelift_codegen::ir::FuncRef or similar to additional associated data.

External names can also serve as a primitive testing and debugging tool. In particular, many .clif test files use function names to identify functions.

Variants

User(UserExternalNameRef)

A reference to a name in a user-defined symbol table.

TestCase(TestcaseName)

A test case function name of up to a hardcoded amount of ascii characters. This is not intended to be used outside test cases.

LibCall(LibCall)

A well-known runtime library function.

KnownSymbol(KnownSymbol)

A well-known symbol.

Implementations

impl ExternalName

pub fn testcase<T>(v: T) -> ExternalName

where T: AsRef<[u8]>,

Creates a new external name from a sequence of bytes. Caller is expected to guarantee bytes are only ascii alphanumeric or _.

Examples

// Create `ExternalName` from a string.
let name = ExternalName::testcase("hello");
assert_eq!(name.display(None).to_string(), "%hello");

pub fn user(func_ref: UserExternalNameRef) -> ExternalName

Create a new external name from a user-defined external function reference.

Examples

let user_func_ref: UserExternalNameRef = Default::default(); // usually obtained with `Function::declare_imported_user_function()`
let name = ExternalName::user(user_func_ref);
assert_eq!(name.display(None).to_string(), "userextname0");

pub fn display<'a>( &'a self, params: Option<&'a FunctionParameters>, ) -> DisplayableExternalName<'a>

Returns a display for the current ExternalName, with extra context to prettify the output.

Trait Implementations

impl Clone for ExternalName

fn clone(&self) -> ExternalName

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExternalName

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

Formats the value using the given formatter.

impl Default for ExternalName

fn default() -> ExternalName

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExternalName

fn deserialize<__D>( __deserializer: __D, ) -> Result<ExternalName, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromStr for ExternalName

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<ExternalName, <ExternalName as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for ExternalName

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

where __H: Hasher,

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 PartialEq for ExternalName

fn eq(&self, other: &ExternalName) -> 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 Serialize for ExternalName

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ExternalName

impl StructuralPartialEq for ExternalName