Move shared code to rustc_sanitizers crate and reorg tests

Author: 1c3t3a

Cargo.lock

@@ -4731,6 +4731,7 @@ name = "rustc_sanitizers"
 version = "0.0.0"
 dependencies = [
  "bitflags",
+ "libc",
  "rustc_abi",
  "rustc_data_structures",
  "rustc_hir",

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -7,6 +7,7 @@ use rustc_middle::middle::codegen_fn_attrs::{
     TargetFeature,
 };
 use rustc_middle::ty::{self, Instance, TyCtxt};
+use rustc_sanitizers::ignorelist::SanitizerIgnoreList;
 use rustc_session::config::{
     BranchProtection, FunctionReturn, InstrumentMcount, InstrumentMcountOpts, OptLevel, PAuthKey,
     PacRet,
@@ -476,7 +477,7 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
     llfn: &'ll Value,
     codegen_fn_attrs: &CodegenFnAttrs,
     instance: Option<ty::Instance<'tcx>>,
-    sanitizer_ignorelist: Option<&crate::llvm::SanitizerIgnoreList>,
+    sanitizer_ignorelist: Option<&SanitizerIgnoreList>,
 ) {
     let sess = tcx.sess;
     let mut to_add = SmallVec::<[_; 16]>::new();
@@ -541,59 +542,12 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         let mut enabled = tcx.sess.sanitizers() - codegen_fn_attrs.sanitizers.disabled;
         if let Some(ignorelist) = sanitizer_ignorelist {
             if let Some(instance) = instance {
-                let sym_name = tcx.symbol_name(instance).name;
-                let span = tcx.def_span(instance.def_id());
-                let source_map = tcx.sess.source_map();
-                let filename =
-                    source_map.span_to_filename(span).prefer_local_unconditionally().to_string();
-
-                let mainfile = tcx
-                    .sess
-                    .local_crate_source_file()
-                    .and_then(|path| path.local_path().map(|p| p.display().to_string()))
-                    .unwrap_or_default();
-
-                let demangled = rustc_middle::ty::print::with_no_trimmed_paths!(
-                    tcx.def_path_str(instance.def_id())
-                );
-                let is_ignored = |section: &std::ffi::CStr| -> bool {
-                    ignorelist.contains_prefix(section, c"fun", sym_name)
-                        || ignorelist.contains_prefix(section, c"fun", &demangled)
-                        || ignorelist.contains_prefix(section, c"src", &filename)
-                        || (!mainfile.is_empty()
-                            && ignorelist.contains_prefix(section, c"mainfile", &mainfile))
-                };
-
-                let ignore_address = is_ignored(c"address");
-                let ignore_kernel_address = ignore_address || is_ignored(c"kernel-address");
-                let ignore_hwaddress = is_ignored(c"hwaddress");
-                let ignore_kernel_hwaddress = ignore_hwaddress || is_ignored(c"kernel-hwaddress");
-
-                if enabled.contains(SanitizerSet::ADDRESS) && ignore_address {
-                    enabled.remove(SanitizerSet::ADDRESS);
-                }
-                if enabled.contains(SanitizerSet::KERNELADDRESS) && ignore_kernel_address {
-                    enabled.remove(SanitizerSet::KERNELADDRESS);
-                }
-                if enabled.contains(SanitizerSet::MEMORY) && is_ignored(c"memory") {
-                    enabled.remove(SanitizerSet::MEMORY);
-                }
-                if enabled.contains(SanitizerSet::THREAD) && is_ignored(c"thread") {
-                    enabled.remove(SanitizerSet::THREAD);
-                }
-                if enabled.contains(SanitizerSet::HWADDRESS) && ignore_hwaddress {
-                    enabled.remove(SanitizerSet::HWADDRESS);
-                }
-                if enabled.contains(SanitizerSet::KERNELHWADDRESS) && ignore_kernel_hwaddress {
-                    enabled.remove(SanitizerSet::KERNELHWADDRESS);
-                }
-                if enabled.contains(SanitizerSet::SAFESTACK) && is_ignored(c"safestack") {
-                    enabled.remove(SanitizerSet::SAFESTACK);
-                }
-                if is_ignored(c"cfi") {
+                let result = ignorelist.filter_instance_sanitizers(tcx, instance, enabled);
+                enabled = result.enabled;
+                if result.ignore_cfi {
                     to_add.push(llvm::CreateAttrString(cx.llcx, "no-sanitize-cfi"));
                 }
-                if is_ignored(c"kcfi") {
+                if result.ignore_kcfi {
                     to_add.push(llvm::CreateAttrString(cx.llcx, "no-sanitize-kcfi"));
                 }
             }

compiler/rustc_codegen_llvm/src/base.rs

@@ -129,7 +129,12 @@ pub(crate) fn compile_codegen_unit(
             if let Some(entry) =
                 maybe_create_entry_wrapper::<Builder<'_, '_, '_>>(&cx, cx.codegen_unit)
             {
-                let mut attrs = attributes::sanitize_attrs(&cx, tcx, SanitizerFnAttrs::default(), tcx.sess.sanitizers());
+                let mut attrs = attributes::sanitize_attrs(
+                    &cx,
+                    tcx,
+                    SanitizerFnAttrs::default(),
+                    tcx.sess.sanitizers(),
+                );
                 // When pointer authentication is enabled, ensure that the ptrauth-* attributes are
                 // also attached to the entry wrapper.
                 //

compiler/rustc_codegen_llvm/src/common.rs

@@ -15,8 +15,8 @@ use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::{GlobalAlloc, PointerArithmetic, Scalar};
-use rustc_middle::ty::{self, Ty, Instance, TyCtxt};
-use rustc_session::{PointerAuthAddressDiscriminator, PointerAuthSchema, cstore::DllImport};
+use rustc_middle::ty::{Instance, TyCtxt};
+use rustc_session::{PointerAuthAddressDiscriminator, PointerAuthSchema};
 use tracing::debug;
 
 use crate::consts::{IsInitOrFini, IsStatic, const_alloc_to_llvm};
@@ -535,17 +535,3 @@ impl AsCCharPtr for [u8] {
         self.as_ptr().cast()
     }
 }
-
-pub(crate) fn type_name_for_ignore_list<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    fn_abi: &rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>,
-) -> String {
-    let inputs: Vec<_> = fn_abi.args.iter().map(|arg| arg.layout.ty).collect();
-    let output = fn_abi.ret.layout.ty;
-    let mut fn_sig_kind = ty::FnSigKind::default();
-    fn_sig_kind = fn_sig_kind.set_safety(rustc_hir::Safety::Safe);
-    fn_sig_kind = fn_sig_kind.set_c_variadic(fn_abi.c_variadic);
-    let fn_sig = tcx.mk_fn_sig(inputs, output, fn_sig_kind);
-    let fn_ptr = Ty::new_fn_ptr(tcx, ty::Binder::dummy(fn_sig));
-    ty::print::with_no_trimmed_paths!(fn_ptr.to_string())
-}

compiler/rustc_codegen_llvm/src/context.rs

@@ -20,6 +20,7 @@ use rustc_middle::ty::layout::{
 };
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
+use rustc_sanitizers::ignorelist::{SanitizerIgnoreList, type_name_for_ignore_list};
 use rustc_session::config::{
     BranchProtection, CFGuard, CFProtection, DebugInfo, FunctionReturn, PAuthKey, PacRet,
 };
@@ -133,7 +134,7 @@ pub(crate) struct FullCx<'ll, 'tcx> {
     /// Extra per-CGU codegen state needed when coverage instrumentation is enabled.
     pub coverage_cx: Option<coverageinfo::CguCoverageContext<'ll, 'tcx>>,
     pub dbg_cx: Option<debuginfo::CodegenUnitDebugContext<'ll, 'tcx>>,
-    pub sanitizer_ignorelist: Option<crate::llvm::SanitizerIgnoreList>,
+    pub sanitizer_ignorelist: Option<SanitizerIgnoreList>,
 
     eh_personality: Cell<Option<&'ll Value>>,
     pub rust_try_fn: Cell<Option<(&'ll Type, &'ll Value)>>,
@@ -689,9 +690,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
             for path in &tcx.sess.opts.unstable_opts.sanitizer_ignorelist {
                 let _ = tcx.sess.source_map().load_file(std::path::Path::new(path));
             }
-            match crate::llvm::SanitizerIgnoreList::new(
-                &tcx.sess.opts.unstable_opts.sanitizer_ignorelist,
-            ) {
+            match SanitizerIgnoreList::new(&tcx.sess.opts.unstable_opts.sanitizer_ignorelist) {
                 Ok(list) => Some(list),
                 Err(err) => {
                     tcx.dcx().fatal(format!("failed to parse sanitizer ignorelist: {}", err));
@@ -867,7 +866,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
         fn_abi: &rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>,
     ) -> bool {
         self.sanitizer_ignorelist.as_ref().is_some_and(|ignorelist| {
-            let type_name = crate::common::type_name_for_ignore_list(self.tcx, fn_abi);
+            let type_name = type_name_for_ignore_list(self.tcx, fn_abi);
             ignorelist.contains_prefix(sanitizer, c"type", &type_name)
         })
     }

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -2463,19 +2463,6 @@ unsafe extern "C" {
     pub(crate) fn LLVMRustSetNormalizedTarget(M: &Module, triple: *const c_char);
     pub(crate) fn LLVMRustRunRestrictionPass(M: &Module, syms: *const *const c_char, len: size_t);
 
-    pub(crate) fn LLVMRustSpecialCaseListCreate(
-        Paths: *const *const c_char,
-        NumPaths: size_t,
-        ErrorMsg: &RustString,
-    ) -> *mut Opaque;
-    pub(crate) fn LLVMRustSpecialCaseListDestroy(List: *mut Opaque);
-    pub(crate) fn LLVMRustSpecialCaseListContainsPrefix(
-        List: *const Opaque,
-        Section: *const c_char,
-        Prefix: *const c_char,
-        Query: *const c_char,
-    ) -> bool;
-
     pub(crate) fn LLVMRustWriteTwineToString(T: &Twine, s: &RustString);
 
     pub(crate) fn LLVMRustUnpackOptimizationDiagnostic<'a>(

compiler/rustc_codegen_llvm/src/llvm/mod.rs

@@ -375,52 +375,6 @@ pub(crate) fn build_byte_buffer(f: impl FnOnce(&RustString)) -> Vec<u8> {
     RustString::build_byte_buffer(f)
 }
 
-pub(crate) struct SanitizerIgnoreList {
-    inner: *mut ffi::Opaque,
-}
-
-impl SanitizerIgnoreList {
-    pub(crate) fn new(paths: &[String]) -> Result<Self, String> {
-        use std::ffi::CString;
-        let c_paths: Vec<CString> =
-            paths.iter().map(|p| CString::new(p.as_str()).unwrap()).collect();
-        let c_ptrs: Vec<*const libc::c_char> = c_paths.iter().map(|c| c.as_ptr()).collect();
-
-        let mut inner = std::ptr::null_mut();
-        let err = build_string(|err| unsafe {
-            inner = ffi::LLVMRustSpecialCaseListCreate(c_ptrs.as_ptr(), c_ptrs.len(), err);
-        });
-
-        let err = err.unwrap_or_else(|e| format!("utf8 error: {}", e));
-        if inner.is_null() { Err(err) } else { Ok(Self { inner }) }
-    }
-
-    pub(crate) fn contains_prefix(
-        &self,
-        section: &std::ffi::CStr,
-        prefix: &std::ffi::CStr,
-        query: &str,
-    ) -> bool {
-        let query = std::ffi::CString::new(query).unwrap();
-        unsafe {
-            ffi::LLVMRustSpecialCaseListContainsPrefix(
-                self.inner,
-                section.as_ptr(),
-                prefix.as_ptr(),
-                query.as_ptr(),
-            )
-        }
-    }
-}
-
-impl Drop for SanitizerIgnoreList {
-    fn drop(&mut self) {
-        unsafe {
-            ffi::LLVMRustSpecialCaseListDestroy(self.inner);
-        }
-    }
-}
-
 pub(crate) fn twine_to_string(tr: &Twine) -> String {
     unsafe {
         build_string(|s| LLVMRustWriteTwineToString(tr, s)).expect("got a non-UTF8 Twine from LLVM")

compiler/rustc_sanitizers/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 bitflags = "2.5.0"
+libc = "0.2"
 rustc_abi = { path = "../rustc_abi" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_hir = { path = "../rustc_hir" }

compiler/rustc_sanitizers/src/ignorelist/ffi.rs

@@ -0,0 +1,64 @@
+use std::cell::RefCell;
+use std::ffi::c_char;
+use std::ptr;
+use std::string::FromUtf8Error;
+
+use libc::size_t;
+
+unsafe extern "C" {
+    pub(crate) type Opaque;
+    /// Opaque type that allows C++ code to write bytes to a Rust-side buffer,
+    /// in conjunction with `RawRustStringOstream`. Use this as `&RustString`
+    /// (Rust) and `RustStringRef` (C++) in FFI signatures.
+    pub(crate) type RustString;
+
+    pub(crate) fn LLVMRustSpecialCaseListCreate(
+        Paths: *const *const c_char,
+        NumPaths: size_t,
+        ErrorMsg: &RustString,
+    ) -> *mut Opaque;
+
+    pub(crate) fn LLVMRustSpecialCaseListDestroy(List: *mut Opaque);
+    pub(crate) fn LLVMRustSpecialCaseListContainsPrefix(
+        List: *const Opaque,
+        Section: *const c_char,
+        Prefix: *const c_char,
+        Query: *const c_char,
+    ) -> bool;
+}
+
+/// Underlying implementation of [`RustString`].
+///
+/// Having two separate types makes it possible to use the opaque [`RustString`]
+/// in FFI signatures without `improper_ctypes` warnings. This is a workaround
+/// for the fact that there is no way to opt out of `improper_ctypes` when
+/// _declaring_ a type (as opposed to using that type).
+#[derive(Default)]
+struct RustStringInner {
+    bytes: RefCell<Vec<u8>>,
+}
+
+impl RustStringInner {
+    fn as_opaque(&self) -> &RustString {
+        let ptr: *const RustStringInner = ptr::from_ref(self);
+        // We can't use `ptr::cast` here because extern types are `!Sized`.
+        let ptr = ptr as *const RustString;
+        unsafe { &*ptr }
+    }
+
+    fn into_inner(self) -> Vec<u8> {
+        self.bytes.into_inner()
+    }
+}
+
+impl RustString {
+    pub(crate) fn build_byte_buffer(closure: impl FnOnce(&Self)) -> Vec<u8> {
+        let buf = RustStringInner::default();
+        closure(buf.as_opaque());
+        buf.into_inner()
+    }
+}
+
+pub(crate) fn build_string(f: impl FnOnce(&RustString)) -> Result<String, FromUtf8Error> {
+    String::from_utf8(RustString::build_byte_buffer(f))
+}