Move all LLVM externs into the rustc_llvm crate

Cargo.lock

@@ -3434,7 +3434,6 @@ dependencies = [
 name = "rustc_codegen_llvm"
 version = "0.0.0"
 dependencies = [
- "bitflags",
  "gimli",
  "itertools",
  "libc",
@@ -4014,8 +4013,14 @@ dependencies = [
 name = "rustc_llvm"
 version = "0.0.0"
 dependencies = [
+ "bitflags",
  "cc",
  "libc",
+ "rustc_codegen_ssa",
+ "rustc_macros",
+ "rustc_middle",
+ "rustc_session",
+ "rustc_target",
 ]
 
 [[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, AttributeExt as _, 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

@@ -11,7 +11,7 @@ use rustc_symbol_mangling::mangle_internal_symbol;
 
 use crate::builder::SBuilder;
 use crate::declare::declare_simple_fn;
-use crate::llvm::{self, False, True, Type};
+use crate::llvm::{self, AttributeExt as _, False, True, Type};
 use crate::{SimpleCx, attributes, debuginfo};
 
 pub(crate) unsafe fn codegen(

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::{AttributeExt as _, 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,10 @@ 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, AttributeExt as _, 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, LLVMRustResultExt as _, 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/lto.rs

@@ -29,7 +29,7 @@ use crate::errors::{
     DynamicLinkingWithLTO, LlvmError, LtoBitcodeFromRlib, LtoDisallowed, LtoDylib, LtoProcMacro,
 };
 use crate::llvm::AttributePlace::Function;
-use crate::llvm::{self, build_string};
+use crate::llvm::{self, AttributeExt as _, build_string};
 use crate::{LlvmCodegenBackend, ModuleLlvm, SimpleCx, attributes};
 
 /// We keep track of the computed LTO cache keys from the previous

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -41,8 +41,8 @@ use crate::errors::{
     WithLlvmError, WriteBytecode,
 };
 use crate::llvm::diagnostic::OptimizationDiagnosticKind::*;
-use crate::llvm::{self, DiagnosticInfo};
-use crate::type_::Type;
+use crate::llvm::{self, DiagnosticInfo, LLVMRustResultExt as _};
+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

@@ -33,11 +33,11 @@ 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,
+    self, AtomicOrdering, AtomicRmwBinOp, AttributeExt as _, 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>>> {

compiler/rustc_codegen_llvm/src/builder/autodiff.rs

@@ -15,8 +15,7 @@ use crate::context::SimpleCx;
 use crate::declare::declare_simple_fn;
 use crate::errors::{AutoDiffWithoutEnable, LlvmError};
 use crate::llvm::AttributePlace::Function;
-use crate::llvm::{Metadata, True};
-use crate::value::Value;
+use crate::llvm::{AttributeExt as _, Metadata, True, Value};
 use crate::{CodegenContext, LlvmCodegenBackend, ModuleLlvm, attributes, llvm};
 
 fn get_params(fnc: &Value) -> Vec<&Value> {

compiler/rustc_codegen_llvm/src/callee.rs

@@ -11,7 +11,7 @@ use tracing::debug;
 
 use crate::context::CodegenCx;
 use crate::llvm;
-use crate::value::Value;
+use crate::llvm::Value;
 
 /// Codegens a reference to a fn/method item, monomorphizing and
 /// inlining as it goes.

compiler/rustc_codegen_llvm/src/common.rs

@@ -21,9 +21,8 @@ use tracing::debug;
 use crate::consts::const_alloc_to_llvm;
 pub(crate) use crate::context::CodegenCx;
 use crate::context::{GenericCx, SCx};
-use crate::llvm::{self, BasicBlock, Bool, ConstantInt, False, Metadata, True};
+use crate::llvm::{self, BasicBlock, Bool, ConstantInt, False, Metadata, True, Value};
 use crate::type_::Type;
-use crate::value::Value;
 
 /*
 * A note on nomenclature of linking: "extern", "foreign", and "upcall".

compiler/rustc_codegen_llvm/src/consts.rs

@@ -19,10 +19,9 @@ use tracing::{debug, instrument, trace};
 
 use crate::common::{AsCCharPtr, CodegenCx};
 use crate::errors::SymbolAlreadyDefined;
-use crate::llvm::{self, True};
+use crate::llvm::{self, True, Value};
 use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
 use crate::{base, debuginfo};
 
 pub(crate) fn const_alloc_to_llvm<'ll>(

compiler/rustc_codegen_llvm/src/context.rs

@@ -32,13 +32,13 @@ use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::{HasTargetSpec, RelocModel, SmallDataThresholdSupport, Target, TlsModel};
 use smallvec::SmallVec;
 
+use crate::abi::CallConvExt as _;
 use crate::back::write::to_llvm_code_model;
 use crate::callee::get_fn;
 use crate::common::AsCCharPtr;
 use crate::debuginfo::metadata::apply_vcall_visibility_metadata;
-use crate::llvm::Metadata;
-use crate::type_::Type;
-use crate::value::Value;
+use crate::llvm::{Metadata, Value};
+use crate::type_::{Type, type_ix_llcx};
 use crate::{attributes, common, coverageinfo, debuginfo, llvm, llvm_util};
 
 /// `TyCtxt` (and related cache datastructures) can't be move between threads.
@@ -669,7 +669,7 @@ impl<'ll> SimpleCx<'ll> {
         llcx: &'ll llvm::Context,
         pointer_size: Size,
     ) -> Self {
-        let isize_ty = llvm::Type::ix_llcx(llcx, pointer_size.bits());
+        let isize_ty = type_ix_llcx(llcx, pointer_size.bits());
         Self(SCx { llmod, llcx, isize_ty }, PhantomData)
     }
 }

compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs

@@ -2,8 +2,9 @@
 
 use std::ffi::CString;
 
+use rustc_llvm::ffi;
+
 use crate::common::AsCCharPtr;
-use crate::coverageinfo::ffi;
 use crate::llvm;
 
 pub(crate) fn covmap_var_name() -> CString {
@@ -60,10 +61,10 @@ pub(crate) fn write_filenames_to_buffer(filenames: &[impl AsRef<str>]) -> Vec<u8
 
 pub(crate) fn write_function_mappings_to_buffer(
     virtual_file_mapping: &[u32],
-    expressions: &[ffi::CounterExpression],
-    regions: &ffi::Regions,
+    expressions: &[ffi::coverageinfo::CounterExpression],
+    regions: &ffi::coverageinfo::Regions,
 ) -> Vec<u8> {
-    let ffi::Regions {
+    let ffi::coverageinfo::Regions {
         code_regions,
         expansion_regions,
         branch_regions,

compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/covfun.rs

@@ -9,6 +9,7 @@ use std::sync::Arc;
 
 use rustc_abi::Align;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods as _, ConstCodegenMethods};
+use rustc_llvm::ffi;
 use rustc_middle::mir::coverage::{
     BasicCoverageBlock, CovTerm, CoverageIdsInfo, Expression, FunctionCoverageInfo, Mapping,
     MappingKind, Op,
@@ -19,8 +20,8 @@ use rustc_target::spec::HasTargetSpec;
 use tracing::debug;
 
 use crate::common::CodegenCx;
+use crate::coverageinfo::llvm_cov;
 use crate::coverageinfo::mapgen::{GlobalFileTable, VirtualFileMapping, spans};
-use crate::coverageinfo::{ffi, llvm_cov};
 use crate::llvm;
 
 /// Intermediate coverage metadata for a single function, used to help build
@@ -32,8 +33,8 @@ pub(crate) struct CovfunRecord<'tcx> {
     is_used: bool,
 
     virtual_file_mapping: VirtualFileMapping,
-    expressions: Vec<ffi::CounterExpression>,
-    regions: ffi::Regions,
+    expressions: Vec<ffi::coverageinfo::CounterExpression>,
+    regions: ffi::coverageinfo::Regions,
 }
 
 impl<'tcx> CovfunRecord<'tcx> {
@@ -60,7 +61,7 @@ pub(crate) fn prepare_covfun_record<'tcx>(
         is_used,
         virtual_file_mapping: VirtualFileMapping::default(),
         expressions,
-        regions: ffi::Regions::default(),
+        regions: ffi::coverageinfo::Regions::default(),
     };
 
     fill_region_tables(tcx, fn_cov_info, ids_info, &mut covfun);
@@ -74,8 +75,8 @@ pub(crate) fn prepare_covfun_record<'tcx>(
 }
 
 /// Convert the function's coverage-counter expressions into a form suitable for FFI.
-fn prepare_expressions(ids_info: &CoverageIdsInfo) -> Vec<ffi::CounterExpression> {
-    let counter_for_term = ffi::Counter::from_term;
+fn prepare_expressions(ids_info: &CoverageIdsInfo) -> Vec<ffi::coverageinfo::CounterExpression> {
+    let counter_for_term = ffi::coverageinfo::Counter::from_term;
 
     // We know that LLVM will optimize out any unused expressions before
     // producing the final coverage map, so there's no need to do the same
@@ -84,11 +85,11 @@ fn prepare_expressions(ids_info: &CoverageIdsInfo) -> Vec<ffi::CounterExpression
     ids_info
         .expressions
         .iter()
-        .map(move |&Expression { lhs, op, rhs }| ffi::CounterExpression {
+        .map(move |&Expression { lhs, op, rhs }| ffi::coverageinfo::CounterExpression {
             lhs: counter_for_term(lhs),
             kind: match op {
-                Op::Add => ffi::ExprKind::Add,
-                Op::Subtract => ffi::ExprKind::Subtract,
+                Op::Add => ffi::coverageinfo::ExprKind::Add,
+                Op::Subtract => ffi::coverageinfo::ExprKind::Subtract,
             },
             rhs: counter_for_term(rhs),
         })
@@ -122,7 +123,7 @@ fn fill_region_tables<'tcx>(
         if discard_all { None } else { spans::make_coords(source_map, &source_file, span) }
     };
 
-    let ffi::Regions {
+    let ffi::coverageinfo::Regions {
         code_regions,
         expansion_regions: _, // FIXME(Zalathar): Fill out support for expansion regions
         branch_regions,
@@ -134,41 +135,48 @@ fn fill_region_tables<'tcx>(
     // form suitable for FFI.
     for &Mapping { ref kind, span } in &fn_cov_info.mappings {
         // If this function is unused, replace all counters with zero.
-        let counter_for_bcb = |bcb: BasicCoverageBlock| -> ffi::Counter {
+        let counter_for_bcb = |bcb: BasicCoverageBlock| -> ffi::coverageinfo::Counter {
             let term = if covfun.is_used {
                 ids_info.term_for_bcb[bcb].expect("every BCB in a mapping was given a term")
             } else {
                 CovTerm::Zero
             };
-            ffi::Counter::from_term(term)
+            ffi::coverageinfo::Counter::from_term(term)
         };
 
         let Some(coords) = make_coords(span) else { continue };
         let cov_span = coords.make_coverage_span(local_file_id);
 
         match *kind {
             MappingKind::Code { bcb } => {
-                code_regions.push(ffi::CodeRegion { cov_span, counter: counter_for_bcb(bcb) });
+                code_regions.push(ffi::coverageinfo::CodeRegion {
+                    cov_span,
+                    counter: counter_for_bcb(bcb),
+                });
             }
             MappingKind::Branch { true_bcb, false_bcb } => {
-                branch_regions.push(ffi::BranchRegion {
+                branch_regions.push(ffi::coverageinfo::BranchRegion {
                     cov_span,
                     true_counter: counter_for_bcb(true_bcb),
                     false_counter: counter_for_bcb(false_bcb),
                 });
             }
             MappingKind::MCDCBranch { true_bcb, false_bcb, mcdc_params } => {
-                mcdc_branch_regions.push(ffi::MCDCBranchRegion {
+                mcdc_branch_regions.push(ffi::coverageinfo::MCDCBranchRegion {
                     cov_span,
                     true_counter: counter_for_bcb(true_bcb),
                     false_counter: counter_for_bcb(false_bcb),
-                    mcdc_branch_params: ffi::mcdc::BranchParameters::from(mcdc_params),
+                    mcdc_branch_params: ffi::coverageinfo::mcdc::BranchParameters::from(
+                        mcdc_params,
+                    ),
                 });
             }
             MappingKind::MCDCDecision(mcdc_decision_params) => {
-                mcdc_decision_regions.push(ffi::MCDCDecisionRegion {
+                mcdc_decision_regions.push(ffi::coverageinfo::MCDCDecisionRegion {
                     cov_span,
-                    mcdc_decision_params: ffi::mcdc::DecisionParameters::from(mcdc_decision_params),
+                    mcdc_decision_params: ffi::coverageinfo::mcdc::DecisionParameters::from(
+                        mcdc_decision_params,
+                    ),
                 });
             }
         }