Clean llvm wrapper

dpaoliello · dpaoliello · commit 5aac014d7fec · 2025-03-24T10:50:05.000-07:00
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -728,7 +728,7 @@ impl ThinBuffer {
         }
     }
 
-    pub unsafe fn from_raw_ptr(ptr: *mut llvm::ThinLTOBuffer) -> ThinBuffer {
+    pub(crate) unsafe fn from_raw_ptr(ptr: *mut llvm::ThinLTOBuffer) -> ThinBuffer {
         let mut ptr = NonNull::new(ptr).unwrap();
         ThinBuffer(unsafe { ptr.as_mut() })
     }
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -29,7 +29,7 @@ use back::owned_target_machine::OwnedTargetMachine;
 use back::write::{create_informational_target_machine, create_target_machine};
 use context::SimpleCx;
 use errors::{AutoDiffWithoutLTO, ParseTargetMachineConfig};
-pub(crate) use llvm_util::target_features_cfg;
+use llvm_util::target_features_cfg;
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
 use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
@@ -71,9 +71,7 @@ mod debuginfo;
 mod declare;
 mod errors;
 mod intrinsic;
-// FIXME(Zalathar): Fix all the unreachable-pub warnings that would occur if
-// this isn't pub, then make it not pub.
-pub mod llvm;
+mod llvm;
 mod llvm_util;
 mod mono_item;
 mod type_;
diff --git a/compiler/rustc_codegen_llvm/src/llvm/archive_ro.rs b/compiler/rustc_codegen_llvm/src/llvm/archive_ro.rs
@@ -5,17 +5,17 @@ use std::{slice, str};
 
 use rustc_fs_util::path_to_c_string;
 
-pub struct ArchiveRO {
+pub(crate) struct ArchiveRO {
     pub raw: &'static mut super::Archive,
 }
 
 unsafe impl Send for ArchiveRO {}
 
-pub struct Iter<'a> {
+pub(crate) struct Iter<'a> {
     raw: &'a mut super::ArchiveIterator<'a>,
 }
 
-pub struct Child<'a> {
+pub(crate) struct Child<'a> {
     pub raw: &'a mut super::ArchiveChild<'a>,
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs b/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs
@@ -3,13 +3,13 @@
 use libc::c_uint;
 use rustc_span::InnerSpan;
 
-pub use self::Diagnostic::*;
-pub use self::OptimizationDiagnosticKind::*;
+pub(crate) use self::Diagnostic::*;
+use self::OptimizationDiagnosticKind::*;
 use super::{DiagnosticInfo, SMDiagnostic};
 use crate::value::Value;
 
 #[derive(Copy, Clone, Debug)]
-pub enum OptimizationDiagnosticKind {
+pub(crate) enum OptimizationDiagnosticKind {
     OptimizationRemark,
     OptimizationMissed,
     OptimizationAnalysis,
@@ -19,9 +19,10 @@ pub enum OptimizationDiagnosticKind {
     OptimizationRemarkOther,
 }
 
-pub struct OptimizationDiagnostic<'ll> {
+pub(crate) struct OptimizationDiagnostic<'ll> {
     pub kind: OptimizationDiagnosticKind,
     pub pass_name: String,
+    #[expect(dead_code)]
     pub function: &'ll Value,
     pub line: c_uint,
     pub column: c_uint,
@@ -73,14 +74,14 @@ impl<'ll> OptimizationDiagnostic<'ll> {
     }
 }
 
-pub struct SrcMgrDiagnostic {
+pub(crate) struct SrcMgrDiagnostic {
     pub level: super::DiagnosticLevel,
     pub message: String,
     pub source: Option<(String, Vec<InnerSpan>)>,
 }
 
 impl SrcMgrDiagnostic {
-    pub unsafe fn unpack(diag: &SMDiagnostic) -> SrcMgrDiagnostic {
+    pub(crate) unsafe fn unpack(diag: &SMDiagnostic) -> SrcMgrDiagnostic {
         // Recover the post-substitution assembly code from LLVM for better
         // diagnostics.
         let mut have_source = false;
@@ -120,7 +121,7 @@ impl SrcMgrDiagnostic {
 }
 
 #[derive(Clone)]
-pub struct InlineAsmDiagnostic {
+pub(crate) struct InlineAsmDiagnostic {
     pub level: super::DiagnosticLevel,
     pub cookie: u64,
     pub message: String,
@@ -158,19 +159,20 @@ impl InlineAsmDiagnostic {
     }
 }
 
-pub enum Diagnostic<'ll> {
+pub(crate) enum Diagnostic<'ll> {
     Optimization(OptimizationDiagnostic<'ll>),
     InlineAsm(InlineAsmDiagnostic),
     PGO(&'ll DiagnosticInfo),
     Linker(&'ll DiagnosticInfo),
     Unsupported(&'ll DiagnosticInfo),
 
     /// LLVM has other types that we do not wrap here.
+    #[expect(dead_code)]
     UnknownDiagnostic(&'ll DiagnosticInfo),
 }
 
 impl<'ll> Diagnostic<'ll> {
-    pub unsafe fn unpack(di: &'ll DiagnosticInfo) -> Self {
+    pub(crate) unsafe fn unpack(di: &'ll DiagnosticInfo) -> Self {
         use super::DiagnosticKind as Dk;
 
         unsafe {
diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -31,20 +31,20 @@ unsafe extern "C" {
 
 #[repr(C)]
 #[derive(Copy, Clone, PartialEq)]
-pub enum LLVMRustVerifierFailureAction {
+pub(crate) enum LLVMRustVerifierFailureAction {
     LLVMAbortProcessAction = 0,
     LLVMPrintMessageAction = 1,
     LLVMReturnStatusAction = 2,
 }
 
 #[cfg(llvm_enzyme)]
-pub use self::Enzyme_AD::*;
+pub(crate) use self::Enzyme_AD::*;
 
 #[cfg(llvm_enzyme)]
-pub mod Enzyme_AD {
+pub(crate) mod Enzyme_AD {
     use libc::c_void;
     unsafe extern "C" {
-        pub fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);
+        pub(crate) fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);
     }
     unsafe extern "C" {
         static mut EnzymePrintPerf: c_void;
@@ -56,77 +56,77 @@ pub mod Enzyme_AD {
         static mut EnzymeInline: c_void;
         static mut RustTypeRules: c_void;
     }
-    pub fn set_print_perf(print: bool) {
+    pub(crate) fn set_print_perf(print: bool) {
         unsafe {
             EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintPerf), print as u8);
         }
     }
-    pub fn set_print_activity(print: bool) {
+    pub(crate) fn set_print_activity(print: bool) {
         unsafe {
             EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintActivity), print as u8);
         }
     }
-    pub fn set_print_type(print: bool) {
+    pub(crate) fn set_print_type(print: bool) {
         unsafe {
             EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintType), print as u8);
         }
     }
-    pub fn set_print(print: bool) {
+    pub(crate) fn set_print(print: bool) {
         unsafe {
             EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrint), print as u8);
         }
     }
-    pub fn set_strict_aliasing(strict: bool) {
+    pub(crate) fn set_strict_aliasing(strict: bool) {
         unsafe {
             EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymeStrictAliasing), strict as u8);
         }
     }
-    pub fn set_loose_types(loose: bool) {
+    pub(crate) fn set_loose_types(loose: bool) {
         unsafe {
             EnzymeSetCLBool(std::ptr::addr_of_mut!(looseTypeAnalysis), loose as u8);
         }
     }
-    pub fn set_inline(val: bool) {
+    pub(crate) fn set_inline(val: bool) {
         unsafe {
             EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymeInline), val as u8);
         }
     }
-    pub fn set_rust_rules(val: bool) {
+    pub(crate) fn set_rust_rules(val: bool) {
         unsafe {
             EnzymeSetCLBool(std::ptr::addr_of_mut!(RustTypeRules), val as u8);
         }
     }
 }
 
 #[cfg(not(llvm_enzyme))]
-pub use self::Fallback_AD::*;
+pub(crate) use self::Fallback_AD::*;
 
 #[cfg(not(llvm_enzyme))]
-pub mod Fallback_AD {
+pub(crate) mod Fallback_AD {
     #![allow(unused_variables)]
 
-    pub fn set_inline(val: bool) {
+    pub(crate) fn set_inline(val: bool) {
         unimplemented!()
     }
-    pub fn set_print_perf(print: bool) {
+    pub(crate) fn set_print_perf(print: bool) {
         unimplemented!()
     }
-    pub fn set_print_activity(print: bool) {
+    pub(crate) fn set_print_activity(print: bool) {
         unimplemented!()
     }
-    pub fn set_print_type(print: bool) {
+    pub(crate) fn set_print_type(print: bool) {
         unimplemented!()
     }
-    pub fn set_print(print: bool) {
+    pub(crate) fn set_print(print: bool) {
         unimplemented!()
     }
-    pub fn set_strict_aliasing(strict: bool) {
+    pub(crate) fn set_strict_aliasing(strict: bool) {
         unimplemented!()
     }
-    pub fn set_loose_types(loose: bool) {
+    pub(crate) fn set_loose_types(loose: bool) {
         unimplemented!()
     }
-    pub fn set_rust_rules(val: bool) {
+    pub(crate) fn set_rust_rules(val: bool) {
         unimplemented!()
     }
 }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -728,7 +728,7 @@ impl ThinBuffer {`
`728`	`728`	`}`
`729`	`729`	`}`
`730`	`730`
`731`		`- pub unsafe fn from_raw_ptr(ptr: *mut llvm::ThinLTOBuffer) -> ThinBuffer {`
	`731`	`+ pub(crate) unsafe fn from_raw_ptr(ptr: *mut llvm::ThinLTOBuffer) -> ThinBuffer {`
`732`	`732`	`let mut ptr = NonNull::new(ptr).unwrap();`
`733`	`733`	`ThinBuffer(unsafe { ptr.as_mut() })`
`734`	`734`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,17 +5,17 @@ use std::{slice, str};`
`5`	`5`
`6`	`6`	`use rustc_fs_util::path_to_c_string;`
`7`	`7`
`8`		`-pub struct ArchiveRO {`
	`8`	`+pub(crate) struct ArchiveRO {`
`9`	`9`	`pub raw: &'static mut super::Archive,`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`unsafe impl Send for ArchiveRO {}`
`13`	`13`
`14`		`-pub struct Iter<'a> {`
	`14`	`+pub(crate) struct Iter<'a> {`
`15`	`15`	`raw: &'a mut super::ArchiveIterator<'a>,`
`16`	`16`	`}`
`17`	`17`
`18`		`-pub struct Child<'a> {`
	`18`	`+pub(crate) struct Child<'a> {`
`19`	`19`	`pub raw: &'a mut super::ArchiveChild<'a>,`
`20`	`20`	`}`
`21`	`21`
Original file line number	Diff line number	Diff line change
`@@ -31,20 +31,20 @@ unsafe extern "C" {`
`31`	`31`
`32`	`32`	`#[repr(C)]`
`33`	`33`	`#[derive(Copy, Clone, PartialEq)]`
`34`		`-pub enum LLVMRustVerifierFailureAction {`
	`34`	`+pub(crate) enum LLVMRustVerifierFailureAction {`
`35`	`35`	`LLVMAbortProcessAction = 0,`
`36`	`36`	`LLVMPrintMessageAction = 1,`
`37`	`37`	`LLVMReturnStatusAction = 2,`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`#[cfg(llvm_enzyme)]`
`41`		`-pub use self::Enzyme_AD::*;`
	`41`	`+pub(crate) use self::Enzyme_AD::*;`
`42`	`42`
`43`	`43`	`#[cfg(llvm_enzyme)]`
`44`		`-pub mod Enzyme_AD {`
	`44`	`+pub(crate) mod Enzyme_AD {`
`45`	`45`	`use libc::c_void;`
`46`	`46`	`unsafe extern "C" {`
`47`		`- pub fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);`
	`47`	`+ pub(crate) fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);`
`48`	`48`	`}`
`49`	`49`	`unsafe extern "C" {`
`50`	`50`	`static mut EnzymePrintPerf: c_void;`
`@@ -56,77 +56,77 @@ pub mod Enzyme_AD {`
`56`	`56`	`static mut EnzymeInline: c_void;`
`57`	`57`	`static mut RustTypeRules: c_void;`
`58`	`58`	`}`
`59`		`- pub fn set_print_perf(print: bool) {`
	`59`	`+ pub(crate) fn set_print_perf(print: bool) {`
`60`	`60`	`unsafe {`
`61`	`61`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintPerf), print as u8);`
`62`	`62`	`}`
`63`	`63`	`}`
`64`		`- pub fn set_print_activity(print: bool) {`
	`64`	`+ pub(crate) fn set_print_activity(print: bool) {`
`65`	`65`	`unsafe {`
`66`	`66`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintActivity), print as u8);`
`67`	`67`	`}`
`68`	`68`	`}`
`69`		`- pub fn set_print_type(print: bool) {`
	`69`	`+ pub(crate) fn set_print_type(print: bool) {`
`70`	`70`	`unsafe {`
`71`	`71`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintType), print as u8);`
`72`	`72`	`}`
`73`	`73`	`}`
`74`		`- pub fn set_print(print: bool) {`
	`74`	`+ pub(crate) fn set_print(print: bool) {`
`75`	`75`	`unsafe {`
`76`	`76`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrint), print as u8);`
`77`	`77`	`}`
`78`	`78`	`}`
`79`		`- pub fn set_strict_aliasing(strict: bool) {`
	`79`	`+ pub(crate) fn set_strict_aliasing(strict: bool) {`
`80`	`80`	`unsafe {`
`81`	`81`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymeStrictAliasing), strict as u8);`
`82`	`82`	`}`
`83`	`83`	`}`
`84`		`- pub fn set_loose_types(loose: bool) {`
	`84`	`+ pub(crate) fn set_loose_types(loose: bool) {`
`85`	`85`	`unsafe {`
`86`	`86`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(looseTypeAnalysis), loose as u8);`
`87`	`87`	`}`
`88`	`88`	`}`
`89`		`- pub fn set_inline(val: bool) {`
	`89`	`+ pub(crate) fn set_inline(val: bool) {`
`90`	`90`	`unsafe {`
`91`	`91`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymeInline), val as u8);`
`92`	`92`	`}`
`93`	`93`	`}`
`94`		`- pub fn set_rust_rules(val: bool) {`
	`94`	`+ pub(crate) fn set_rust_rules(val: bool) {`
`95`	`95`	`unsafe {`
`96`	`96`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(RustTypeRules), val as u8);`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`#[cfg(not(llvm_enzyme))]`
`102`		`-pub use self::Fallback_AD::*;`
	`102`	`+pub(crate) use self::Fallback_AD::*;`
`103`	`103`
`104`	`104`	`#[cfg(not(llvm_enzyme))]`
`105`		`-pub mod Fallback_AD {`
	`105`	`+pub(crate) mod Fallback_AD {`
`106`	`106`	`#![allow(unused_variables)]`
`107`	`107`
`108`		`- pub fn set_inline(val: bool) {`
	`108`	`+ pub(crate) fn set_inline(val: bool) {`
`109`	`109`	`unimplemented!()`
`110`	`110`	`}`
`111`		`- pub fn set_print_perf(print: bool) {`
	`111`	`+ pub(crate) fn set_print_perf(print: bool) {`
`112`	`112`	`unimplemented!()`
`113`	`113`	`}`
`114`		`- pub fn set_print_activity(print: bool) {`
	`114`	`+ pub(crate) fn set_print_activity(print: bool) {`
`115`	`115`	`unimplemented!()`
`116`	`116`	`}`
`117`		`- pub fn set_print_type(print: bool) {`
	`117`	`+ pub(crate) fn set_print_type(print: bool) {`
`118`	`118`	`unimplemented!()`
`119`	`119`	`}`
`120`		`- pub fn set_print(print: bool) {`
	`120`	`+ pub(crate) fn set_print(print: bool) {`
`121`	`121`	`unimplemented!()`
`122`	`122`	`}`
`123`		`- pub fn set_strict_aliasing(strict: bool) {`
	`123`	`+ pub(crate) fn set_strict_aliasing(strict: bool) {`
`124`	`124`	`unimplemented!()`
`125`	`125`	`}`
`126`		`- pub fn set_loose_types(loose: bool) {`
	`126`	`+ pub(crate) fn set_loose_types(loose: bool) {`
`127`	`127`	`unimplemented!()`
`128`	`128`	`}`
`129`		`- pub fn set_rust_rules(val: bool) {`
	`129`	`+ pub(crate) fn set_rust_rules(val: bool) {`
`130`	`130`	`unimplemented!()`
`131`	`131`	`}`
`132`	`132`	`}`