Move all LLVM externs into the rustc_llvm crate in preparation for ctest

Author: Diggsey

Cargo.lock

@@ -3521,7 +3521,6 @@ dependencies = [
 name = "rustc_codegen_llvm"
 version = "0.0.0"
 dependencies = [
- "bitflags",
  "gimli 0.31.1",
  "itertools",
  "libc",
@@ -4101,8 +4100,10 @@ dependencies = [
 name = "rustc_llvm"
 version = "0.0.0"
 dependencies = [
+ "bitflags",
  "cc",
  "libc",
+ "rustc_macros",
 ]
 
 [[package]]

compiler/rustc_codegen_llvm/Cargo.toml

@@ -8,7 +8,6 @@ test = false
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags = "2.4.1"
 # To avoid duplicate dependencies, this should match the version of gimli used
 # by `rustc_codegen_ssa` via its `thorin-dwp` dependency.
 gimli = "0.31"
@@ -38,7 +37,7 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_symbol_mangling = { path = "../rustc_symbol_mangling" }
 rustc_target = { path = "../rustc_target" }
-serde = { version = "1", features = [ "derive" ]}
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 tracing = "0.1"

compiler/rustc_codegen_llvm/src/abi.rs

@@ -23,10 +23,9 @@ use smallvec::SmallVec;
 use crate::attributes::{self, llfn_attrs_from_instance};
 use crate::builder::Builder;
 use crate::context::CodegenCx;
-use crate::llvm::{self, Attribute, AttributePlace};
+use crate::llvm::{self, Attribute, AttributePlace, Value};
 use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
 
 trait ArgAttributesExt {
     fn apply_attrs_to_llfn(&self, idx: AttributePlace, cx: &CodegenCx<'_, '_>, llfn: &Value);
@@ -644,8 +643,12 @@ impl AbiBuilderMethods for Builder<'_, '_, '_> {
     }
 }
 
-impl llvm::CallConv {
-    pub(crate) fn from_conv(conv: CanonAbi, arch: &str) -> Self {
+pub(crate) trait CallConvExt {
+    fn from_conv(conv: CanonAbi, arch: &str) -> llvm::CallConv;
+}
+
+impl CallConvExt for llvm::CallConv {
+    fn from_conv(conv: CanonAbi, arch: &str) -> Self {
         match conv {
             CanonAbi::C | CanonAbi::Rust => llvm::CCallConv,
             CanonAbi::RustCold => llvm::PreserveMost,

compiler/rustc_codegen_llvm/src/allocator.rs

@@ -114,7 +114,7 @@ fn create_const_value_function(
         name,
         llvm::CallConv::CCallConv,
         llvm::UnnamedAddr::Global,
-        llvm::Visibility::from_generic(tcx.sess.default_visibility()),
+        llvm::visibility_from_generic(tcx.sess.default_visibility()),
         ty,
     );
 
@@ -144,7 +144,7 @@ fn create_wrapper_function(
         from_name,
         llvm::CallConv::CCallConv,
         llvm::UnnamedAddr::Global,
-        llvm::Visibility::from_generic(tcx.sess.default_visibility()),
+        llvm::visibility_from_generic(tcx.sess.default_visibility()),
         ty,
     );
     let no_return = if no_return {

compiler/rustc_codegen_llvm/src/asm.rs

@@ -16,9 +16,9 @@ use tracing::debug;
 use crate::builder::Builder;
 use crate::common::Funclet;
 use crate::context::CodegenCx;
+use crate::llvm::Value;
 use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
 use crate::{attributes, llvm};
 
 impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -12,8 +12,9 @@ use smallvec::SmallVec;
 use crate::context::CodegenCx;
 use crate::errors::SanitizerMemtagRequiresMte;
 use crate::llvm::AttributePlace::Function;
-use crate::llvm::{self, AllocKindFlags, Attribute, AttributeKind, AttributePlace, MemoryEffects};
-use crate::value::Value;
+use crate::llvm::{
+    self, AllocKindFlags, Attribute, AttributeKind, AttributePlace, MemoryEffects, Value,
+};
 use crate::{attributes, llvm_util};
 
 pub(crate) fn apply_to_llfn(llfn: &Value, idx: AttributePlace, attrs: &[&Attribute]) {

compiler/rustc_codegen_llvm/src/back/archive.rs

@@ -11,7 +11,7 @@ use rustc_codegen_ssa::back::archive::{
 use rustc_session::Session;
 
 use crate::llvm::archive_ro::{ArchiveRO, Child};
-use crate::llvm::{self, ArchiveKind, last_error};
+use crate::llvm::{self, last_error, parse_archive_kind};
 
 /// Helper for adding many files to an archive.
 #[must_use = "must call build() to finish building the archive"]
@@ -182,8 +182,7 @@ fn llvm_is_ec_object_file(buf: &[u8]) -> bool {
 impl<'a> LlvmArchiveBuilder<'a> {
     fn build_with_llvm(&mut self, output: &Path) -> io::Result<bool> {
         let kind = &*self.sess.target.archive_format;
-        let kind = kind
-            .parse::<ArchiveKind>()
+        let kind = parse_archive_kind(kind)
             .map_err(|_| kind)
             .unwrap_or_else(|kind| self.sess.dcx().emit_fatal(UnknownArchiveKind { kind }));
 

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -42,7 +42,7 @@ use crate::errors::{
 };
 use crate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 use crate::llvm::{self, DiagnosticInfo};
-use crate::type_::Type;
+use crate::type_::type_ptr_llcx;
 use crate::{LlvmCodegenBackend, ModuleLlvm, base, common, llvm_util};
 
 pub(crate) fn llvm_err<'a>(dcx: DiagCtxtHandle<'_>, err: LlvmError<'a>) -> FatalError {
@@ -1174,7 +1174,7 @@ fn create_msvc_imps(
     // underscores added in front).
     let prefix = if cgcx.target_arch == "x86" { "\x01__imp__" } else { "\x01__imp_" };
 
-    let ptr_ty = Type::ptr_llcx(llcx);
+    let ptr_ty = type_ptr_llcx(llcx);
     let globals = base::iter_globals(llmod)
         .filter(|&val| {
             llvm::get_linkage(val) == llvm::Linkage::ExternalLinkage && !llvm::is_declaration(val)

compiler/rustc_codegen_llvm/src/base.rs

@@ -29,7 +29,7 @@ use rustc_target::spec::SanitizerSet;
 use super::ModuleLlvm;
 use crate::builder::Builder;
 use crate::context::CodegenCx;
-use crate::value::Value;
+use crate::llvm::Value;
 use crate::{attributes, llvm};
 
 pub(crate) struct ValueIter<'ll> {

compiler/rustc_codegen_llvm/src/builder.rs

@@ -32,12 +32,9 @@ use crate::abi::FnAbiLlvmExt;
 use crate::attributes;
 use crate::common::Funclet;
 use crate::context::{CodegenCx, FullCx, GenericCx, SCx};
-use crate::llvm::{
-    self, AtomicOrdering, AtomicRmwBinOp, BasicBlock, False, GEPNoWrapFlags, Metadata, True,
-};
+use crate::llvm::{self, BasicBlock, False, GEPNoWrapFlags, Metadata, True, Value};
 use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
 
 #[must_use]
 pub(crate) struct GenericBuilder<'a, 'll, CX: Borrow<SCx<'ll>>> {
@@ -568,7 +565,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 ty,
                 ptr,
                 UNNAMED,
-                AtomicOrdering::from_generic(order),
+                llvm::atomic_ordering_from_generic(order),
             );
             // LLVM requires the alignment of atomic loads to be at least the size of the type.
             llvm::LLVMSetAlignment(load, size.bytes() as c_uint);
@@ -808,7 +805,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 self.llbuilder,
                 val,
                 ptr,
-                AtomicOrdering::from_generic(order),
+                llvm::atomic_ordering_from_generic(order),
             );
             // LLVM requires the alignment of atomic stores to be at least the size of the type.
             llvm::LLVMSetAlignment(store, size.bytes() as c_uint);
@@ -1005,12 +1002,12 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
     /* Comparisons */
     fn icmp(&mut self, op: IntPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
-        let op = llvm::IntPredicate::from_generic(op);
+        let op = llvm::int_predicate_from_generic(op);
         unsafe { llvm::LLVMBuildICmp(self.llbuilder, op as c_uint, lhs, rhs, UNNAMED) }
     }
 
     fn fcmp(&mut self, op: RealPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
-        let op = llvm::RealPredicate::from_generic(op);
+        let op = llvm::real_predicate_from_generic(op);
         unsafe { llvm::LLVMBuildFCmp(self.llbuilder, op as c_uint, lhs, rhs, UNNAMED) }
     }
 
@@ -1246,8 +1243,8 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 dst,
                 cmp,
                 src,
-                AtomicOrdering::from_generic(order),
-                AtomicOrdering::from_generic(failure_order),
+                llvm::atomic_ordering_from_generic(order),
+                llvm::atomic_ordering_from_generic(failure_order),
                 llvm::False, // SingleThreaded
             );
             llvm::LLVMSetWeak(value, weak);
@@ -1273,10 +1270,10 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         let mut res = unsafe {
             llvm::LLVMBuildAtomicRMW(
                 self.llbuilder,
-                AtomicRmwBinOp::from_generic(op),
+                llvm::atomic_rmw_bin_op_from_generic(op),
                 dst,
                 src,
-                AtomicOrdering::from_generic(order),
+                llvm::atomic_ordering_from_generic(order),
                 llvm::False, // SingleThreaded
             )
         };
@@ -1298,7 +1295,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         unsafe {
             llvm::LLVMBuildFence(
                 self.llbuilder,
-                AtomicOrdering::from_generic(order),
+                llvm::atomic_ordering_from_generic(order),
                 single_threaded,
                 UNNAMED,
             );