use crate::prelude::*;
-pub(crate) fn trans_fn<'clif, 'tcx, B: Backend + 'static>(
- cx: &mut crate::CodegenCx<'clif, 'tcx, B>,
+pub(crate) fn trans_fn<'tcx, B: Backend + 'static>(
+ cx: &mut crate::CodegenCx<'tcx, B>,
instance: Instance<'tcx>,
linkage: Linkage,
) {
// 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 mut debug_context = cx
- .debug_context
- .as_mut()
- .map(|debug_context| FunctionDebugContext::new(debug_context, instance, func_id, &name));
// Make FunctionBuilder
let context = &mut cx.cached_context;
let mut fx = FunctionCx {
tcx,
- module: cx.module,
+ module: &mut cx.module,
pointer_type,
instance,
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, true));
+ tcx.sess.time("codegen prelude", || crate::abi::codegen_fn_prelude(&mut fx, start_block));
codegen_fn_content(&mut fx);
});
}
let local_map = fx.local_map;
let cold_blocks = fx.cold_blocks;
- crate::pretty_clif::write_clif_file(cx.tcx, "unopt", instance, &context.func, &clif_comments, None);
+ crate::pretty_clif::write_clif_file(
+ cx.tcx,
+ "unopt",
+ None,
+ instance,
+ &context,
+ &clif_comments,
+ );
// Verify function
verify_func(tcx, &clif_comments, &context.func);
);
// Write optimized function to file for debugging
- {
- let value_ranges = context
- .build_value_labels_ranges(cx.module.isa())
- .expect("value location ranges");
-
- crate::pretty_clif::write_clif_file(
- cx.tcx,
- "opt",
- instance,
- &context.func,
- &clif_comments,
- Some(&value_ranges),
- );
- }
+ crate::pretty_clif::write_clif_file(
+ cx.tcx,
+ "opt",
+ Some(cx.module.isa()),
+ instance,
+ &context,
+ &clif_comments,
+ );
// Define debuginfo for function
let isa = cx.module.isa();
+ let debug_context = &mut cx.debug_context;
let unwind_context = &mut cx.unwind_context;
tcx.sess.time("generate debug info", || {
- debug_context
- .as_mut()
- .map(|x| x.define(context, isa, &source_info_set, local_map));
+ if let Some(debug_context) = debug_context {
+ debug_context.define_function(instance, func_id, &name, isa, context, &source_info_set, local_map);
+ }
unwind_context.add_function(func_id, &context, isa);
});
pub(crate) fn verify_func(tcx: TyCtxt<'_>, writer: &crate::pretty_clif::CommentWriter, func: &Function) {
tcx.sess.time("verify clif ir", || {
- let flags = settings::Flags::new(settings::builder());
- match ::cranelift_codegen::verify_function(&func, &flags) {
+ let flags = cranelift_codegen::settings::Flags::new(cranelift_codegen::settings::builder());
+ match cranelift_codegen::verify_function(&func, &flags) {
Ok(_) => {}
Err(err) => {
tcx.sess.err(&format!("{:?}", err));
- let pretty_error = ::cranelift_codegen::print_errors::pretty_verifier_error(
+ let pretty_error = cranelift_codegen::print_errors::pretty_verifier_error(
&func,
None,
Some(Box::new(writer)),
cleanup: _,
} => {
if !fx.tcx.sess.overflow_checks() {
- if let mir::AssertKind::OverflowNeg = *msg {
+ if let mir::AssertKind::OverflowNeg(_) = *msg {
let target = fx.get_block(*target);
fx.bcx.ins().jump(target, &[]);
continue;
func,
args,
destination,
+ fn_span,
cleanup: _,
from_hir_call: _,
} => {
fx.tcx.sess.time("codegen call", || crate::abi::codegen_terminator_call(
fx,
- bb_data.terminator().source_info.span,
+ *fn_span,
+ block,
func,
args,
*destination,
operands,
options: _,
destination,
+ line_spans: _,
} => {
match template {
&[] => {
// Black box
}
- _ => unimpl_fatal!(fx.tcx, bb_data.terminator().source_info.span, "Inline assembly is not supported"),
+ _ => fx.tcx.sess.span_fatal(bb_data.terminator().source_info.span, "Inline assembly is not supported"),
}
}
TerminatorKind::Resume | TerminatorKind::Abort => {
trap_unreachable(fx, "[corruption] Hit unreachable code.");
}
TerminatorKind::Yield { .. }
- | TerminatorKind::FalseEdges { .. }
+ | TerminatorKind::FalseEdge { .. }
| TerminatorKind::FalseUnwind { .. }
| TerminatorKind::DropAndReplace { .. }
| TerminatorKind::GeneratorDrop => {
bug!("shouldn't exist at trans {:?}", bb_data.terminator());
}
TerminatorKind::Drop {
- location,
+ place,
target,
unwind: _,
} => {
- let drop_place = trans_place(fx, *location);
+ let drop_place = trans_place(fx, *place);
crate::abi::codegen_drop(fx, bb_data.terminator().source_info.span, drop_place);
let target_block = fx.get_block(*target);
cur_block: Block,
stmt: &Statement<'tcx>,
) {
- let _print_guard = PrintOnPanic(|| format!("stmt {:?}", stmt));
+ let _print_guard = crate::PrintOnPanic(|| format!("stmt {:?}", stmt));
fx.set_debug_loc(stmt.source_info);
let place = trans_place(fx, *place);
place.write_place_ref(fx, lval);
}
+ Rvalue::ThreadLocalRef(def_id) => {
+ let val = crate::constant::codegen_tls_ref(fx, *def_id, lval.layout());
+ lval.write_cvalue(fx, val);
+ }
Rvalue::BinaryOp(bin_op, lhs, rhs) => {
let lhs = trans_operand(fx, lhs);
let rhs = trans_operand(fx, rhs);
crate::trap::trap_unimplemented(fx, "_xgetbv arch intrinsic is not supported");
}
- _ => unimpl_fatal!(fx.tcx, stmt.source_info.span, "Inline assembly is not supported"),
+ // ___chkstk, ___chkstk_ms and __alloca are only used on Windows
+ _ if fx.tcx.symbol_name(fx.instance).name.as_str().starts_with("___chkstk") => {
+ crate::trap::trap_unimplemented(fx, "Stack probes are not supported");
+ }
+ _ if fx.tcx.symbol_name(fx.instance).name.as_str() == "__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"),
}
}
}
let mut cplace = fx.get_local_place(place.local);
for elem in place.projection {
- match *elem {
+ match elem {
PlaceElem::Deref => {
cplace = cplace.place_deref(fx);
}