Add option to disable validity invariant generation

Author: 5225225

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -17,6 +17,7 @@ use rustc_middle::ty::subst::SubstsRef;
 use rustc_middle::ty::{Ty, TyCtxt};
 use rustc_span::symbol::{sym, Symbol};
 use rustc_target::abi::{Abi, Align, InitKind, Primitive, Size};
+use rustc_target::spec::SanitizerSet;
 
 use super::{
     util::ensure_monomorphic_enough, CheckInAllocMsg, ImmTy, InterpCx, Machine, OpTy, PlaceTy,
@@ -106,8 +107,20 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
             | ty::Error(_) => ConstValue::from_machine_usize(0u64, &tcx),
         },
         sym::validity_invariants_of => {
+            let msan = tcx.sess.opts.debugging_opts.sanitizer.contains(SanitizerSet::MEMORY);
+            let disable = tcx.sess.opts.debugging_opts.no_validity_invariant_checks;
+
+            let strictness = if disable {
+                validity_invariants_of::InvariantStrictness::Disable
+            } else if msan {
+                validity_invariants_of::InvariantStrictness::All
+            } else {
+                validity_invariants_of::InvariantStrictness::Normal
+            };
+
             ensure_monomorphic_enough(tcx, tp_ty)?;
-            let (data, length) = validity_invariants_of::alloc_validity_invariants_of(tcx, tp_ty);
+            let (data, length) =
+                validity_invariants_of::alloc_validity_invariants_of(tcx, tp_ty, strictness);
             ConstValue::CustomSlice { data, length }
         }
         other => bug!("`{}` is not a zero arg intrinsic", other),

compiler/rustc_const_eval/src/interpret/intrinsics/validity_invariants_of.rs

@@ -32,7 +32,12 @@ fn add_invariants<'tcx>(
     ty: Ty<'tcx>,
     invs: &mut FxHashMap<InvariantKey, WrappingRange>,
     offset: Size,
+    strictness: InvariantStrictness,
 ) {
+    if strictness == InvariantStrictness::Disable {
+        return;
+    }
+
     let x = tcx.layout_of(ParamEnvAnd { param_env: ParamEnv::reveal_all(), value: ty });
 
     if let Ok(layout) = x {
@@ -48,9 +53,12 @@ fn add_invariants<'tcx>(
                 Primitive::Pointer => InvariantSize::Pointer,
             };
 
-            // Pick the first scalar we see, this means NonZeroU8(u8) ends up with only one
-            // invariant, the stricter one.
-            let _: Result<_, _> = invs.try_insert(InvariantKey { offset, size }, valid_range);
+            if !valid_range.is_full_for(value.size(&tcx)) || strictness == InvariantStrictness::All
+            {
+                // Pick the first scalar we see, this means NonZeroU8(u8) ends up with only one
+                // invariant, the stricter one.
+                let _: Result<_, _> = invs.try_insert(InvariantKey { offset, size }, valid_range);
+            }
         }
 
         //dbg!(&ty, &layout);
@@ -71,7 +79,7 @@ fn add_invariants<'tcx>(
                 for idx in 0..*count {
                     let off = offset + *stride * idx;
                     let f = layout.field(&layout_cx, idx as usize);
-                    add_invariants(tcx, f.ty, invs, off);
+                    add_invariants(tcx, f.ty, invs, off, strictness);
                 }
             }
             FieldsShape::Arbitrary { offsets, .. } => {
@@ -82,7 +90,7 @@ fn add_invariants<'tcx>(
                         // &mut [T]
                         // Easy solution is to just not recurse then.
                     } else {
-                        add_invariants(tcx, f.ty, invs, offset + field_offset);
+                        add_invariants(tcx, f.ty, invs, offset + field_offset, strictness);
                     }
                 }
             }
@@ -99,17 +107,25 @@ fn get_layout_of_invariant<'tcx>(tcx: TyCtxt<'tcx>) -> TyAndLayout<'tcx, Ty<'tcx
     layout
 }
 
+#[derive(PartialEq, Clone, Copy, Eq)]
+pub(crate) enum InvariantStrictness {
+    Disable,
+    Normal,
+    All,
+}
+
 /// Directly returns a `ConstAllocation` containing a list of validity invariants of the given type.
 pub(crate) fn alloc_validity_invariants_of<'tcx>(
     tcx: TyCtxt<'tcx>,
     ty: Ty<'tcx>,
+    strictness: InvariantStrictness,
 ) -> (ConstAllocation<'tcx>, usize) {
     let mut invs = FxHashMap::default();
 
     let layout = tcx.data_layout();
     let validity_invariant = get_layout_of_invariant(tcx);
 
-    add_invariants(tcx, ty, &mut invs, Size::ZERO);
+    add_invariants(tcx, ty, &mut invs, Size::ZERO, strictness);
 
     let allocation_size = validity_invariant.layout.size() * invs.len() as u64;
     let mut alloc =

compiler/rustc_session/src/options.rs

@@ -1380,6 +1380,8 @@ options! {
         "run LLVM in non-parallel mode (while keeping codegen-units and ThinLTO)"),
     no_unique_section_names: bool = (false, parse_bool, [TRACKED],
         "do not use unique names for text and data sections when -Z function-sections is used"),
+    no_validity_invariant_checks: bool = (false, parse_bool, [TRACKED],
+        "do not generate any validity invariants in the validity_invariants_of intrinsic"),
     no_profiler_runtime: bool = (false, parse_no_flag, [TRACKED],
         "prevent automatic injection of the profiler_builtins crate"),
     normalize_docs: bool = (false, parse_bool, [TRACKED],

src/test/ui/intrinsics/validity_invariants_of.rs

@@ -1,4 +1,7 @@
 // run-pass
+// revisions: disabled normal sanitized
+// [disabled]compile-flags: -Zno-validity-invariant-checks
+// [sanitized]compile-flags: -Z sanitizer=memory
 #![feature(core_intrinsics, const_intrinsic_validity_invariants_of)]
 
 use std::mem::MaybeUninit;
@@ -20,40 +23,66 @@ fn main() {
 
     invs.sort_by_key(|x| x.offset);
 
-    assert_eq!(&invs, &[
-        Invariant {
-            offset: 0,
-            size: InvariantSize::U16,
-            valid_range_start: 1,
-            valid_range_end: 65535
-        },
-        Invariant {
-            offset: 2,
-            size: InvariantSize::U8,
-            valid_range_start: 0,
-            valid_range_end: 255
-        },
-        Invariant {
-            offset: 3,
-            size: InvariantSize::U8,
-            valid_range_start: 0,
-            valid_range_end: 1
-        },
-    ]);
+    if cfg!(disabled) {
+        assert_eq!(&invs, &[]);
+    } else if cfg!(normal) {
+        assert_eq!(&invs, &[
+            Invariant {
+                offset: 0,
+                size: InvariantSize::U16,
+                valid_range_start: 1,
+                valid_range_end: 65535
+            },
+            Invariant {
+                offset: 3,
+                size: InvariantSize::U8,
+                valid_range_start: 0,
+                valid_range_end: 1
+            },
+        ]);
+    } else {
+        assert!(cfg!(sanitized));
+
+        assert_eq!(&invs, &[
+            Invariant {
+                offset: 0,
+                size: InvariantSize::U16,
+                valid_range_start: 1,
+                valid_range_end: 65535
+            },
+            Invariant {
+                offset: 2,
+                size: InvariantSize::U8,
+                valid_range_start: 0,
+                valid_range_end: 255
+            },
+            Invariant {
+                offset: 3,
+                size: InvariantSize::U8,
+                valid_range_start: 0,
+                valid_range_end: 1
+            },
+        ]);
+    }
+
 
     unsafe {
         let v = MyStruct { a: NonZeroU16::new(1).unwrap(), b: 2, c: true };
         assert!(assert_validity_of(&v as *const _));
     }
 
-    assert_eq!(OPTION_INVARIANTS, &[
-        Invariant {
-            offset: 0,
-            size: InvariantSize::Pointer,
-            valid_range_start: 1,
-            valid_range_end: 0,
-        },
-    ]);
+    if cfg!(sanitized) {
+        assert_eq!(OPTION_INVARIANTS, &[
+            Invariant {
+                offset: 0,
+                size: InvariantSize::Pointer,
+                valid_range_start: 1,
+                valid_range_end: 0,
+            },
+        ]);
+    } else {
+        assert_eq!(OPTION_INVARIANTS, &[]);
+    }
 
 
     unsafe {

src/test/ui/sanitize/memory.rs

@@ -1,7 +1,7 @@
 // needs-sanitizer-support
 // needs-sanitizer-memory
 //
-// compile-flags: -Z sanitizer=memory -Zsanitizer-memory-track-origins -O
+// compile-flags: -Z sanitizer=memory -Zno-validity-invariant-checks -Zsanitizer-memory-track-origins -O
 //
 // run-fail
 // error-pattern: MemorySanitizer: use-of-uninitialized-value
@@ -10,6 +10,8 @@
 //
 // This test case intentionally limits the usage of the std,
 // since it will be linked with an uninstrumented version of it.
+//
+// -Zno-validity-invariant-checks is needed in order to not fail inside the assume_init
 
 #![feature(core_intrinsics)]
 #![feature(start)]