Enum CallingConvention

#[non_exhaustive]
#[repr(u64)]
pub enum CallingConvention {
    C = 0,
    Fast = 8,
    Cold = 9,
    GHC = 10,
    HiPE = 11,
    WebKitJS = 12,
    AnyReg = 13,
    PreserveMost = 14,
    PreserveAll = 15,
    Swift = 16,
    CXXFASTTLS = 17,
    X86Stdcall = 64,
    X86Fastcall = 65,
    ARMAPCS = 66,
    ARMAAPCS = 67,
    ARMAAPCSVFP = 68,
    MSP430INTR = 69,
    X86ThisCall = 70,
    PTXKernel = 71,
    PTXDevice = 72,
    SPIRFUNC = 75,
    SPIRKERNEL = 76,
    IntelOCLBI = 77,
    X8664SysV = 78,
    Win64 = 79,
    X86VectorCall = 80,
    HHVM = 81,
    HHVMC = 82,
    X86INTR = 83,
    AVRINTR = 84,
    AVRSIGNAL = 85,
    AVRBUILTIN = 86,
    AMDGPUVS = 87,
    AMDGPUGS = 88,
    AMDGPUPS = 89,
    AMDGPUCS = 90,
    AMDGPUKERNEL = 91,
    X86RegCall = 92,
    AMDGPUHS = 93,
    MSP430BUILTIN = 94,
    AMDGPULS = 95,
    AMDGPUES = 96,
}

Calling conventions supported by LLVM.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

C = 0

Fast = 8

Cold = 9

GHC = 10

HiPE = 11

WebKitJS = 12

AnyReg = 13

PreserveMost = 14

PreserveAll = 15

Swift = 16

CXXFASTTLS = 17

X86Stdcall = 64

X86Fastcall = 65

ARMAPCS = 66

ARMAAPCS = 67

ARMAAPCSVFP = 68

MSP430INTR = 69

X86ThisCall = 70

PTXKernel = 71

PTXDevice = 72

SPIRFUNC = 75

SPIRKERNEL = 76

IntelOCLBI = 77

X8664SysV = 78

Win64 = 79

X86VectorCall = 80

HHVM = 81

HHVMC = 82

X86INTR = 83

AVRINTR = 84

AVRSIGNAL = 85

AVRBUILTIN = 86

AMDGPUVS = 87

AMDGPUGS = 88

AMDGPUPS = 89

AMDGPUCS = 90

AMDGPUKERNEL = 91

X86RegCall = 92

AMDGPUHS = 93

MSP430BUILTIN = 94

AMDGPULS = 95

AMDGPUES = 96

Trait Implementations

impl Debug for CallingConvention

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

Formats the value using the given formatter.

impl PartialEq for CallingConvention

fn eq(&self, other: &CallingConvention) -> 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 CallingConvention

type Error = TryFromPrimitiveError<CallingConvention>

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 CallingConvention

const NAME: &'static str = "CallingConvention"

type Primitive = u64

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

impl StructuralPartialEq for CallingConvention