Update Cranelift for basic blocks

Author: bjorn3

Cargo.lock

@@ -288,13 +288,13 @@ fn local_place<'tcx>(
     fx.local_map[&local]
 }
 
-pub fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_ebb: Ebb) {
+pub fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_block: Block) {
     let ssa_analyzed = crate::analyze::analyze(fx);
 
     #[cfg(debug_assertions)]
     self::comments::add_args_header_comment(fx);
 
-    self::returning::codegen_return_param(fx, &ssa_analyzed, start_ebb);
+    self::returning::codegen_return_param(fx, &ssa_analyzed, start_block);
 
     // None means pass_mode == NoPass
     enum ArgKind<'tcx> {
@@ -322,13 +322,13 @@ pub fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_ebb:
 
                 let mut params = Vec::new();
                 for (i, arg_ty) in tupled_arg_tys.types().enumerate() {
-                    let param = cvalue_for_param(fx, start_ebb, Some(local), Some(i), arg_ty);
+                    let param = cvalue_for_param(fx, start_block, Some(local), Some(i), arg_ty);
                     params.push(param);
                 }
 
                 (local, ArgKind::Spread(params), arg_ty)
             } else {
-                let param = cvalue_for_param(fx, start_ebb, Some(local), None, arg_ty);
+                let param = cvalue_for_param(fx, start_block, Some(local), None, arg_ty);
                 (local, ArgKind::Normal(param), arg_ty)
             }
         })
@@ -337,10 +337,10 @@ pub fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_ebb:
     assert!(fx.caller_location.is_none());
     if fx.instance.def.requires_caller_location(fx.tcx) {
         // Store caller location for `#[track_caller]`.
-        fx.caller_location = Some(cvalue_for_param(fx, start_ebb, None, None, fx.tcx.caller_location_ty()).unwrap());
+        fx.caller_location = Some(cvalue_for_param(fx, start_block, None, None, fx.tcx.caller_location_ty()).unwrap());
     }
 
-    fx.bcx.switch_to_block(start_ebb);
+    fx.bcx.switch_to_block(start_block);
     fx.bcx.ins().nop();
 
     #[cfg(debug_assertions)]
@@ -416,7 +416,7 @@ pub fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_ebb:
 
     fx.bcx
         .ins()
-        .jump(*fx.ebb_map.get(START_BLOCK).unwrap(), &[]);
+        .jump(*fx.block_map.get(START_BLOCK).unwrap(), &[]);
 }
 
 pub fn codegen_terminator_call<'tcx>(
@@ -458,8 +458,8 @@ pub fn codegen_terminator_call<'tcx>(
             InstanceDef::DropGlue(_, None) => {
                 // empty drop glue - a nop.
                 let (_, dest) = destination.expect("Non terminating drop_in_place_real???");
-                let ret_ebb = fx.get_ebb(dest);
-                fx.bcx.ins().jump(ret_ebb, &[]);
+                let ret_block = fx.get_block(dest);
+                fx.bcx.ins().jump(ret_block, &[]);
                 return;
             }
             _ => {}
@@ -498,8 +498,8 @@ pub fn codegen_terminator_call<'tcx>(
     );
 
     if let Some((_, dest)) = destination {
-        let ret_ebb = fx.get_ebb(dest);
-        fx.bcx.ins().jump(ret_ebb, &[]);
+        let ret_block = fx.get_block(dest);
+        fx.bcx.ins().jump(ret_block, &[]);
     } else {
         trap_unreachable(fx, "[corruption] Diverging function returned");
     }
@@ -513,7 +513,7 @@ fn codegen_call_inner<'tcx>(
     args: Vec<CValue<'tcx>>,
     ret_place: Option<CPlace<'tcx>>,
 ) {
-    // FIXME mark the current ebb as cold when calling a `#[cold]` function.
+    // FIXME mark the current block as cold when calling a `#[cold]` function.
     let fn_sig = fx
         .tcx
         .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), &fn_ty.fn_sig(fx.tcx));

src/abi/mod.rs

@@ -129,7 +129,7 @@ pub(super) fn adjust_arg_for_abi<'tcx>(
 
 pub(super) fn cvalue_for_param<'tcx>(
     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
-    start_ebb: Ebb,
+    start_block: Block,
     local: Option<mir::Local>,
     local_field: Option<usize>,
     arg_ty: Ty<'tcx>,
@@ -142,29 +142,29 @@ pub(super) fn cvalue_for_param<'tcx>(
     }
 
     let clif_types = pass_mode.get_param_ty(fx.tcx);
-    let ebb_params = clif_types.map(|t| fx.bcx.append_ebb_param(start_ebb, t));
+    let block_params = clif_types.map(|t| fx.bcx.append_block_param(start_block, t));
 
     #[cfg(debug_assertions)]
     crate::abi::comments::add_arg_comment(
         fx,
         "arg",
         local,
         local_field,
-        ebb_params,
+        block_params,
         pass_mode,
         arg_ty,
     );
 
     match pass_mode {
         PassMode::NoPass => unreachable!(),
-        PassMode::ByVal(_) => Some(CValue::by_val(ebb_params.assert_single(), layout)),
+        PassMode::ByVal(_) => Some(CValue::by_val(block_params.assert_single(), layout)),
         PassMode::ByValPair(_, _) => {
-            let (a, b) = ebb_params.assert_pair();
+            let (a, b) = block_params.assert_pair();
             Some(CValue::by_val_pair(a, b, layout))
         }
-        PassMode::ByRef { sized: true } => Some(CValue::by_ref(Pointer::new(ebb_params.assert_single()), layout)),
+        PassMode::ByRef { sized: true } => Some(CValue::by_ref(Pointer::new(block_params.assert_single()), layout)),
         PassMode::ByRef { sized: false } => {
-            let (ptr, meta) = ebb_params.assert_pair();
+            let (ptr, meta) = block_params.assert_pair();
             Some(CValue::by_ref_unsized(Pointer::new(ptr), meta, layout))
         }
     }

src/abi/pass_mode.rs

@@ -16,7 +16,7 @@ pub fn can_return_to_ssa_var<'tcx>(tcx: TyCtxt<'tcx>, dest_layout: TyLayout<'tcx
 pub(super) fn codegen_return_param(
     fx: &mut FunctionCx<impl Backend>,
     ssa_analyzed: &rustc_index::vec::IndexVec<Local, crate::analyze::SsaKind>,
-    start_ebb: Ebb,
+    start_block: Block,
 ) {
     let ret_layout = return_layout(fx);
     let ret_pass_mode = get_pass_mode(fx.tcx, ret_layout);
@@ -34,7 +34,7 @@ pub(super) fn codegen_return_param(
             Empty
         }
         PassMode::ByRef { sized: true } => {
-            let ret_param = fx.bcx.append_ebb_param(start_ebb, fx.pointer_type);
+            let ret_param = fx.bcx.append_block_param(start_block, fx.pointer_type);
             fx.local_map
                 .insert(RETURN_PLACE, CPlace::for_ptr(Pointer::new(ret_param), ret_layout));
 

src/abi/returning.rs

@@ -78,11 +78,11 @@ fn codegen_inner(module: &mut Module<impl Backend + 'static>, kind: AllocatorKin
             let mut func_ctx = FunctionBuilderContext::new();
             let mut bcx = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
 
-            let ebb = bcx.create_ebb();
-            bcx.switch_to_block(ebb);
+            let block = bcx.create_block();
+            bcx.switch_to_block(block);
             let args = arg_tys
                 .into_iter()
-                .map(|ty| bcx.append_ebb_param(ebb, ty))
+                .map(|ty| bcx.append_block_param(block, ty))
                 .collect::<Vec<Value>>();
 
             let callee_func_ref = module.declare_func_in_func(callee_func_id, &mut bcx.func);