Struct GlobalVariableTable

pub struct GlobalVariableTable { /* private fields */ }

This table is used to lay out and link together global variables for a Program.

See the docs for Linkage, GlobalVariableData, and GlobalVariableTable::declare for more details.

Implementations

impl GlobalVariableTable

pub fn new(conflict_strategy: ConflictResolutionStrategy) -> Self

pub fn len(&self) -> usize

Returns the number of global variables in this table

pub fn is_empty(&self) -> bool

Returns true if the global variable table is empty

pub fn iter<'a, 'b: 'a>(&'b self) -> Iter<'a, GlobalVariableAdapter>

Get a double-ended iterator over the current table layout

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

Returns true if a global variable with name has been declared

pub fn find(&self, name: Ident) -> Option<GlobalVariable>

Looks up a GlobalVariable by name.

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

Gets the data associated with the given GlobalVariable

pub fn contains_key(&self, id: GlobalVariable) -> bool

Checks if the given id can be found in this table

pub fn remove(&mut self, id: GlobalVariable)

Removes the global variable associated with id from this table

The actual definition remains behind, in order to ensure that id remains valid should there be any other outstanding references, however the data is removed from the layout, and will not be seen when traversing the table.

pub fn size_in_bytes(&self) -> usize

Computes the total size in bytes of the table, as it is currently laid out.

pub unsafe fn offset_of(&self, id: GlobalVariable) -> u32

Computes the offset, in bytes, of the given GlobalVariable from the start of the segment in which globals are allocated, assuming that the layout of the global variable table up to and including id remains unchanged.

Safety

This should only be used once all data segments and global variables have been declared, and the layout of the table has been decided. It is technically safe to use offsets obtained before all global variables are declared, IF the data segments and global variable layout up to and including those global variables remains unchanged after that point.

If the offset for a given global variable is obtained, and the heap layout is subsequently changed in such a way that the original offset is no longer accurate, bad things will happen.

pub fn get_constant(&self, id: Constant) -> Arc<ConstantData>

Get the constant data associated with id

pub fn insert_constant(&mut self, data: ConstantData) -> Constant

Inserts the given constant data into this table without allocating a global

pub fn insert_refcounted_constant( &mut self, data: Arc<ConstantData>, ) -> Constant

Inserts the given constant data into this table without allocating a global

pub fn contains_constant(&self, data: &ConstantData) -> bool

Returns true if the given constant data is in the constant pool

pub fn constants( &self, ) -> impl Iterator<Item = (Constant, Arc<ConstantData>)> + '_

Traverse all of the constants in the table

pub fn has_constants(&self) -> bool

Returns true if the table has constant data stored

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

Declares a new global variable with the given symbol name, type, linkage, and optional initializer.

If successful, Ok is returned, with the GlobalVariable corresponding to the data for the symbol.

Returns an error if the specification of the global is invalid in any way, or the declaration conflicts with a previous declaration of the same name.

NOTE: While similar to try_insert, a key difference is that try_declare does not attempt to resolve conflicts. If the given name has been previously declared, and the declarations are not identical, then an error will be returned. This is because conflict resolution is a process performed when linking together modules. Declaring globals is done during the initial construction of a module, where any attempt to rename a global variable locally would cause unexpected issues as references to that global are emitted. Once a module is constructed, globals it declares with internal linkage can be renamed freely, as the name is no longer significant.

pub fn try_insert( &mut self, data: GlobalVariableData, ) -> Result<(GlobalVariable, bool), GlobalVariableError>

Attempt to insert the given GlobalVariableData into this table.

Returns the id of the global variable in the table, along with a flag indicating whether the global symbol was renamed to resolve a conflict with an existing symbol. The caller is expected to handle such renames so that any references to the original name that are affected can be updated.

If there was an unresolvable conflict, an error will be returned.

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

This sets the initializer for the given GlobalVariable to init.

This function will return Err if any of the following occur:

• The global variable already has an initializer
• The given data does not match the type of the global variable, i.e. more data than the type supports.

If the data is smaller than the type of the global variable, the data will be zero-extended to fill it out.

NOTE: The initializer data is expected to be in little-endian order.

Trait Implementations

impl Debug for GlobalVariableTable

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

Formats the value using the given formatter.

impl Default for GlobalVariableTable

fn default() -> Self

Returns the “default value” for a type.