Enum TypeCode

#[repr(u64)]
pub enum TypeCode {
    NumEntry = 1,
    Void = 2,
    Float = 3,
    Double = 4,
    Label = 5,
    Opaque = 6,
    Integer = 7,
    Pointer = 8,
    FunctionOld = 9,
    Half = 10,
    Array = 11,
    Vector = 12,
    X86Fp80 = 13,
    Fp128 = 14,
    PpcFp128 = 15,
    Metadata = 16,
    X86Mmx = 17,
    StructAnon = 18,
    StructName = 19,
    StructNamed = 20,
    Function = 21,
    Token = 22,
    BFloat = 23,
    X86Amx = 24,
    OpaquePointer = 25,
}

Codes for each record in TYPE_BLOCK (i.e., TYPE_BLOCK_ID_NEW).

Variants

NumEntry = 1

TYPE_CODE_NUMENTRY: [numentries]

Void = 2

TYPE_CODE_VOID

Float = 3

TYPE_CODE_FLOAT

Double = 4

TYPE_CODE_DOUBLE

Label = 5

TYPE_CODE_LABEL

Opaque = 6

TYPE_CODE_OPAQUE

Integer = 7

TYPE_CODE_INTEGER: [width]

Pointer = 8

TYPE_CODE_POINTER: [pointee type]

FunctionOld = 9

TYPE_CODE_FUNCTION_OLD: [vararg, attrid, retty, paramty x N]

Half = 10

TYPE_CODE_HALF

Array = 11

TYPE_CODE_ARRAY: [numelts, eltty]

Vector = 12

TYPE_CODE_VECTOR: [numelts, eltty]

X86Fp80 = 13

TYPE_CODE_X86_FP80

Fp128 = 14

TYPE_CODE_FP128

PpcFp128 = 15

TYPE_CODE_PPC_FP128

Metadata = 16

TYPE_CODE_METADATA,

X86Mmx = 17

TYPE_CODE_X86_MMX

StructAnon = 18

TYPE_CODE_STRUCT_ANON: [ispacked, eltty x N]

StructName = 19

TYPE_CODE_STRUCT_NAME: [strchr x N]

StructNamed = 20

TYPE_CODE_STRUCT_NAMED: [ispacked, eltty x N]

Function = 21

TYPE_CODE_FUNCTION: [vararg, retty, paramty x N]

Token = 22

TYPE_CODE_TOKEN

BFloat = 23

TYPE_CODE_BFLOAT

X86Amx = 24

TYPE_CODE_X86_AMX

OpaquePointer = 25

TYPE_CODE_OPAQUE_POINTER: [addrspace]

Trait Implementations

impl Debug for TypeCode

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

Formats the value using the given formatter.

impl From<TypeCode> for u64

fn from(enum_value: TypeCode) -> Self

Converts to this type from the input type.

impl PartialEq for TypeCode

fn eq(&self, other: &TypeCode) -> 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 TryFrom<u64> for TypeCode

type Error = TryFromPrimitiveError<TypeCode>

The type returned in the event of a conversion error.

fn try_from(number: u64) -> Result<Self, TryFromPrimitiveError<Self>>

Performs the conversion.

impl TryFromPrimitive for TypeCode

const NAME: &'static str = "TypeCode"

type Primitive = u64

fn try_from_primitive( number: Self::Primitive, ) -> Result<Self, TryFromPrimitiveError<Self>>

impl StructuralPartialEq for TypeCode