//! Codegen of a single function
+use cranelift_codegen::binemit::{NullStackMapSink, NullTrapSink};
use rustc_index::vec::IndexVec;
use rustc_middle::ty::adjustment::PointerCast;
+use rustc_middle::ty::layout::FnAbiExt;
+use rustc_target::abi::call::FnAbi;
+use crate::constant::ConstantCx;
use crate::prelude::*;
pub(crate) fn codegen_fn<'tcx>(
- cx: &mut crate::CodegenCx<'tcx, impl Module>,
+ cx: &mut crate::CodegenCx<'tcx>,
+ module: &mut dyn Module,
instance: Instance<'tcx>,
- linkage: Linkage,
) {
let tcx = cx.tcx;
let mir = tcx.instance_mir(instance.def);
// Declare function
- let (name, sig) = get_function_name_and_sig(tcx, cx.module.isa().triple(), instance, false);
- let func_id = cx.module.declare_function(&name, linkage, &sig).unwrap();
+ let symbol_name = tcx.symbol_name(instance);
+ let sig = get_function_sig(tcx, module.isa().triple(), instance);
+ let func_id = module.declare_function(symbol_name.name, Linkage::Local, &sig).unwrap();
cx.cached_context.clear();
// Predefine blocks
let start_block = bcx.create_block();
- let block_map: IndexVec<BasicBlock, Block> = (0..mir.basic_blocks().len())
- .map(|_| bcx.create_block())
- .collect();
+ let block_map: IndexVec<BasicBlock, Block> =
+ (0..mir.basic_blocks().len()).map(|_| bcx.create_block()).collect();
// Make FunctionCx
- let pointer_type = cx.module.target_config().pointer_type();
+ let pointer_type = module.target_config().pointer_type();
let clif_comments = crate::pretty_clif::CommentWriter::new(tcx, instance);
let mut fx = FunctionCx {
cx,
+ module,
tcx,
pointer_type,
+ vtables: FxHashMap::default(),
+ constants_cx: ConstantCx::new(),
instance,
+ symbol_name,
mir,
+ fn_abi: Some(FnAbi::of_instance(&RevealAllLayoutCx(tcx), instance, &[])),
bcx,
block_map,
local_map: IndexVec::with_capacity(mir.local_decls.len()),
caller_location: None, // set by `codegen_fn_prelude`
- cold_blocks: EntitySet::new(),
clif_comments,
source_info_set: indexmap::IndexSet::new(),
inline_asm_index: 0,
};
- let arg_uninhabited = fx.mir.args_iter().any(|arg| {
- fx.layout_of(fx.monomorphize(&fx.mir.local_decls[arg].ty))
- .abi
- .is_uninhabited()
- });
+ let arg_uninhabited = fx
+ .mir
+ .args_iter()
+ .any(|arg| fx.layout_of(fx.monomorphize(&fx.mir.local_decls[arg].ty)).abi.is_uninhabited());
- if arg_uninhabited {
- fx.bcx
- .append_block_params_for_function_params(fx.block_map[START_BLOCK]);
+ if !crate::constant::check_constants(&mut fx) {
+ fx.bcx.append_block_params_for_function_params(fx.block_map[START_BLOCK]);
+ fx.bcx.switch_to_block(fx.block_map[START_BLOCK]);
+ crate::trap::trap_unreachable(&mut fx, "compilation should have been aborted");
+ } else if arg_uninhabited {
+ fx.bcx.append_block_params_for_function_params(fx.block_map[START_BLOCK]);
fx.bcx.switch_to_block(fx.block_map[START_BLOCK]);
crate::trap::trap_unreachable(&mut fx, "function has uninhabited argument");
} else {
tcx.sess.time("codegen clif ir", || {
- tcx.sess.time("codegen prelude", || {
- crate::abi::codegen_fn_prelude(&mut fx, start_block)
- });
+ tcx.sess
+ .time("codegen prelude", || crate::abi::codegen_fn_prelude(&mut fx, start_block));
codegen_fn_content(&mut fx);
});
}
let mut clif_comments = fx.clif_comments;
let source_info_set = fx.source_info_set;
let local_map = fx.local_map;
- let cold_blocks = fx.cold_blocks;
+
+ fx.constants_cx.finalize(fx.tcx, &mut *fx.module);
// Store function in context
let context = &mut cx.cached_context;
// Perform rust specific optimizations
tcx.sess.time("optimize clif ir", || {
- crate::optimize::optimize_function(
- tcx,
- instance,
- context,
- &cold_blocks,
- &mut clif_comments,
- );
+ crate::optimize::optimize_function(tcx, instance, context, &mut clif_comments);
});
// If the return block is not reachable, then the SSA builder may have inserted an `iconst.i128`
// instruction, which doesn't have an encoding.
context.compute_cfg();
context.compute_domtree();
- context.eliminate_unreachable_code(cx.module.isa()).unwrap();
- context.dce(cx.module.isa()).unwrap();
+ context.eliminate_unreachable_code(module.isa()).unwrap();
+ context.dce(module.isa()).unwrap();
+ // Some Cranelift optimizations expect the domtree to not yet be computed and as such don't
+ // invalidate it when it would change.
+ context.domtree.clear();
context.want_disasm = crate::pretty_clif::should_write_ir(tcx);
// Define function
- let module = &mut cx.module;
tcx.sess.time("define function", || {
module
- .define_function(
- func_id,
- context,
- &mut cranelift_codegen::binemit::NullTrapSink {},
- )
+ .define_function(func_id, context, &mut NullTrapSink {}, &mut NullStackMapSink {})
.unwrap()
});
crate::pretty_clif::write_clif_file(
tcx,
"opt",
- Some(cx.module.isa()),
+ Some(module.isa()),
instance,
&context,
&clif_comments,
);
- if let Some(mach_compile_result) = &context.mach_compile_result {
- if let Some(disasm) = &mach_compile_result.disasm {
- crate::pretty_clif::write_ir_file(
- tcx,
- &format!("{}.vcode", tcx.symbol_name(instance).name),
- |file| file.write_all(disasm.as_bytes()),
- )
- }
+ if let Some(disasm) = &context.mach_compile_result.as_ref().unwrap().disasm {
+ crate::pretty_clif::write_ir_file(
+ tcx,
+ || format!("{}.vcode", tcx.symbol_name(instance).name),
+ |file| file.write_all(disasm.as_bytes()),
+ )
}
// Define debuginfo for function
- let isa = cx.module.isa();
+ let isa = module.isa();
let debug_context = &mut cx.debug_context;
let unwind_context = &mut cx.unwind_context;
tcx.sess.time("generate debug info", || {
debug_context.define_function(
instance,
func_id,
- &name,
+ symbol_name.name,
isa,
context,
&source_info_set,
Some(Box::new(writer)),
err,
);
- tcx.sess
- .fatal(&format!("cranelift verify error:\n{}", pretty_error));
+ tcx.sess.fatal(&format!("cranelift verify error:\n{}", pretty_error));
}
}
});
}
-fn codegen_fn_content(fx: &mut FunctionCx<'_, '_, impl Module>) {
- crate::constant::check_constants(fx);
-
+fn codegen_fn_content(fx: &mut FunctionCx<'_, '_, '_>) {
for (bb, bb_data) in fx.mir.basic_blocks().iter_enumerated() {
let block = fx.get_block(bb);
fx.bcx.switch_to_block(block);
// Unwinding after panicking is not supported
continue;
- // FIXME once unwinding is supported uncomment next lines
- // // Unwinding is unlikely to happen, so mark cleanup block's as cold.
- // fx.cold_blocks.insert(block);
+ // FIXME Once unwinding is supported and Cranelift supports marking blocks as cold, do
+ // so for cleanup blocks.
}
fx.bcx.ins().nop();
codegen_stmt(fx, block, stmt);
}
- #[cfg(debug_assertions)]
- {
+ if fx.clif_comments.enabled() {
let mut terminator_head = "\n".to_string();
- bb_data
- .terminator()
- .kind
- .fmt_head(&mut terminator_head)
- .unwrap();
+ bb_data.terminator().kind.fmt_head(&mut terminator_head).unwrap();
let inst = fx.bcx.func.layout.last_inst(block).unwrap();
fx.add_comment(inst, terminator_head);
}
TerminatorKind::Return => {
crate::abi::codegen_return(fx);
}
- TerminatorKind::Assert {
- cond,
- expected,
- msg,
- target,
- cleanup: _,
- } => {
+ TerminatorKind::Assert { cond, expected, msg, target, cleanup: _ } => {
if !fx.tcx.sess.overflow_checks() {
if let mir::AssertKind::OverflowNeg(_) = *msg {
let target = fx.get_block(*target);
let target = fx.get_block(*target);
let failure = fx.bcx.create_block();
- fx.cold_blocks.insert(failure);
+ // FIXME Mark failure block as cold once Cranelift supports it
if *expected {
fx.bcx.ins().brz(cond, failure, &[]);
}
}
- TerminatorKind::SwitchInt {
- discr,
- switch_ty,
- targets,
- } => {
+ TerminatorKind::SwitchInt { discr, switch_ty, targets } => {
let discr = codegen_operand(fx, discr).load_scalar(fx);
let use_bool_opt = switch_ty.kind() == fx.tcx.types.bool.kind()
from_hir_call: _,
} => {
fx.tcx.sess.time("codegen call", || {
- crate::abi::codegen_terminator_call(
- fx,
- *fn_span,
- block,
- func,
- args,
- *destination,
- )
+ crate::abi::codegen_terminator_call(fx, *fn_span, func, args, *destination)
});
}
TerminatorKind::InlineAsm {
| TerminatorKind::GeneratorDrop => {
bug!("shouldn't exist at codegen {:?}", bb_data.terminator());
}
- TerminatorKind::Drop {
- place,
- target,
- unwind: _,
- } => {
+ TerminatorKind::Drop { place, target, unwind: _ } => {
let drop_place = codegen_place(fx, *place);
crate::abi::codegen_drop(fx, bb_data.terminator().source_info.span, drop_place);
}
fn codegen_stmt<'tcx>(
- fx: &mut FunctionCx<'_, 'tcx, impl Module>,
+ fx: &mut FunctionCx<'_, '_, 'tcx>,
#[allow(unused_variables)] cur_block: Block,
stmt: &Statement<'tcx>,
) {
fx.set_debug_loc(stmt.source_info);
- #[cfg(false_debug_assertions)]
+ #[cfg(disabled)]
match &stmt.kind {
StatementKind::StorageLive(..) | StatementKind::StorageDead(..) => {} // Those are not very useful
_ => {
- let inst = fx.bcx.func.layout.last_inst(cur_block).unwrap();
- fx.add_comment(inst, format!("{:?}", stmt));
+ if fx.clif_comments.enabled() {
+ let inst = fx.bcx.func.layout.last_inst(cur_block).unwrap();
+ fx.add_comment(inst, format!("{:?}", stmt));
+ }
}
}
match &stmt.kind {
- StatementKind::SetDiscriminant {
- place,
- variant_index,
- } => {
+ StatementKind::SetDiscriminant { place, variant_index } => {
let place = codegen_place(fx, **place);
crate::discriminant::codegen_set_discriminant(fx, place, *variant_index);
}
let val = crate::constant::codegen_tls_ref(fx, def_id, lval.layout());
lval.write_cvalue(fx, val);
}
- Rvalue::BinaryOp(bin_op, ref lhs, ref rhs) => {
- let lhs = codegen_operand(fx, lhs);
- let rhs = codegen_operand(fx, rhs);
+ Rvalue::BinaryOp(bin_op, ref lhs_rhs) => {
+ let lhs = codegen_operand(fx, &lhs_rhs.0);
+ let rhs = codegen_operand(fx, &lhs_rhs.1);
let res = crate::num::codegen_binop(fx, bin_op, lhs, rhs);
lval.write_cvalue(fx, res);
}
- Rvalue::CheckedBinaryOp(bin_op, ref lhs, ref rhs) => {
- let lhs = codegen_operand(fx, lhs);
- let rhs = codegen_operand(fx, rhs);
+ Rvalue::CheckedBinaryOp(bin_op, ref lhs_rhs) => {
+ let lhs = codegen_operand(fx, &lhs_rhs.0);
+ let rhs = codegen_operand(fx, &lhs_rhs.1);
let res = if !fx.tcx.sess.overflow_checks() {
let val =
let from_ty = operand.layout().ty;
let to_ty = fx.monomorphize(to_ty);
- fn is_fat_ptr<'tcx>(
- fx: &FunctionCx<'_, 'tcx, impl Module>,
- ty: Ty<'tcx>,
- ) -> bool {
+ fn is_fat_ptr<'tcx>(fx: &FunctionCx<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool {
ty.builtin_deref(true)
- .map(
- |ty::TypeAndMut {
- ty: pointee_ty,
- mutbl: _,
- }| {
- has_ptr_meta(fx.tcx, pointee_ty)
- },
- )
+ .map(|ty::TypeAndMut { ty: pointee_ty, mutbl: _ }| {
+ has_ptr_meta(fx.tcx, pointee_ty)
+ })
.unwrap_or(false)
}
ty::Uint(_) | ty::Int(_) => {}
_ => unreachable!("cast adt {} -> {}", from_ty, to_ty),
}
+ let to_clif_ty = fx.clif_type(to_ty).unwrap();
- use rustc_target::abi::{Int, TagEncoding, Variants};
-
- match operand.layout().variants {
- Variants::Single { index } => {
- let discr = operand
- .layout()
- .ty
- .discriminant_for_variant(fx.tcx, index)
- .unwrap();
- let discr = if discr.ty.is_signed() {
- fx.layout_of(discr.ty).size.sign_extend(discr.val)
- } else {
- discr.val
- };
- let discr = discr.into();
-
- let discr = CValue::const_val(fx, fx.layout_of(to_ty), discr);
- lval.write_cvalue(fx, discr);
- }
- Variants::Multiple {
- ref tag,
- tag_field,
- tag_encoding: TagEncoding::Direct,
- variants: _,
- } => {
- let cast_to = fx.clif_type(dest_layout.ty).unwrap();
-
- // Read the tag/niche-encoded discriminant from memory.
- let encoded_discr =
- operand.value_field(fx, mir::Field::new(tag_field));
- let encoded_discr = encoded_discr.load_scalar(fx);
-
- // Decode the discriminant (specifically if it's niche-encoded).
- let signed = match tag.value {
- Int(_, signed) => signed,
- _ => false,
- };
- let val = clif_intcast(fx, encoded_discr, cast_to, signed);
- let val = CValue::by_val(val, dest_layout);
- lval.write_cvalue(fx, val);
- }
- Variants::Multiple { .. } => unreachable!(),
- }
+ let discriminant = crate::discriminant::codegen_get_discriminant(
+ fx,
+ operand,
+ fx.layout_of(operand.layout().ty.discriminant_ty(fx.tcx)),
+ )
+ .load_scalar(fx);
+
+ let res = crate::cast::clif_intcast(
+ fx,
+ discriminant,
+ to_clif_ty,
+ to_ty.is_signed(),
+ );
+ lval.write_cvalue(fx, CValue::by_val(res, dest_layout));
} else {
let to_clif_ty = fx.clif_type(to_ty).unwrap();
let from = operand.load_scalar(fx);
.val
.try_to_bits(fx.tcx.data_layout.pointer_size)
.unwrap();
- if fx.clif_type(operand.layout().ty) == Some(types::I8) {
+ if operand.layout().size.bytes() == 0 {
+ // Do nothing for ZST's
+ } else if fx.clif_type(operand.layout().ty) == Some(types::I8) {
let times = fx.bcx.ins().iconst(fx.pointer_type, times as i64);
// FIXME use emit_small_memset where possible
let addr = lval.to_ptr().get_addr(fx);
let val = operand.load_scalar(fx);
- fx.bcx
- .call_memset(fx.cx.module.target_config(), addr, val, times);
+ fx.bcx.call_memset(fx.module.target_config(), addr, val, times);
} else {
let loop_block = fx.bcx.create_block();
let loop_block2 = fx.bcx.create_block();
let content_ty = fx.monomorphize(content_ty);
let layout = fx.layout_of(content_ty);
let llsize = fx.bcx.ins().iconst(usize_type, layout.size.bytes() as i64);
- let llalign = fx
- .bcx
- .ins()
- .iconst(usize_type, layout.align.abi.bytes() as i64);
+ let llalign = fx.bcx.ins().iconst(usize_type, layout.align.abi.bytes() as i64);
let box_layout = fx.layout_of(fx.tcx.mk_box(content_ty));
// Allocate space:
- let def_id = match fx
- .tcx
- .lang_items()
- .require(rustc_hir::LangItem::ExchangeMalloc)
- {
- Ok(id) => id,
- Err(s) => {
- fx.tcx
- .sess
- .fatal(&format!("allocation of `{}` {}", box_layout.ty, s));
- }
- };
+ let def_id =
+ match fx.tcx.lang_items().require(rustc_hir::LangItem::ExchangeMalloc) {
+ Ok(id) => id,
+ Err(s) => {
+ fx.tcx
+ .sess
+ .fatal(&format!("allocation of `{}` {}", box_layout.ty, s));
+ }
+ };
let instance = ty::Instance::mono(fx.tcx, def_id).polymorphize(fx.tcx);
let func_ref = fx.get_function_ref(instance);
let call = fx.bcx.ins().call(func_ref, &[llsize, llalign]);
lval.write_cvalue(fx, CValue::by_val(ptr, box_layout));
}
Rvalue::NullaryOp(NullOp::SizeOf, ty) => {
- assert!(lval
- .layout()
- .ty
- .is_sized(fx.tcx.at(stmt.source_info.span), ParamEnv::reveal_all()));
+ assert!(
+ lval.layout()
+ .ty
+ .is_sized(fx.tcx.at(stmt.source_info.span), ParamEnv::reveal_all())
+ );
let ty_size = fx.layout_of(fx.monomorphize(ty)).size.bytes();
let val =
CValue::const_val(fx, fx.layout_of(fx.tcx.types.usize), ty_size.into());
| StatementKind::AscribeUserType(..) => {}
StatementKind::LlvmInlineAsm(asm) => {
- use rustc_span::symbol::Symbol;
- let LlvmInlineAsm {
- asm,
- outputs,
- inputs,
- } = &**asm;
- let rustc_hir::LlvmInlineAsmInner {
- asm: asm_code, // Name
- outputs: output_names, // Vec<LlvmInlineAsmOutput>
- inputs: input_names, // Vec<Name>
- clobbers, // Vec<Name>
- volatile, // bool
- alignstack, // bool
- dialect: _,
- asm_str_style: _,
- } = asm;
- match asm_code.as_str().trim() {
+ match asm.asm.asm.as_str().trim() {
"" => {
// Black box
}
- "mov %rbx, %rsi\n cpuid\n xchg %rbx, %rsi" => {
- assert_eq!(
- input_names,
- &[Symbol::intern("{eax}"), Symbol::intern("{ecx}")]
- );
- assert_eq!(output_names.len(), 4);
- for (i, c) in (&["={eax}", "={esi}", "={ecx}", "={edx}"])
- .iter()
- .enumerate()
- {
- assert_eq!(&output_names[i].constraint.as_str(), c);
- assert!(!output_names[i].is_rw);
- assert!(!output_names[i].is_indirect);
- }
-
- assert_eq!(clobbers, &[]);
-
- assert!(!volatile);
- assert!(!alignstack);
-
- assert_eq!(inputs.len(), 2);
- let leaf = codegen_operand(fx, &inputs[0].1).load_scalar(fx); // %eax
- let subleaf = codegen_operand(fx, &inputs[1].1).load_scalar(fx); // %ecx
-
- let (eax, ebx, ecx, edx) =
- crate::intrinsics::codegen_cpuid_call(fx, leaf, subleaf);
-
- assert_eq!(outputs.len(), 4);
- codegen_place(fx, outputs[0])
- .write_cvalue(fx, CValue::by_val(eax, fx.layout_of(fx.tcx.types.u32)));
- codegen_place(fx, outputs[1])
- .write_cvalue(fx, CValue::by_val(ebx, fx.layout_of(fx.tcx.types.u32)));
- codegen_place(fx, outputs[2])
- .write_cvalue(fx, CValue::by_val(ecx, fx.layout_of(fx.tcx.types.u32)));
- codegen_place(fx, outputs[3])
- .write_cvalue(fx, CValue::by_val(edx, fx.layout_of(fx.tcx.types.u32)));
- }
- "xgetbv" => {
- assert_eq!(input_names, &[Symbol::intern("{ecx}")]);
-
- assert_eq!(output_names.len(), 2);
- for (i, c) in (&["={eax}", "={edx}"]).iter().enumerate() {
- assert_eq!(&output_names[i].constraint.as_str(), c);
- assert!(!output_names[i].is_rw);
- assert!(!output_names[i].is_indirect);
- }
-
- assert_eq!(clobbers, &[]);
-
- assert!(!volatile);
- assert!(!alignstack);
-
- crate::trap::trap_unimplemented(fx, "_xgetbv arch intrinsic is not supported");
- }
- // ___chkstk, ___chkstk_ms and __alloca are only used on Windows
- _ if fx
- .tcx
- .symbol_name(fx.instance)
- .name
- .starts_with("___chkstk") =>
- {
- crate::trap::trap_unimplemented(fx, "Stack probes are not supported");
- }
- _ if fx.tcx.symbol_name(fx.instance).name == "__alloca" => {
- crate::trap::trap_unimplemented(fx, "Alloca is not supported");
- }
- // Used in sys::windows::abort_internal
- "int $$0x29" => {
- crate::trap::trap_unimplemented(fx, "Windows abort");
- }
- _ => fx
- .tcx
- .sess
- .span_fatal(stmt.source_info.span, "Inline assembly is not supported"),
+ _ => fx.tcx.sess.span_fatal(
+ stmt.source_info.span,
+ "Legacy `llvm_asm!` inline assembly is not supported. \
+ Try using the new `asm!` instead.",
+ ),
}
}
StatementKind::Coverage { .. } => fx.tcx.sess.fatal("-Zcoverage is unimplemented"),
+ StatementKind::CopyNonOverlapping(inner) => {
+ let dst = codegen_operand(fx, &inner.dst);
+ let pointee = dst
+ .layout()
+ .pointee_info_at(fx, rustc_target::abi::Size::ZERO)
+ .expect("Expected pointer");
+ let dst = dst.load_scalar(fx);
+ let src = codegen_operand(fx, &inner.src).load_scalar(fx);
+ let count = codegen_operand(fx, &inner.count).load_scalar(fx);
+ let elem_size: u64 = pointee.size.bytes();
+ let bytes =
+ if elem_size != 1 { fx.bcx.ins().imul_imm(count, elem_size as i64) } else { count };
+ fx.bcx.call_memcpy(fx.module.target_config(), dst, src, bytes);
+ }
}
}
-fn codegen_array_len<'tcx>(
- fx: &mut FunctionCx<'_, 'tcx, impl Module>,
- place: CPlace<'tcx>,
-) -> Value {
+fn codegen_array_len<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, place: CPlace<'tcx>) -> Value {
match *place.layout().ty.kind() {
ty::Array(_elem_ty, len) => {
- let len = fx
- .monomorphize(len)
- .eval_usize(fx.tcx, ParamEnv::reveal_all()) as i64;
+ let len = fx.monomorphize(len).eval_usize(fx.tcx, ParamEnv::reveal_all()) as i64;
fx.bcx.ins().iconst(fx.pointer_type, len)
}
- ty::Slice(_elem_ty) => place
- .to_ptr_maybe_unsized()
- .1
- .expect("Length metadata for slice place"),
+ ty::Slice(_elem_ty) => {
+ place.to_ptr_maybe_unsized().1.expect("Length metadata for slice place")
+ }
_ => bug!("Rvalue::Len({:?})", place),
}
}
pub(crate) fn codegen_place<'tcx>(
- fx: &mut FunctionCx<'_, 'tcx, impl Module>,
+ fx: &mut FunctionCx<'_, '_, 'tcx>,
place: Place<'tcx>,
) -> CPlace<'tcx> {
let mut cplace = fx.get_local_place(place.local);
let index = fx.get_local_place(local).to_cvalue(fx).load_scalar(fx);
cplace = cplace.place_index(fx, index);
}
- PlaceElem::ConstantIndex {
- offset,
- min_length: _,
- from_end,
- } => {
+ PlaceElem::ConstantIndex { offset, min_length: _, from_end } => {
let offset: u64 = offset;
let index = if !from_end {
fx.bcx.ins().iconst(fx.pointer_type, offset as i64)
}
pub(crate) fn codegen_operand<'tcx>(
- fx: &mut FunctionCx<'_, 'tcx, impl Module>,
+ fx: &mut FunctionCx<'_, '_, 'tcx>,
operand: &Operand<'tcx>,
) -> CValue<'tcx> {
match operand {
}
}
-pub(crate) fn codegen_panic<'tcx>(
- fx: &mut FunctionCx<'_, 'tcx, impl Module>,
- msg_str: &str,
- span: Span,
-) {
+pub(crate) fn codegen_panic<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, msg_str: &str, span: Span) {
let location = fx.get_caller_location(span).load_scalar(fx);
let msg_ptr = fx.anonymous_str("assert", msg_str);
- let msg_len = fx
- .bcx
- .ins()
- .iconst(fx.pointer_type, i64::try_from(msg_str.len()).unwrap());
+ let msg_len = fx.bcx.ins().iconst(fx.pointer_type, i64::try_from(msg_str.len()).unwrap());
let args = [msg_ptr, msg_len, location];
codegen_panic_inner(fx, rustc_hir::LangItem::Panic, &args, span);
}
pub(crate) fn codegen_panic_inner<'tcx>(
- fx: &mut FunctionCx<'_, 'tcx, impl Module>,
+ fx: &mut FunctionCx<'_, '_, 'tcx>,
lang_item: rustc_hir::LangItem,
args: &[Value],
span: Span,
) {
- let def_id = fx
- .tcx
- .lang_items()
- .require(lang_item)
- .unwrap_or_else(|s| fx.tcx.sess.span_fatal(span, &s));
+ let def_id =
+ fx.tcx.lang_items().require(lang_item).unwrap_or_else(|s| fx.tcx.sess.span_fatal(span, &s));
let instance = Instance::mono(fx.tcx, def_id).polymorphize(fx.tcx);
let symbol_name = fx.tcx.symbol_name(instance).name;
fx.lib_call(
&*symbol_name,
- vec![fx.pointer_type, fx.pointer_type, fx.pointer_type],
+ vec![
+ AbiParam::new(fx.pointer_type),
+ AbiParam::new(fx.pointer_type),
+ AbiParam::new(fx.pointer_type),
+ ],
vec![],
args,
);
projects / rust.git / blobdiff