Enum Constant 

pub enum Constant {
    Null,
    Undef,
    Integer(i64),
    Float(u64),
    Aggregate(Vec<ValueId>),
    Data(Vec<u64>),
    String(Vec<u8>),
    Gep {
        base: ValueId,
        indices: Vec<ValueId>,
        source: TypeId,
        inbounds: bool,
    },
    Cast {
        op: CastOp,
        value: ValueId,
    },
    Binary {
        op: BinaryOp,
        lhs: ValueId,
        rhs: ValueId,
        flags: u64,
    },
    Compare {
        predicate: u64,
        lhs: ValueId,
        rhs: ValueId,
    },
}

A module-level constant.

Variants

Null

The null value of the constant’s type (zero).

Undef

An undefined value.

Integer(i64)

An integer’s bits, sign-extended from its width.

Float(u64)

A float’s bits (half, float or double by its type).

Aggregate(Vec<ValueId>)

An array, structure or vector of other constants (value ids).

Data(Vec<u64>)

A constant array or vector of numbers, as stored (the bits of each element).

String(Vec<u8>)

An array of i8 given as text: its bytes, with the terminating zero a CST_CODE_CSTRING record implies.

Gep

A constant getelementptr: the base (a global) and its indices (module constants).

Fields

base: ValueId

The base global.

indices: Vec<ValueId>

The index constants.

source: TypeId

The type the first index steps over: the base’s pointee.

inbounds: bool

inbounds (CST_CODE_CE_INBOUNDS_GEP).

Cast

A constant cast of a module value (to the type of the constant).

Fields

op: CastOp

The cast.

value: ValueId

The value cast.

Binary

A constant binary operation on module values.

Fields

op: BinaryOp

The operation.

lhs: ValueId

The left operand.

rhs: ValueId

The right operand.

flags: u64

The record’s flags, as Instruction::flags.

Compare

A constant comparison of module values, by its LLVM predicate (as Op::Compare).

Fields

predicate: u64

The predicate.

lhs: ValueId

The left operand.

rhs: ValueId

The right operand.

Trait Implementations

impl Clone for Constant

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Constant

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

Formats the value using the given formatter.

impl PartialEq for Constant

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Constant