Enum llvm_ir::constant::Constant[−][src]

pub enum Constant {
Show variants    Int {
        bits: u32,
        value: u64,
    },
    Float(Float),
    Null(TypeRef),
    AggregateZero(TypeRef),
    Struct {
        name: Option<String>,
        values: Vec<ConstantRef>,
        is_packed: bool,
    },
    Array {
        element_type: TypeRef,
        elements: Vec<ConstantRef>,
    },
    Vector(Vec<ConstantRef>),
    Undef(TypeRef),
    BlockAddress,
    GlobalReference {
        name: Name,
        ty: TypeRef,
    },
    TokenNone,
    Add(Add),
    Sub(Sub),
    Mul(Mul),
    UDiv(UDiv),
    SDiv(SDiv),
    URem(URem),
    SRem(SRem),
    And(And),
    Or(Or),
    Xor(Xor),
    Shl(Shl),
    LShr(LShr),
    AShr(AShr),
    FAdd(FAdd),
    FSub(FSub),
    FMul(FMul),
    FDiv(FDiv),
    FRem(FRem),
    ExtractElement(ExtractElement),
    InsertElement(InsertElement),
    ShuffleVector(ShuffleVector),
    ExtractValue(ExtractValue),
    InsertValue(InsertValue),
    GetElementPtr(GetElementPtr),
    Trunc(Trunc),
    ZExt(ZExt),
    SExt(SExt),
    FPTrunc(FPTrunc),
    FPExt(FPExt),
    FPToUI(FPToUI),
    FPToSI(FPToSI),
    UIToFP(UIToFP),
    SIToFP(SIToFP),
    PtrToInt(PtrToInt),
    IntToPtr(IntToPtr),
    BitCast(BitCast),
    AddrSpaceCast(AddrSpaceCast),
    ICmp(ICmp),
    FCmp(FCmp),
    Select(Select),
}

Expand description

See LLVM 12 docs on Constants. Constants can be either values, or expressions involving other constants (see LLVM 12 docs on Constant Expressions).

Variants

Int

Show fields

Fields of Int

bits: u32

Number of bits in the constant integer

value: u64

The constant value itself.

If bits == 64, this is the value.

If bits < 64, the constant value is zero-extended to fit in this field.

If bits > 64, the constant value is truncated to fit in this field; but if this truncation would change the value (i.e., if the value is >= 2^64 when interpreted as unsigned) then Module::from_bc_path() will fail. See #5.

Float(Float)

Null(TypeRef)

The TypeRef here must be to a PointerType. See LLVM 12 docs on Simple Constants

AggregateZero(TypeRef)

A zero-initialized array or struct (or scalar).

Struct

Show fields

Fields of Struct

name: Option<String>values: Vec<ConstantRef>is_packed: bool

Array

Show fields

Fields of Array

element_type: TypeRefelements: Vec<ConstantRef>

Vector(Vec<ConstantRef>)

Undef(TypeRef)

Undef can be used anywhere a constant is expected. See LLVM 12 docs on Undefined Values

BlockAddress

The address of the given (non-entry) BasicBlock. See LLVM 12 docs on Addresses of Basic Blocks. BlockAddress needs more fields, but the necessary getter functions are apparently not exposed in the LLVM C API (only the C++ API)

GlobalReference

Show fields

Fields of GlobalReference

name: Namety: TypeRef

TokenNone

Add(Add)

Sub(Sub)

Mul(Mul)

UDiv(UDiv)

SDiv(SDiv)

URem(URem)

SRem(SRem)

And(And)

Or(Or)

Xor(Xor)

Shl(Shl)

LShr(LShr)

AShr(AShr)

FAdd(FAdd)

FSub(FSub)

FMul(FMul)

FDiv(FDiv)

FRem(FRem)

ExtractElement(ExtractElement)

InsertElement(InsertElement)

ShuffleVector(ShuffleVector)

ExtractValue(ExtractValue)

InsertValue(InsertValue)

GetElementPtr(GetElementPtr)

Trunc(Trunc)

ZExt(ZExt)

SExt(SExt)

FPTrunc(FPTrunc)

FPExt(FPExt)

FPToUI(FPToUI)

FPToSI(FPToSI)

UIToFP(UIToFP)

SIToFP(SIToFP)

PtrToInt(PtrToInt)

IntToPtr(IntToPtr)

BitCast(BitCast)

AddrSpaceCast(AddrSpaceCast)

ICmp(ICmp)

FCmp(FCmp)

Select(Select)

Enum llvm_ir::constant::Constant[−][src]

Variants

Fields of Int

Fields of Struct

Fields of Array

Fields of GlobalReference

Trait Implementations

Auto Trait Implementations

Blanket Implementations