cg_llvm: More preparation for moving FFI bindings to rustc_llvm

compiler/rustc_codegen_llvm/src/debuginfo/di_builder.rs

@@ -1,8 +1,37 @@
+use std::ptr;
+
 use libc::c_uint;
 use rustc_abi::Align;
 
 use crate::llvm::debuginfo::DIBuilder;
-use crate::llvm::{self, ToLlvmBool};
+use crate::llvm::{self, Module, ToLlvmBool};
+
+/// Owning pointer to a `DIBuilder<'ll>` that will dispose of the builder
+/// when dropped. Use `.as_ref()` to get the underlying `&DIBuilder`
+/// needed for debuginfo FFI calls.
+pub(crate) struct DIBuilderBox<'ll> {
+    raw: ptr::NonNull<DIBuilder<'ll>>,
+}
+
+impl<'ll> DIBuilderBox<'ll> {
+    pub(crate) fn new(llmod: &'ll Module) -> Self {
+        let raw = unsafe { llvm::LLVMCreateDIBuilder(llmod) };
+        let raw = ptr::NonNull::new(raw).unwrap();
+        Self { raw }
+    }
+
+    pub(crate) fn as_ref(&self) -> &DIBuilder<'ll> {
+        // SAFETY: This is an owning pointer, so `&DIBuilder` is valid
+        // for as long as `&self` is.
+        unsafe { self.raw.as_ref() }
+    }
+}
+
+impl<'ll> Drop for DIBuilderBox<'ll> {
+    fn drop(&mut self) {
+        unsafe { llvm::LLVMDisposeDIBuilder(self.raw) };
+    }
+}
 
 /// Extension trait for defining safe wrappers and helper methods on
 /// `&DIBuilder<'ll>`, without requiring it to be defined in the same crate.

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -38,8 +38,9 @@ use self::namespace::mangled_name_of_instance;
 use self::utils::{DIB, create_DIArray, is_node_local_to_unit};
 use crate::builder::Builder;
 use crate::common::{AsCCharPtr, CodegenCx};
+use crate::debuginfo::di_builder::DIBuilderBox;
 use crate::llvm::debuginfo::{
-    DIArray, DIBuilderBox, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope,
+    DIArray, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope,
     DITemplateTypeParameter, DIType, DIVariable,
 };
 use crate::llvm::{self, Value};

compiler/rustc_codegen_llvm/src/llvm/conversions.rs

@@ -1,6 +1,6 @@
 //! Conversions from backend-independent data types to/from LLVM FFI types.
 
-use rustc_codegen_ssa::common::{AtomicRmwBinOp, IntPredicate, RealPredicate};
+use rustc_codegen_ssa::common::{AtomicRmwBinOp, IntPredicate, RealPredicate, TypeKind};
 use rustc_middle::ty::AtomicOrdering;
 use rustc_session::config::DebugInfo;
 use rustc_target::spec::SymbolVisibility;
@@ -9,10 +9,22 @@ use crate::llvm;
 
 /// Helper trait for converting backend-independent types to LLVM-specific
 /// types, for FFI purposes.
+///
+/// FIXME(#147327): These trait/method names were chosen to avoid churn in
+/// existing code, but are not great and could probably be made clearer.
 pub(crate) trait FromGeneric<T> {
     fn from_generic(other: T) -> Self;
 }
 
+/// Helper trait for converting LLVM-specific types to backend-independent
+/// types, for FFI purposes.
+///
+/// FIXME(#147327): These trait/method names were chosen to avoid churn in
+/// existing code, but are not great and could probably be made clearer.
+pub(crate) trait ToGeneric<T> {
+    fn to_generic(&self) -> T;
+}
+
 impl FromGeneric<SymbolVisibility> for llvm::Visibility {
     fn from_generic(visibility: SymbolVisibility) -> Self {
         match visibility {
@@ -113,3 +125,29 @@ impl FromGeneric<DebugInfo> for llvm::debuginfo::DebugEmissionKind {
         }
     }
 }
+
+impl ToGeneric<TypeKind> for llvm::TypeKind {
+    fn to_generic(&self) -> TypeKind {
+        match self {
+            Self::Void => TypeKind::Void,
+            Self::Half => TypeKind::Half,
+            Self::Float => TypeKind::Float,
+            Self::Double => TypeKind::Double,
+            Self::X86_FP80 => TypeKind::X86_FP80,
+            Self::FP128 => TypeKind::FP128,
+            Self::PPC_FP128 => TypeKind::PPC_FP128,
+            Self::Label => TypeKind::Label,
+            Self::Integer => TypeKind::Integer,
+            Self::Function => TypeKind::Function,
+            Self::Struct => TypeKind::Struct,
+            Self::Array => TypeKind::Array,
+            Self::Pointer => TypeKind::Pointer,
+            Self::Vector => TypeKind::Vector,
+            Self::Metadata => TypeKind::Metadata,
+            Self::Token => TypeKind::Token,
+            Self::ScalableVector => TypeKind::ScalableVector,
+            Self::BFloat => TypeKind::BFloat,
+            Self::X86_AMX => TypeKind::X86_AMX,
+        }
+    }
+}

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -361,33 +361,6 @@ pub(crate) enum TypeKind {
     X86_AMX = 19,
 }
 
-impl TypeKind {
-    pub(crate) fn to_generic(self) -> rustc_codegen_ssa::common::TypeKind {
-        use rustc_codegen_ssa::common::TypeKind as Common;
-        match self {
-            Self::Void => Common::Void,
-            Self::Half => Common::Half,
-            Self::Float => Common::Float,
-            Self::Double => Common::Double,
-            Self::X86_FP80 => Common::X86_FP80,
-            Self::FP128 => Common::FP128,
-            Self::PPC_FP128 => Common::PPC_FP128,
-            Self::Label => Common::Label,
-            Self::Integer => Common::Integer,
-            Self::Function => Common::Function,
-            Self::Struct => Common::Struct,
-            Self::Array => Common::Array,
-            Self::Pointer => Common::Pointer,
-            Self::Vector => Common::Vector,
-            Self::Metadata => Common::Metadata,
-            Self::Token => Common::Token,
-            Self::ScalableVector => Common::ScalableVector,
-            Self::BFloat => Common::BFloat,
-            Self::X86_AMX => Common::X86_AMX,
-        }
-    }
-}
-
 /// LLVMAtomicRmwBinOp
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -726,12 +699,9 @@ unsafe extern "C" {
 pub(crate) type DiagnosticHandlerTy = unsafe extern "C" fn(&DiagnosticInfo, *mut c_void);
 
 pub(crate) mod debuginfo {
-    use std::ptr;
-
     use bitflags::bitflags;
 
     use super::{InvariantOpaque, Metadata};
-    use crate::llvm::{self, Module};
 
     /// Opaque target type for references to an LLVM debuginfo builder.
     ///
@@ -744,33 +714,6 @@ pub(crate) mod debuginfo {
     #[repr(C)]
     pub(crate) struct DIBuilder<'ll>(InvariantOpaque<'ll>);
 
-    /// Owning pointer to a `DIBuilder<'ll>` that will dispose of the builder
-    /// when dropped. Use `.as_ref()` to get the underlying `&DIBuilder`
-    /// needed for debuginfo FFI calls.
-    pub(crate) struct DIBuilderBox<'ll> {
-        raw: ptr::NonNull<DIBuilder<'ll>>,
-    }
-
-    impl<'ll> DIBuilderBox<'ll> {
-        pub(crate) fn new(llmod: &'ll Module) -> Self {
-            let raw = unsafe { llvm::LLVMCreateDIBuilder(llmod) };
-            let raw = ptr::NonNull::new(raw).unwrap();
-            Self { raw }
-        }
-
-        pub(crate) fn as_ref(&self) -> &DIBuilder<'ll> {
-            // SAFETY: This is an owning pointer, so `&DIBuilder` is valid
-            // for as long as `&self` is.
-            unsafe { self.raw.as_ref() }
-        }
-    }
-
-    impl<'ll> Drop for DIBuilderBox<'ll> {
-        fn drop(&mut self) {
-            unsafe { llvm::LLVMDisposeDIBuilder(self.raw) };
-        }
-    }
-
     pub(crate) type DIDescriptor = Metadata;
     pub(crate) type DILocation = Metadata;
     pub(crate) type DIScope = DIDescriptor;

compiler/rustc_codegen_llvm/src/type_.rs

@@ -15,7 +15,7 @@ use rustc_target::callconv::{CastTarget, FnAbi};
 use crate::abi::{FnAbiLlvmExt, LlvmType};
 use crate::common;
 use crate::context::{CodegenCx, GenericCx, SCx};
-use crate::llvm::{self, FALSE, Metadata, TRUE, ToLlvmBool, Type, Value};
+use crate::llvm::{self, FALSE, Metadata, TRUE, ToGeneric, ToLlvmBool, Type, Value};
 use crate::type_of::LayoutLlvmExt;
 
 impl PartialEq for Type {