Struct rustc_codegen_llvm::builder::Builder

#[must_use]pub struct Builder<'a, 'll, 'tcx> {
    pub llbuilder: &'ll mut Builder<'ll>,
    pub cx: &'a CodegenCx<'ll, 'tcx>,
}

Fields

llbuilder: &'ll mut Builder<'ll>

cx: &'a CodegenCx<'ll, 'tcx>

Implementations

impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx>

pub fn llfn(&self) -> &'ll Value

pub(in builder) fn position_at_start(
    &mut self,
    llbb: &'ll BasicBlock
)

pub fn minnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value

pub fn maxnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value

pub fn insert_element(
    &mut self,
    vec: &'ll Value,
    elt: &'ll Value,
    idx: &'ll Value
) -> &'ll Value

pub fn shuffle_vector(
    &mut self,
    v1: &'ll Value,
    v2: &'ll Value,
    mask: &'ll Value
) -> &'ll Value

pub fn vector_reduce_fadd(
    &mut self,
    acc: &'ll Value,
    src: &'ll Value
) -> &'ll Value

pub fn vector_reduce_fmul(
    &mut self,
    acc: &'ll Value,
    src: &'ll Value
) -> &'ll Value

pub fn vector_reduce_fadd_fast(
    &mut self,
    acc: &'ll Value,
    src: &'ll Value
) -> &'ll Value

pub fn vector_reduce_fmul_fast(
    &mut self,
    acc: &'ll Value,
    src: &'ll Value
) -> &'ll Value

pub fn vector_reduce_add(&mut self, src: &'ll Value) -> &'ll Value

pub fn vector_reduce_mul(&mut self, src: &'ll Value) -> &'ll Value

pub fn vector_reduce_and(&mut self, src: &'ll Value) -> &'ll Value

pub fn vector_reduce_or(&mut self, src: &'ll Value) -> &'ll Value

pub fn vector_reduce_xor(&mut self, src: &'ll Value) -> &'ll Value

pub fn vector_reduce_fmin(&mut self, src: &'ll Value) -> &'ll Value

pub fn vector_reduce_fmax(&mut self, src: &'ll Value) -> &'ll Value

pub fn vector_reduce_fmin_fast(&mut self, src: &'ll Value) -> &'ll Value

pub fn vector_reduce_fmax_fast(&mut self, src: &'ll Value) -> &'ll Value

pub fn vector_reduce_min(
    &mut self,
    src: &'ll Value,
    is_signed: bool
) -> &'ll Value

pub fn vector_reduce_max(
    &mut self,
    src: &'ll Value,
    is_signed: bool
) -> &'ll Value

pub fn add_clause(&mut self, landing_pad: &'ll Value, clause: &'ll Value)

pub fn catch_ret(
    &mut self,
    funclet: &Funclet<'ll>,
    unwind: &'ll BasicBlock
) -> &'ll Value

pub(in builder) fn check_store(
    &mut self,
    val: &'ll Value,
    ptr: &'ll Value
) -> &'ll Value

pub(in builder) fn check_call<'b>(
    &mut self,
    typ: &str,
    llfn: &'ll Value,
    args: &'b [&'ll Value]
) -> Cow<'b, [&'ll Value]>

pub fn va_arg(&mut self, list: &'ll Value, ty: &'ll Type) -> &'ll Value

pub(in builder) fn call_lifetime_intrinsic(
    &mut self,
    intrinsic: &str,
    ptr: &'ll Value,
    size: Size
)

pub(crate) fn phi(
    &mut self,
    ty: &'ll Type,
    vals: &[&'ll Value],
    bbs: &[&'ll BasicBlock]
) -> &'ll Value

pub(in builder) fn add_incoming_to_phi(
    &mut self,
    phi: &'ll Value,
    val: &'ll Value,
    bb: &'ll BasicBlock
)

pub(in builder) fn wasm_and_missing_nontrapping_fptoint(
    &self
) -> bool

Methods from Deref<Target = CodegenCx<'ll, 'tcx>>

pub fn const_array(&self, ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value

pub fn const_vector(&self, elts: &[&'ll Value]) -> &'ll Value

pub fn const_bytes(&self, bytes: &[u8]) -> &'ll Value

pub(in common) fn const_cstr(
    &self,
    s: Symbol,
    null_terminated: bool
) -> &'ll Value

pub fn const_get_elt(&self, v: &'ll Value, idx: u64) -> &'ll Value

pub(crate) fn const_bitcast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value

pub(crate) fn static_addr_of_mut(
    &self,
    cv: &'ll Value,
    align: Align,
    kind: Option<&str>
) -> &'ll Value

pub(crate) fn get_static(&self, def_id: DefId) -> &'ll Value

pub(crate) fn statics_to_rauw(&self) -> &RefCell<Vec<(&'ll Value, &'ll Value)>>

pub fn coverage_context<'a>(&'a self) -> Option<&'a CrateCoverageContext<'tcx>>

pub(crate) fn get_intrinsic(&self, key: &str) -> &'b Value

pub(in context) fn insert_intrinsic(
    &self,
    name: &'static str,
    args: Option<&[&'b Type]>,
    ret: &'b Type
) -> &'b Value

pub(in context) fn declare_intrinsic(
    &self,
    key: &str
) -> Option<&'b Value>

pub(crate) fn eh_catch_typeinfo(&self) -> &'b Value

pub fn generate_local_symbol_name(&self, prefix: &str) -> String

Generates a new symbol name with the given prefix. This symbol name must only be used for definitions with internal or private linkage.

pub fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc

Looks up debug source information about a BytePos.

pub fn declare_global(&self, name: &str, ty: &'ll Type) -> &'ll Value

Declare a global value.

If there’s a value with the same name already declared, the function will return its Value instead.

pub fn declare_cfn(&self, name: &str, fn_type: &'ll Type) -> &'ll Value

Declare a C ABI function.

Only use this for foreign function ABIs and glue. For Rust functions use declare_fn instead.

If there’s a value with the same name already declared, the function will update the declaration and return existing Value instead.

pub fn declare_fn(
    &self,
    name: &str,
    fn_abi: &FnAbi<'tcx, Ty<'tcx>>
) -> &'ll Value

Declare a Rust function.

If there’s a value with the same name already declared, the function will update the declaration and return existing Value instead.

pub fn define_global(&self, name: &str, ty: &'ll Type) -> Option<&'ll Value>

Declare a global with an intention to define it.

Use this function when you intend to define a global. This function will return None if the name already has a definition associated with it. In that case an error should be reported to the user, because it usually happens due to user’s fault (e.g., misuse of #[no_mangle] or #[export_name] attributes).

pub fn define_private_global(&self, ty: &'ll Type) -> &'ll Value

Declare a private global

Use this function when you intend to define a global without a name.

pub fn get_declared_value(&self, name: &str) -> Option<&'ll Value>

Gets declared value by name.

pub fn get_defined_value(&self, name: &str) -> Option<&'ll Value>

Gets defined or externally defined (AvailableExternally linkage) value by name.

pub(crate) fn type_named_struct(&self, name: &str) -> &'ll Type

pub(crate) fn set_struct_body(
    &self,
    ty: &'ll Type,
    els: &[&'ll Type],
    packed: bool
)

pub(crate) fn type_void(&self) -> &'ll Type

pub(crate) fn type_metadata(&self) -> &'ll Type

pub(crate) fn type_ix(&self, num_bits: u64) -> &'ll Type

x Creates an integer type with the given number of bits, e.g., i24

pub(crate) fn type_vector(&self, ty: &'ll Type, len: u64) -> &'ll Type

pub(crate) fn func_params_types(&self, ty: &'ll Type) -> Vec<&'ll Type>

pub(crate) fn type_bool(&self) -> &'ll Type

pub(crate) fn type_int_from_ty(&self, t: IntTy) -> &'ll Type

pub(crate) fn type_uint_from_ty(&self, t: UintTy) -> &'ll Type

pub(crate) fn type_float_from_ty(&self, t: FloatTy) -> &'ll Type

pub(crate) fn type_pointee_for_align(&self, align: Align) -> &'ll Type

pub(crate) fn type_padding_filler(&self, size: Size, align: Align) -> &'ll Type

Return a LLVM type that has at most the required alignment, and exactly the required size, as a best-effort padding array.

pub(crate) fn type_variadic_func(
    &self,
    args: &[&'ll Type],
    ret: &'ll Type
) -> &'ll Type

pub(crate) fn type_array(&self, ty: &'ll Type, len: u64) -> &'ll Type

pub fn align_of(&self, ty: Ty<'tcx>) -> Align

pub fn size_of(&self, ty: Ty<'tcx>) -> Size

pub fn size_and_align_of(&self, ty: Ty<'tcx>) -> (Size, Align)

Trait Implementations

impl<'tcx, 'a, 'll> AbiBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx>

pub fn apply_attrs_callsite(
    &mut self,
    fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
    callsite: Self::Value
)

pub fn get_param(&self, index: usize) -> Self::Value

impl<'tcx, 'a, 'll> ArgAbiMethods<'tcx> for Builder<'a, 'll, 'tcx>

pub fn store_fn_arg(
    &mut self,
    arg_abi: &ArgAbi<'tcx, Ty<'tcx>>,
    idx: &mut usize,
    dst: PlaceRef<'tcx, Self::Value>
)

pub fn store_arg(
    &mut self,
    arg_abi: &ArgAbi<'tcx, Ty<'tcx>>,
    val: &'ll Value,
    dst: PlaceRef<'tcx, &'ll Value>
)

pub fn arg_memory_ty(&self, arg_abi: &ArgAbi<'tcx, Ty<'tcx>>) -> &'ll Type

impl<'tcx, 'a, 'll> AsmBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx>

pub fn codegen_llvm_inline_asm(
    &mut self,
    ia: &LlvmInlineAsmInner,
    outputs: Vec<PlaceRef<'tcx, &'ll Value>>,
    inputs: Vec<&'ll Value>,
    span: Span
) -> bool

Take an inline assembly expression and splat it out via LLVM

pub fn codegen_inline_asm(
    &mut self,
    template: &[InlineAsmTemplatePiece],
    operands: &[InlineAsmOperandRef<'tcx, Self>],
    options: InlineAsmOptions,
    line_spans: &[Span]
)

Take an inline assembly expression and splat it out via LLVM

impl<'_, 'll, 'tcx> BackendTypes for Builder<'_, 'll, 'tcx>

type Value = <CodegenCx<'ll, 'tcx> as BackendTypes>::Value

type Function = <CodegenCx<'ll, 'tcx> as BackendTypes>::Function

type BasicBlock = <CodegenCx<'ll, 'tcx> as BackendTypes>::BasicBlock

type Type = <CodegenCx<'ll, 'tcx> as BackendTypes>::Type

type Funclet = <CodegenCx<'ll, 'tcx> as BackendTypes>::Funclet

type DIScope = <CodegenCx<'ll, 'tcx> as BackendTypes>::DIScope

type DILocation = <CodegenCx<'ll, 'tcx> as BackendTypes>::DILocation

type DIVariable = <CodegenCx<'ll, 'tcx> as BackendTypes>::DIVariable

impl<'a, 'tcx, 'll> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx>

pub fn new_block<'b>(
    cx: &'a CodegenCx<'ll, 'tcx>,
    llfn: &'ll Value,
    name: &'b str
) -> Self

pub fn with_cx(cx: &'a CodegenCx<'ll, 'tcx>) -> Self

pub fn build_sibling_block(&self, name: &str) -> Self

pub fn llbb(&self) -> &'ll BasicBlock

pub fn set_span(&mut self, _span: Span)

pub fn position_at_end(&mut self, llbb: &'ll BasicBlock)

pub fn ret_void(&mut self)

pub fn ret(&mut self, v: &'ll Value)

pub fn br(&mut self, dest: &'ll BasicBlock)

pub fn cond_br(
    &mut self,
    cond: &'ll Value,
    then_llbb: &'ll BasicBlock,
    else_llbb: &'ll BasicBlock
)

pub fn switch(
    &mut self,
    v: &'ll Value,
    else_llbb: &'ll BasicBlock,
    cases: impl ExactSizeIterator<Item = (u128, &'ll BasicBlock)>
)

pub fn invoke(
    &mut self,
    llfn: &'ll Value,
    args: &[&'ll Value],
    then: &'ll BasicBlock,
    catch: &'ll BasicBlock,
    funclet: Option<&Funclet<'ll>>
) -> &'ll Value

pub fn unreachable(&mut self)

pub fn add(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn fadd(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn sub(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn fsub(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn mul(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn fmul(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn udiv(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn exactudiv(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn sdiv(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn exactsdiv(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn fdiv(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn urem(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn srem(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn frem(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn shl(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn lshr(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn ashr(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn and(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn or(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn xor(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value

pub fn neg(&mut self, x: &'ll Value) -> &'ll Value

pub fn fneg(&mut self, x: &'ll Value) -> &'ll Value

pub fn not(&mut self, x: &'ll Value) -> &'ll Value

pub fn unchecked_sadd(&mut self, x: &'ll Value, y: &'ll Value) -> &'ll Value

pub fn unchecked_uadd(&mut self, x: &'ll Value, y: &'ll Value) -> &'ll Value

pub fn unchecked_ssub(&mut self, x: &'ll Value, y: &'ll Value) -> &'ll Value

pub fn unchecked_usub(&mut self, x: &'ll Value, y: &'ll Value) -> &'ll Value

pub fn unchecked_smul(&mut self, x: &'ll Value, y: &'ll Value) -> &'ll Value

pub fn unchecked_umul(&mut self, x: &'ll Value, y: &'ll Value) -> &'ll Value

pub fn fadd_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value

pub fn fsub_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value

pub fn fmul_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value

pub fn fdiv_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value

pub fn frem_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value

pub fn checked_binop(
    &mut self,
    oop: OverflowOp,
    ty: Ty<'_>,
    lhs: Self::Value,
    rhs: Self::Value
) -> (Self::Value, Self::Value)

pub fn from_immediate(&mut self, val: Self::Value) -> Self::Value

pub fn to_immediate_scalar(
    &mut self,
    val: Self::Value,
    scalar: &Scalar
) -> Self::Value

pub fn alloca(&mut self, ty: &'ll Type, align: Align) -> &'ll Value

pub fn dynamic_alloca(&mut self, ty: &'ll Type, align: Align) -> &'ll Value

pub fn array_alloca(
    &mut self,
    ty: &'ll Type,
    len: &'ll Value,
    align: Align
) -> &'ll Value

pub fn load(&mut self, ptr: &'ll Value, align: Align) -> &'ll Value

pub fn volatile_load(&mut self, ptr: &'ll Value) -> &'ll Value

pub fn atomic_load(
    &mut self,
    ptr: &'ll Value,
    order: AtomicOrdering,
    size: Size
) -> &'ll Value

pub fn load_operand(
    &mut self,
    place: PlaceRef<'tcx, &'ll Value>
) -> OperandRef<'tcx, &'ll Value>

pub fn write_operand_repeatedly(
    self,
    cg_elem: OperandRef<'tcx, &'ll Value>,
    count: u64,
    dest: PlaceRef<'tcx, &'ll Value>
) -> Self

Called for Rvalue::Repeat when the elem is neither a ZST nor optimizable using memset.

pub fn range_metadata(&mut self, load: &'ll Value, range: Range<u128>)

pub fn nonnull_metadata(&mut self, load: &'ll Value)

pub fn store(
    &mut self,
    val: &'ll Value,
    ptr: &'ll Value,
    align: Align
) -> &'ll Value

pub fn store_with_flags(
    &mut self,
    val: &'ll Value,
    ptr: &'ll Value,
    align: Align,
    flags: MemFlags
) -> &'ll Value

pub fn atomic_store(
    &mut self,
    val: &'ll Value,
    ptr: &'ll Value,
    order: AtomicOrdering,
    size: Size
)

pub fn gep(&mut self, ptr: &'ll Value, indices: &[&'ll Value]) -> &'ll Value

pub fn inbounds_gep(
    &mut self,
    ptr: &'ll Value,
    indices: &[&'ll Value]
) -> &'ll Value

pub fn struct_gep(&mut self, ptr: &'ll Value, idx: u64) -> &'ll Value

pub fn trunc(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn sext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn fptoui_sat(
    &mut self,
    val: &'ll Value,
    dest_ty: &'ll Type
) -> Option<&'ll Value>

pub fn fptosi_sat(
    &mut self,
    val: &'ll Value,
    dest_ty: &'ll Type
) -> Option<&'ll Value>

pub fn fptosui_may_trap(&self, val: &'ll Value, dest_ty: &'ll Type) -> bool

pub fn fptoui(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn fptosi(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn uitofp(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn sitofp(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn fptrunc(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn fpext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn ptrtoint(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn inttoptr(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn bitcast(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn intcast(
    &mut self,
    val: &'ll Value,
    dest_ty: &'ll Type,
    is_signed: bool
) -> &'ll Value

pub fn pointercast(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn icmp(
    &mut self,
    op: IntPredicate,
    lhs: &'ll Value,
    rhs: &'ll Value
) -> &'ll Value

pub fn fcmp(
    &mut self,
    op: RealPredicate,
    lhs: &'ll Value,
    rhs: &'ll Value
) -> &'ll Value

pub fn memcpy(
    &mut self,
    dst: &'ll Value,
    dst_align: Align,
    src: &'ll Value,
    src_align: Align,
    size: &'ll Value,
    flags: MemFlags
)

pub fn memmove(
    &mut self,
    dst: &'ll Value,
    dst_align: Align,
    src: &'ll Value,
    src_align: Align,
    size: &'ll Value,
    flags: MemFlags
)

pub fn memset(
    &mut self,
    ptr: &'ll Value,
    fill_byte: &'ll Value,
    size: &'ll Value,
    align: Align,
    flags: MemFlags
)

pub fn select(
    &mut self,
    cond: &'ll Value,
    then_val: &'ll Value,
    else_val: &'ll Value
) -> &'ll Value

pub fn va_arg(&mut self, list: &'ll Value, ty: &'ll Type) -> &'ll Value

pub fn extract_element(
    &mut self,
    vec: &'ll Value,
    idx: &'ll Value
) -> &'ll Value

pub fn vector_splat(&mut self, num_elts: usize, elt: &'ll Value) -> &'ll Value

pub fn extract_value(&mut self, agg_val: &'ll Value, idx: u64) -> &'ll Value

pub fn insert_value(
    &mut self,
    agg_val: &'ll Value,
    elt: &'ll Value,
    idx: u64
) -> &'ll Value

pub fn landing_pad(
    &mut self,
    ty: &'ll Type,
    pers_fn: &'ll Value,
    num_clauses: usize
) -> &'ll Value

pub fn set_cleanup(&mut self, landing_pad: &'ll Value)

pub fn resume(&mut self, exn: &'ll Value) -> &'ll Value

pub fn cleanup_pad(
    &mut self,
    parent: Option<&'ll Value>,
    args: &[&'ll Value]
) -> Funclet<'ll>

pub fn cleanup_ret(
    &mut self,
    funclet: &Funclet<'ll>,
    unwind: Option<&'ll BasicBlock>
) -> &'ll Value

pub fn catch_pad(
    &mut self,
    parent: &'ll Value,
    args: &[&'ll Value]
) -> Funclet<'ll>

pub fn catch_switch(
    &mut self,
    parent: Option<&'ll Value>,
    unwind: Option<&'ll BasicBlock>,
    num_handlers: usize
) -> &'ll Value

pub fn add_handler(
    &mut self,
    catch_switch: &'ll Value,
    handler: &'ll BasicBlock
)

pub fn set_personality_fn(&mut self, personality: &'ll Value)

pub fn atomic_cmpxchg(
    &mut self,
    dst: &'ll Value,
    cmp: &'ll Value,
    src: &'ll Value,
    order: AtomicOrdering,
    failure_order: AtomicOrdering,
    weak: bool
) -> &'ll Value

pub fn atomic_rmw(
    &mut self,
    op: AtomicRmwBinOp,
    dst: &'ll Value,
    src: &'ll Value,
    order: AtomicOrdering
) -> &'ll Value

pub fn atomic_fence(
    &mut self,
    order: AtomicOrdering,
    scope: SynchronizationScope
)

pub fn set_invariant_load(&mut self, load: &'ll Value)

pub fn lifetime_start(&mut self, ptr: &'ll Value, size: Size)

Called for StorageLive

pub fn lifetime_end(&mut self, ptr: &'ll Value, size: Size)

Called for StorageDead

pub fn instrprof_increment(
    &mut self,
    fn_name: &'ll Value,
    hash: &'ll Value,
    num_counters: &'ll Value,
    index: &'ll Value
)

pub fn call(
    &mut self,
    llfn: &'ll Value,
    args: &[&'ll Value],
    funclet: Option<&Funclet<'ll>>
) -> &'ll Value

pub fn zext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value

pub fn cx(&self) -> &CodegenCx<'ll, 'tcx>

pub unsafe fn delete_basic_block(&mut self, bb: &'ll BasicBlock)

pub fn do_not_inline(&mut self, llret: &'ll Value)

pub fn to_immediate(
    &mut self,
    val: Self::Value,
    layout: TyAndLayout<'_, &TyS<'_>>
) -> Self::Value

impl<'tcx, 'a, 'll> CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx>

pub fn create_pgo_func_name_var(&self, instance: Instance<'tcx>) -> Self::Value

Calls llvm::createPGOFuncNameVar() with the given function instance's mangled function name. The LLVM API returns an llvm::GlobalVariable containing the function name, with the specific variable name and linkage required by LLVM InstrProf source-based coverage instrumentation.

pub fn set_function_source_hash(
    &mut self,
    instance: Instance<'tcx>,
    function_source_hash: u64
) -> bool

Returns true if the function source hash was added to the coverage map (even if it had already been added, for this instance). Returns false only if -Z instrument-coverage is not enabled (a coverage map is not being generated).

pub fn add_coverage_counter(
    &mut self,
    instance: Instance<'tcx>,
    id: CounterValueReference,
    region: CodeRegion
) -> bool

Returns true if the counter was added to the coverage map; false if -Z instrument-coverage is not enabled (a coverage map is not being generated).

pub fn add_coverage_counter_expression(
    &mut self,
    instance: Instance<'tcx>,
    id: InjectedExpressionId,
    lhs: ExpressionOperandId,
    op: Op,
    rhs: ExpressionOperandId,
    region: Option<CodeRegion>
) -> bool

Returns true if the expression was added to the coverage map; false if -Z instrument-coverage is not enabled (a coverage map is not being generated).

pub fn add_coverage_unreachable(
    &mut self,
    instance: Instance<'tcx>,
    region: CodeRegion
) -> bool

Returns true if the region was added to the coverage map; false if -Z instrument-coverage is not enabled (a coverage map is not being generated).

impl<'a, 'll, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'll, 'tcx>

pub fn dbg_var_addr(
    &mut self,
    dbg_var: &'ll DIVariable,
    dbg_loc: &'ll DILocation,
    variable_alloca: Self::Value,
    direct_offset: Size,
    indirect_offsets: &[Size]
)

pub fn set_dbg_loc(&mut self, dbg_loc: &'ll DILocation)

pub fn insert_reference_to_gdb_debug_scripts_section_global(&mut self)

pub fn set_var_name(&mut self, value: &'ll Value, name: &str)

impl<'_, 'll, 'tcx> Deref for Builder<'_, 'll, 'tcx>

type Target = CodegenCx<'ll, 'tcx>

The resulting type after dereferencing.

pub fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, 'll, 'tcx> Drop for Builder<'a, 'll, 'tcx>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<'tcx, '_, 'll> HasCodegen<'tcx> for Builder<'_, 'll, 'tcx>

type CodegenCx = CodegenCx<'ll, 'tcx>

impl<'_, '_, '_> HasDataLayout for Builder<'_, '_, '_>

pub fn data_layout(&self) -> &TargetDataLayout

impl<'tcx, '_, '_> HasParamEnv<'tcx> for Builder<'_, '_, 'tcx>

pub fn param_env(&self) -> ParamEnv<'tcx>

impl<'_, '_, 'tcx> HasTargetSpec for Builder<'_, '_, 'tcx>

pub fn target_spec(&self) -> &Target

impl<'tcx, '_, '_> HasTyCtxt<'tcx> for Builder<'_, '_, 'tcx>

pub fn tcx(&self) -> TyCtxt<'tcx>

impl<'tcx, 'a, 'll> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx>

pub fn codegen_intrinsic_call(
    &mut self,
    instance: Instance<'tcx>,
    fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
    args: &[OperandRef<'tcx, &'ll Value>],
    llresult: &'ll Value,
    span: Span
)

Remember to add all intrinsics here, in compiler/rustc_typeck/src/check/mod.rs, and in library/core/src/intrinsics.rs; if you need access to any LLVM intrinsics, add them to compiler/rustc_codegen_llvm/src/context.rs.

pub fn abort(&mut self)

pub fn assume(&mut self, val: Self::Value)

pub fn expect(&mut self, cond: Self::Value, expected: bool) -> Self::Value

pub fn sideeffect(&mut self, unconditional: bool)

Normally, sideeffect is only emitted if -Zinsert-sideeffect is passed; in some cases though we want to emit it regardless.

pub fn va_start(&mut self, va_list: &'ll Value) -> &'ll Value

Trait method used to inject va_start on the "spoofed" VaListImpl in Rust defined C-variadic functions.

pub fn va_end(&mut self, va_list: &'ll Value) -> &'ll Value

Trait method used to inject va_end on the "spoofed" VaListImpl before Rust defined C-variadic functions return.

impl<'_, '_, 'tcx> LayoutOf for Builder<'_, '_, 'tcx>

type Ty = Ty<'tcx>

type TyAndLayout = TyAndLayout<'tcx>

pub fn layout_of(&self, ty: Ty<'tcx>) -> Self::TyAndLayout

pub fn spanned_layout_of(&self, ty: Self::Ty, _span: Span) -> Self::TyAndLayout

impl<'a, 'll, 'tcx> StaticBuilderMethods for Builder<'a, 'll, 'tcx>

pub fn get_static(&mut self, def_id: DefId) -> &'ll Value