Struct pliron_llvm::types::StructType

pub struct StructType { /* private fields */ }

Represents a c-like struct type. Limitations and warnings on its usage are similar to that in MLIR. <https://mlir.llvm.org/docs/Dialects/LLVM/#structure-types>

1. Anonymous (aka unnamed) structs cannot be recursive.
2. Named structs are uniqued only by name, and may be recursive. Call “set_fields” after creation to set recursive types.
3. LLVM calls anonymous structs as literal structs and named structs as identified structs.

Implementations

impl StructType

pub fn get_named( ctx: &mut Context, name: &str, fields: Option<Vec<StructField>> ) -> Result<TypePtr<Self>>

Get or create a new named StructType. If fields is None, it indicates an opaque (i.e., not finalized) struct. Opaque structs must be finalized (by passing non-none fields) for verify() to succeed. Opaque structs are an intermediary in creating recursive types. Returns an error when the name is already registered but the fields don’t match.

pub fn get_unnamed(ctx: &mut Context, fields: Vec<StructField>) -> TypePtr<Self>

Get or create a new unnamed (anonymous) struct. These are finalized upon creation, and uniqued based on the fields.

pub fn is_finalized(ctx: &Context, ty: Ptr<TypeObj>) -> bool

Is this struct finalized? Returns false for non StructTypes.

pub fn get_existing_named(ctx: &Context, name: &str) -> Option<TypePtr<Self>>

If a named struct already exists, get a pointer to it.

pub fn get_existing_unnamed( ctx: &Context, fields: Vec<StructField> ) -> Option<TypePtr<Self>>

If an unnamed struct already exists, get a pointer to it.

pub fn field_type(&self, field_idx: usize) -> Ptr<TypeObj>

Get type of the idx’th field.

pub fn field_name(&self, field_idx: usize) -> Identifier

Get name of the idx’th field.

pub fn num_fields(&self) -> usize

Get the number of fields this struct has

Trait Implementations

impl Debug for StructType

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

Formats the value using the given formatter.

impl Hash for StructType

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

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 Parsable for StructType

type Arg = ()

Type of the argument that must be passed to the parser.

type Parsed = TypePtr<StructType>

The type of the parsed entity.

fn parse<'a>( state_stream: &mut StateStream<'a>, _arg: Self::Arg ) -> ParseResult<'a, Self::Parsed>

where Self: Sized,

Define a parser using existing combinators and call into on Parser::parse_stream to get the final ParseResult. Use state_stream.state as necessary.

fn parser<'a>( arg: Self::Arg ) -> Box<dyn Parser<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, PartialState = (), Output = Self::Parsed> + 'a>

Get a parser combinator that can work on StateStream as its input.

fn parser_fn<'a>( _: &'a (), arg: Self::Arg ) -> Box<dyn Parser<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, PartialState = (), Output = Self::Parsed> + 'a>

Same as Self::parser but takes a unit reference for use as ParserFn

impl PartialEq for StructType

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Printable for StructType

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

fn disp<'t, 'c>(&'t self, ctx: &'c Context) -> Box<dyn Display + 'c>

where 't: 'c, Self: Sized + 'c,

Get a Display’able object from the given Context and default State.

fn print<'t, 'c>( &'t self, ctx: &'c Context, state: &State ) -> Box<dyn Display + 'c>

where 't: 'c, Self: Sized + 'c,

Get a Display’able object from the given Context and State.

impl Type for StructType

fn hash_type(&self) -> TypeValueHash

Compute and get the hash for this instance of Self. Hash collisions can be a possibility.

fn eq_type(&self, other: &dyn Type) -> bool

Is self equal to an other Type?

fn get_type_id(&self) -> TypeId

Get a Type’s static name. This is not per instantiation of the type. It is mostly useful for printing and parsing the type. Uniquing does not use this, but instead uses std::any::TypeId.

fn get_type_id_static() -> TypeId

Same as get_type_id, but without the self reference.

fn get_self_ptr(&self, ctx: &Context) -> Ptr<Box<dyn Type>>

Get a copyable pointer to this type.

fn register_instance(t: Self, ctx: &mut Context) -> TypePtr<Self>

where Self: Sized,

Register an instance of a type in the provided Context Returns a pointer to self. If the type was already registered, a pointer to the existing object is returned.

fn get_instance(t: Self, ctx: &Context) -> Option<TypePtr<Self>>

where Self: Sized,

If an instance of t already exists, get a Ptr to it. Consumes t either way.

fn register_type_in_dialect( dialect: &mut Dialect, parser: for<'a> fn(_: &'a (), _: ()) -> Box<dyn Parser<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, PartialState = (), Output = TypePtr<Self>> + 'a> )

where Self: Sized,

Register this Type’s TypeId in the dialect it belongs to.

impl Verify for StructType

fn verify(&self, _ctx: &Context) -> Result<()>

impl Eq for StructType