Cleanup not needed arguments

Author: 5225225

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -55,6 +55,7 @@ mod simd;
 pub(crate) use cpuid::codegen_cpuid_call;
 pub(crate) use llvm::codegen_llvm_intrinsic_call;
 
+use rustc_const_eval::might_permit_raw_init::might_permit_raw_init;
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::subst::SubstsRef;
 use rustc_span::symbol::{kw, sym, Symbol};
@@ -673,12 +674,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             }
 
             if intrinsic == sym::assert_zero_valid
-                && !rustc_const_eval::might_permit_raw_init::might_permit_raw_init(
-                    fx.tcx,
-                    source_info.span,
-                    layout,
-                    fx.tcx.sess.opts.debugging_opts.strict_init_checks,
-                    InitKind::Zero) {
+                && !might_permit_raw_init(fx.tcx, layout, InitKind::Zero) {
 
                 with_no_trimmed_paths!({
                     crate::base::codegen_panic(
@@ -691,12 +687,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             }
 
             if intrinsic == sym::assert_uninit_valid
-                && !rustc_const_eval::might_permit_raw_init::might_permit_raw_init(
-                    fx.tcx,
-                    source_info.span,
-                    layout,
-                    fx.tcx.sess.opts.debugging_opts.strict_init_checks,
-                    InitKind::Uninit) {
+                && !might_permit_raw_init(fx.tcx, layout, InitKind::Uninit) {
 
                 with_no_trimmed_paths!({
                     crate::base::codegen_panic(

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -528,7 +528,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         source_info: mir::SourceInfo,
         target: Option<mir::BasicBlock>,
         cleanup: Option<mir::BasicBlock>,
-        strict_validity: bool,
     ) -> bool {
         // Emit a panic or a no-op for `assert_*` intrinsics.
         // These are intrinsics that compile to panics so that we can get a message
@@ -553,20 +552,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             let layout = bx.layout_of(ty);
             let do_panic = match intrinsic {
                 Inhabited => layout.abi.is_uninhabited(),
-                ZeroValid => !might_permit_raw_init(
-                    bx.tcx(),
-                    source_info.span,
-                    layout,
-                    strict_validity,
-                    InitKind::Zero,
-                ),
-                UninitValid => !might_permit_raw_init(
-                    bx.tcx(),
-                    source_info.span,
-                    layout,
-                    strict_validity,
-                    InitKind::Uninit,
-                ),
+                ZeroValid => !might_permit_raw_init(bx.tcx(), layout, InitKind::Zero),
+                UninitValid => !might_permit_raw_init(bx.tcx(), layout, InitKind::Uninit),
             };
             if do_panic {
                 let msg_str = with_no_visible_paths!({
@@ -701,7 +688,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             source_info,
             target,
             cleanup,
-            self.cx.tcx().sess.opts.debugging_opts.strict_init_checks,
         ) {
             return;
         }

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -417,13 +417,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 }
 
                 if intrinsic_name == sym::assert_zero_valid {
-                    let should_panic = !might_permit_raw_init(
-                        *self.tcx,
-                        self.cur_span(),
-                        layout,
-                        self.tcx.sess.opts.debugging_opts.strict_init_checks,
-                        InitKind::Zero,
-                    );
+                    let should_panic = !might_permit_raw_init(*self.tcx, layout, InitKind::Zero);
 
                     if should_panic {
                         M::abort(
@@ -437,13 +431,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 }
 
                 if intrinsic_name == sym::assert_uninit_valid {
-                    let should_panic = !might_permit_raw_init(
-                        *self.tcx,
-                        self.cur_span(),
-                        layout,
-                        self.tcx.sess.opts.debugging_opts.strict_init_checks,
-                        InitKind::Uninit,
-                    );
+                    let should_panic = !might_permit_raw_init(*self.tcx, layout, InitKind::Uninit);
 
                     if should_panic {
                         M::abort(

compiler/rustc_const_eval/src/might_permit_raw_init.rs

@@ -3,20 +3,19 @@ use crate::interpret::{InterpCx, MemoryKind, OpTy};
 use rustc_middle::ty::layout::LayoutCx;
 use rustc_middle::ty::{layout::TyAndLayout, ParamEnv, TyCtxt};
 use rustc_session::Limit;
-use rustc_span::Span;
 use rustc_target::abi::InitKind;
 
 pub fn might_permit_raw_init<'tcx>(
     tcx: TyCtxt<'tcx>,
-    root_span: Span,
     ty: TyAndLayout<'tcx>,
-    strict: bool,
     kind: InitKind,
 ) -> bool {
+    let strict = tcx.sess.opts.debugging_opts.strict_init_checks;
+
     if strict {
         let machine = CompileTimeInterpreter::new(Limit::new(0), false);
 
-        let mut cx = InterpCx::new(tcx, root_span, ParamEnv::reveal_all(), machine);
+        let mut cx = InterpCx::new(tcx, rustc_span::DUMMY_SP, ParamEnv::reveal_all(), machine);
 
         // We could panic here... Or we could just return "yeah it's valid whatever". Or let
         // codegen_panic_intrinsic return an error that halts compilation.