Clean llvm wrapper

dpaoliello · dpaoliello · commit 5bf2edb3c5b3 · 2025-02-24T09:33:36.000-08:00
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -30,7 +30,7 @@ use std::mem::ManuallyDrop;
 use back::owned_target_machine::OwnedTargetMachine;
 use back::write::{create_informational_target_machine, create_target_machine};
 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};
@@ -72,9 +72,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
@@ -30,20 +30,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;
     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);
     }
     extern "C" {
         static mut EnzymePrintPerf: c_void;
@@ -55,77 +55,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
`@@ -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
`@@ -30,20 +30,20 @@ unsafe extern "C" {`
`30`	`30`
`31`	`31`	`#[repr(C)]`
`32`	`32`	`#[derive(Copy, Clone, PartialEq)]`
`33`		`-pub enum LLVMRustVerifierFailureAction {`
	`33`	`+pub(crate) enum LLVMRustVerifierFailureAction {`
`34`	`34`	`LLVMAbortProcessAction = 0,`
`35`	`35`	`LLVMPrintMessageAction = 1,`
`36`	`36`	`LLVMReturnStatusAction = 2,`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`#[cfg(llvm_enzyme)]`
`40`		`-pub use self::Enzyme_AD::*;`
	`40`	`+pub(crate) use self::Enzyme_AD::*;`
`41`	`41`
`42`	`42`	`#[cfg(llvm_enzyme)]`
`43`		`-pub mod Enzyme_AD {`
	`43`	`+pub(crate) mod Enzyme_AD {`
`44`	`44`	`use libc::c_void;`
`45`	`45`	`extern "C" {`
`46`		`- pub fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);`
	`46`	`+ pub(crate) fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);`
`47`	`47`	`}`
`48`	`48`	`extern "C" {`
`49`	`49`	`static mut EnzymePrintPerf: c_void;`
`@@ -55,77 +55,77 @@ pub mod Enzyme_AD {`
`55`	`55`	`static mut EnzymeInline: c_void;`
`56`	`56`	`static mut RustTypeRules: c_void;`
`57`	`57`	`}`
`58`		`- pub fn set_print_perf(print: bool) {`
	`58`	`+ pub(crate) fn set_print_perf(print: bool) {`
`59`	`59`	`unsafe {`
`60`	`60`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintPerf), print as u8);`
`61`	`61`	`}`
`62`	`62`	`}`
`63`		`- pub fn set_print_activity(print: bool) {`
	`63`	`+ pub(crate) fn set_print_activity(print: bool) {`
`64`	`64`	`unsafe {`
`65`	`65`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintActivity), print as u8);`
`66`	`66`	`}`
`67`	`67`	`}`
`68`		`- pub fn set_print_type(print: bool) {`
	`68`	`+ pub(crate) fn set_print_type(print: bool) {`
`69`	`69`	`unsafe {`
`70`	`70`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrintType), print as u8);`
`71`	`71`	`}`
`72`	`72`	`}`
`73`		`- pub fn set_print(print: bool) {`
	`73`	`+ pub(crate) fn set_print(print: bool) {`
`74`	`74`	`unsafe {`
`75`	`75`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymePrint), print as u8);`
`76`	`76`	`}`
`77`	`77`	`}`
`78`		`- pub fn set_strict_aliasing(strict: bool) {`
	`78`	`+ pub(crate) fn set_strict_aliasing(strict: bool) {`
`79`	`79`	`unsafe {`
`80`	`80`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymeStrictAliasing), strict as u8);`
`81`	`81`	`}`
`82`	`82`	`}`
`83`		`- pub fn set_loose_types(loose: bool) {`
	`83`	`+ pub(crate) fn set_loose_types(loose: bool) {`
`84`	`84`	`unsafe {`
`85`	`85`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(looseTypeAnalysis), loose as u8);`
`86`	`86`	`}`
`87`	`87`	`}`
`88`		`- pub fn set_inline(val: bool) {`
	`88`	`+ pub(crate) fn set_inline(val: bool) {`
`89`	`89`	`unsafe {`
`90`	`90`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(EnzymeInline), val as u8);`
`91`	`91`	`}`
`92`	`92`	`}`
`93`		`- pub fn set_rust_rules(val: bool) {`
	`93`	`+ pub(crate) fn set_rust_rules(val: bool) {`
`94`	`94`	`unsafe {`
`95`	`95`	`EnzymeSetCLBool(std::ptr::addr_of_mut!(RustTypeRules), val as u8);`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`#[cfg(not(llvm_enzyme))]`
`101`		`-pub use self::Fallback_AD::*;`
	`101`	`+pub(crate) use self::Fallback_AD::*;`
`102`	`102`
`103`	`103`	`#[cfg(not(llvm_enzyme))]`
`104`		`-pub mod Fallback_AD {`
	`104`	`+pub(crate) mod Fallback_AD {`
`105`	`105`	`#![allow(unused_variables)]`
`106`	`106`
`107`		`- pub fn set_inline(val: bool) {`
	`107`	`+ pub(crate) fn set_inline(val: bool) {`
`108`	`108`	`unimplemented!()`
`109`	`109`	`}`
`110`		`- pub fn set_print_perf(print: bool) {`
	`110`	`+ pub(crate) fn set_print_perf(print: bool) {`
`111`	`111`	`unimplemented!()`
`112`	`112`	`}`
`113`		`- pub fn set_print_activity(print: bool) {`
	`113`	`+ pub(crate) fn set_print_activity(print: bool) {`
`114`	`114`	`unimplemented!()`
`115`	`115`	`}`
`116`		`- pub fn set_print_type(print: bool) {`
	`116`	`+ pub(crate) fn set_print_type(print: bool) {`
`117`	`117`	`unimplemented!()`
`118`	`118`	`}`
`119`		`- pub fn set_print(print: bool) {`
	`119`	`+ pub(crate) fn set_print(print: bool) {`
`120`	`120`	`unimplemented!()`
`121`	`121`	`}`
`122`		`- pub fn set_strict_aliasing(strict: bool) {`
	`122`	`+ pub(crate) fn set_strict_aliasing(strict: bool) {`
`123`	`123`	`unimplemented!()`
`124`	`124`	`}`
`125`		`- pub fn set_loose_types(loose: bool) {`
	`125`	`+ pub(crate) fn set_loose_types(loose: bool) {`
`126`	`126`	`unimplemented!()`
`127`	`127`	`}`
`128`		`- pub fn set_rust_rules(val: bool) {`
	`128`	`+ pub(crate) fn set_rust_rules(val: bool) {`
`129`	`129`	`unimplemented!()`
`130`	`130`	`}`
`131`	`131`	`}`