Support tail calls in mir via TerminatorKind::TailCall

compiler/rustc_borrowck/src/lib.rs

@@ -728,6 +728,12 @@ impl<'a, 'mir, 'tcx, R> rustc_mir_dataflow::ResultsVisitor<'mir, 'tcx, R>
  }
  self.mutate_place(loc, (*destination, span), Deep, flow_state);
  }
+ TerminatorKind::TailCall { func, args, fn_span: _ } => {
+ self.consume_operand(loc, (func, span), flow_state);
+ for arg in args {
+ self.consume_operand(loc, (&arg.node, arg.span), flow_state);
+ }
+ }
  TerminatorKind::Assert { cond, expected: _, msg, target: _, unwind: _ } => {
  self.consume_operand(loc, (cond, span), flow_state);
  if let AssertKind::BoundsCheck { len, index } = &**msg {
@@ -814,9 +820,8 @@ impl<'a, 'mir, 'tcx, R> rustc_mir_dataflow::ResultsVisitor<'mir, 'tcx, R>
 
  TerminatorKind::UnwindResume
  | TerminatorKind::Return
+ | TerminatorKind::TailCall { .. }
  | TerminatorKind::CoroutineDrop => {
- // Returning from the function implicitly kills storage for all locals and statics.
- // Often, the storage will already have been killed by an explicit
  // StorageDead, but we don't always emit those (notably on unwind paths),
  // so this "extra check" serves as a kind of backup.
  let borrow_set = self.borrow_set.clone();

compiler/rustc_borrowck/src/polonius/loan_invalidations.rs

@@ -125,6 +125,12 @@ impl<'cx, 'tcx> Visitor<'tcx> for LoanInvalidationsGenerator<'cx, 'tcx> {
  }
  self.mutate_place(location, *destination, Deep);
  }
+ TerminatorKind::TailCall { func, args, .. } => {
+ self.consume_operand(location, func);
+ for arg in args {
+ self.consume_operand(location, &arg.node);
+ }
+ }
  TerminatorKind::Assert { cond, expected: _, msg, target: _, unwind: _ } => {
  self.consume_operand(location, cond);
  use rustc_middle::mir::AssertKind;

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1352,7 +1352,14 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  }
  // FIXME: check the values
  }
- TerminatorKind::Call { func, args, destination, call_source, target, .. } => {
+ TerminatorKind::Call { func, args, .. }
+ | TerminatorKind::TailCall { func, args, .. } => {
+ let call_source = match term.kind {
+ TerminatorKind::Call { call_source, .. } => call_source,
+ TerminatorKind::TailCall { .. } => CallSource::Normal,
+ _ => unreachable!(),
+ };
+
  self.check_operand(func, term_location);
  for arg in args {
  self.check_operand(&arg.node, term_location);
@@ -1425,7 +1432,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  );
  }
 
- self.check_call_dest(body, term, &sig, *destination, *target, term_location);
+ if let TerminatorKind::Call { destination, target, .. } = term.kind {
+ self.check_call_dest(body, term, &sig, destination, target, term_location);
+ }
 
  // The ordinary liveness rules will ensure that all
  // regions in the type of the callee are live here. We
@@ -1443,7 +1452,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  .add_location(region_vid, term_location);
  }
 
- self.check_call_inputs(body, term, func, &sig, args, term_location, *call_source);
+ self.check_call_inputs(body, term, func, &sig, args, term_location, call_source);
  }
  TerminatorKind::Assert { cond, msg, .. } => {
  self.check_operand(cond, term_location);
@@ -1675,6 +1684,11 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
  span_mirbug!(self, block_data, "return on cleanup block")
  }
  }
+ TerminatorKind::TailCall { .. } => {
+ if is_cleanup {
+ span_mirbug!(self, block_data, "tailcall on cleanup block")
+ }
+ }
  TerminatorKind::CoroutineDrop { .. } => {
  if is_cleanup {
  span_mirbug!(self, block_data, "coroutine_drop in cleanup block")

compiler/rustc_codegen_cranelift/src/base.rs

@@ -491,6 +491,11 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
  )
  });
  }
+ // FIXME(explicit_tail_calls): add support for tail calls to the cranelift backend, once cranelift supports tail calls
+ TerminatorKind::TailCall { fn_span, .. } => span_bug!(
+ *fn_span,
+ "tail calls are not yet supported in `rustc_codegen_cranelift` backend"
+ ),
  TerminatorKind::InlineAsm {
  template,
  operands,

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -565,6 +565,7 @@ pub(crate) fn mir_operand_get_const_val<'tcx>(
  {
  return None;
  }
+ TerminatorKind::TailCall { .. } => return None,
  TerminatorKind::Call { .. } => {}
  }
  }

compiler/rustc_codegen_ssa/src/mir/analyze.rs

@@ -281,6 +281,7 @@ pub fn cleanup_kinds(mir: &mir::Body<'_>) -> IndexVec<mir::BasicBlock, CleanupKi
  | TerminatorKind::UnwindResume
  | TerminatorKind::UnwindTerminate(_)
  | TerminatorKind::Return
+ | TerminatorKind::TailCall { .. }
  | TerminatorKind::CoroutineDrop
  | TerminatorKind::Unreachable
  | TerminatorKind::SwitchInt { .. }

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1389,6 +1389,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  fn_span,
  mergeable_succ(),
  ),
+ mir::TerminatorKind::TailCall { .. } => {
+ // FIXME(explicit_tail_calls): implement tail calls in ssa backend
+ span_bug!(
+ terminator.source_info.span,
+ "`TailCall` terminator is not yet supported by `rustc_codegen_ssa`"
+ )
+ }
  mir::TerminatorKind::CoroutineDrop | mir::TerminatorKind::Yield { .. } => {
  bug!("coroutine ops in codegen")
  }

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -135,6 +135,8 @@ impl<'mir, 'tcx> Qualifs<'mir, 'tcx> {
  ccx: &'mir ConstCx<'mir, 'tcx>,
  tainted_by_errors: Option<ErrorGuaranteed>,
  ) -> ConstQualifs {
+ // FIXME(explicit_tail_calls): uhhhh I think we can return without return now, does it change anything
+
  // Find the `Return` terminator if one exists.
  //
  // If no `Return` terminator exists, this MIR is divergent. Just return the conservative
@@ -711,7 +713,14 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  self.super_terminator(terminator, location);
 
  match &terminator.kind {
- TerminatorKind::Call { func, args, fn_span, call_source, .. } => {
+ TerminatorKind::Call { func, args, fn_span, .. }
+ | TerminatorKind::TailCall { func, args, fn_span, .. } => {
+ let call_source = match terminator.kind {
+ TerminatorKind::Call { call_source, .. } => call_source,
+ TerminatorKind::TailCall { .. } => CallSource::Normal,
+ _ => unreachable!(),
+ };
+
  let ConstCx { tcx, body, param_env, .. } = *self.ccx;
  let caller = self.def_id();
 
@@ -783,7 +792,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  callee,
  args: fn_args,
  span: *fn_span,
- call_source: *call_source,
+ call_source,
  feature: Some(if tcx.features().const_trait_impl {
  sym::effects
  } else {
@@ -830,7 +839,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  callee,
  args: fn_args,
  span: *fn_span,
- call_source: *call_source,
+ call_source,
  feature: None,
  });
  return;

compiler/rustc_const_eval/src/check_consts/post_drop_elaboration.rs

@@ -108,6 +108,7 @@ impl<'tcx> Visitor<'tcx> for CheckLiveDrops<'_, 'tcx> {
 
  mir::TerminatorKind::UnwindTerminate(_)
  | mir::TerminatorKind::Call { .. }
+ | mir::TerminatorKind::TailCall { .. }
  | mir::TerminatorKind::Assert { .. }
  | mir::TerminatorKind::FalseEdge { .. }
  | mir::TerminatorKind::FalseUnwind { .. }