move intrinsic handling to misc to reuse code, refactoring 2/2

Author: xacrimon

compiler/rustc_mir_build/src/builder/matches/test.rs

@@ -22,6 +22,7 @@ use tracing::{debug, instrument};
 
 use crate::builder::matches::util::Range;
 use crate::builder::matches::{Candidate, MatchPairTree, Test, TestBranch, TestCase, TestKind};
+use crate::builder::misc::SpannedCallOperandsExt;
 use crate::builder::{BlockAnd, BlockAndExtension, Builder, PlaceBuilder};
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
@@ -311,73 +312,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
-    fn intrinsic_offset(
-        &mut self,
-        block: BasicBlock,
-        ptr: Operand<'tcx>,
-        offset: Operand<'tcx>,
-        span: Span,
-    ) -> BlockAnd<Place<'tcx>> {
-        let tcx = self.tcx;
-        let source_info = self.source_info(span);
-        let ptr_ty = ptr.ty(&self.local_decls, tcx);
-        let pointee_ty = ptr_ty.pointee();
-        let func = Operand::function_handle(
-            tcx,
-            tcx.require_lang_item(LangItem::Offset, Some(span)),
-            [pointee_ty.into()],
-            span,
-        );
-
-        let out = self.temp(ptr_ty, span);
-        let next_block = self.cfg.start_new_block();
-        self.cfg.terminate(block, source_info, TerminatorKind::Call {
-            func,
-            args: [Spanned { node: ptr, span }, Spanned { node: offset, span }].into(),
-            destination: out,
-            target: Some(next_block),
-            unwind: UnwindAction::Continue,
-            call_source: CallSource::Misc,
-            fn_span: span,
-        });
-
-        next_block.and(out)
-    }
-
-    fn intrinsic_aggregate_raw_ptr(
-        &mut self,
-        block: BasicBlock,
-        ptr: Operand<'tcx>,
-        data: Operand<'tcx>,
-        span: Span,
-    ) -> BlockAnd<Place<'tcx>> {
-        let tcx = self.tcx;
-        let source_info = self.source_info(span);
-        let ptr_ty = ptr.ty(&self.local_decls, tcx);
-        let pointee_ty = ptr_ty.pointee();
-        let func = Operand::function_handle(
-            tcx,
-            tcx.require_lang_item(LangItem::AggregateRawPtr, Some(span)),
-            [pointee_ty.into()],
-            span,
-        );
-
-        let aggregate_ptr_ty = Ty::new_ptr(tcx, Ty::new_slice(tcx, pointee_ty), Mutability::Not);
-        let out = self.temp(aggregate_ptr_ty, span);
-        let next_block = self.cfg.start_new_block();
-        self.cfg.terminate(block, source_info, TerminatorKind::Call {
-            func,
-            args: [Spanned { node: ptr, span }, Spanned { node: data, span }].into(),
-            destination: out,
-            target: Some(next_block),
-            unwind: UnwindAction::Continue,
-            call_source: CallSource::Misc,
-            fn_span: span,
-        });
-
-        next_block.and(out)
-    }
-
     fn subslice_sized_range(
         &mut self,
         mut block: BasicBlock,
@@ -431,21 +365,35 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             Rvalue::Cast(CastKind::PtrToPtr, Operand::Copy(temp_source_ptr), elem_ptr_ty),
         );
 
-        let updated_ptr = unpack!(
-            block = self.intrinsic_offset(block, Operand::Copy(temp_elem_ptr), ptr_offset, span)
+        let updated_ptr = self.temp(elem_ptr_ty, span);
+
+        unpack!(
+            block = self.call_intrinsic(
+                block,
+                span,
+                LangItem::Offset,
+                &[elem_ty],
+                span.args([Operand::Copy(temp_elem_ptr), ptr_offset]),
+                updated_ptr
+            )
         );
+
         let slice_len = self.literal_operand(span, slice_len);
+        let slice_ptr_ty = Ty::new_imm_ptr(tcx, Ty::new_slice(tcx, elem_ty));
+        let subslice_ptr = self.temp(slice_ptr_ty, span);
 
-        let subslice_ptr = unpack!(
-            block = self.intrinsic_aggregate_raw_ptr(
+        unpack!(
+            block = self.call_intrinsic(
                 block,
-                Operand::Copy(updated_ptr),
-                slice_len,
-                span
+                span,
+                LangItem::AggregateRawPtr,
+                &[elem_ty],
+                span.args([Operand::Copy(updated_ptr), slice_len]),
+                subslice_ptr
             )
         );
-        let out = PlaceBuilder::from(subslice_ptr).project(PlaceElem::Deref).to_place(self);
 
+        let out = PlaceBuilder::from(subslice_ptr).project(PlaceElem::Deref).to_place(self);
         block.and(out)
     }
 

compiler/rustc_mir_build/src/builder/misc.rs

@@ -1,12 +1,15 @@
 //! Miscellaneous builder routines that are not specific to building any particular
 //! kind of thing.
 
+use rustc_hir::LangItem;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Span;
+use rustc_span::source_map::Spanned;
 use rustc_trait_selection::infer::InferCtxtExt;
 use tracing::debug;
 
+use super::{BlockAnd, BlockAndExtension};
 use crate::builder::Builder;
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
@@ -62,4 +65,46 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             Operand::Move(place)
         }
     }
+
+    pub(crate) fn call_intrinsic(
+        &mut self,
+        block: BasicBlock,
+        span: Span,
+        intrinsic: LangItem,
+        type_args: &[Ty<'tcx>],
+        args: Box<[Spanned<Operand<'tcx>>]>,
+        output: Place<'tcx>,
+    ) -> BlockAnd<()> {
+        let tcx = self.tcx;
+        let source_info = self.source_info(span);
+        let func = Operand::function_handle(
+            tcx,
+            tcx.require_lang_item(intrinsic, Some(span)),
+            type_args.iter().copied().map(Into::into),
+            span,
+        );
+
+        let next_block = self.cfg.start_new_block();
+        self.cfg.terminate(block, source_info, TerminatorKind::Call {
+            func,
+            args,
+            destination: output,
+            target: Some(next_block),
+            unwind: UnwindAction::Continue,
+            call_source: CallSource::Misc,
+            fn_span: span,
+        });
+
+        next_block.unit()
+    }
+}
+
+pub(crate) trait SpannedCallOperandsExt<'tcx> {
+    fn args(&self, list: impl IntoIterator<Item = Operand<'tcx>>) -> Box<[Spanned<Operand<'tcx>>]>;
+}
+
+impl<'tcx> SpannedCallOperandsExt<'tcx> for Span {
+    fn args(&self, list: impl IntoIterator<Item = Operand<'tcx>>) -> Box<[Spanned<Operand<'tcx>>]> {
+        list.into_iter().map(move |arg| Spanned { node: arg, span: *self }).collect()
+    }
 }