Stop using dlltool for generating import libraries on MinGW

Older versions of ld.bfd didn't support short import libraries like the
builtin implementation of rustc generates. So we worked around this by
using binutils dlltool, which produces the old import library format. We
have now bumped the minimum supported ld.bfd version to one which does
support them, so we can drop the dlltool usage. This makes
cross-compilation a bit easier and removes a bunch of code in rustc.

Author: bjorn3

compiler/rustc_codegen_ssa/src/back/archive.rs

@@ -1,6 +1,4 @@
-use std::env;
 use std::error::Error;
-use std::ffi::OsString;
 use std::fs::{self, File};
 use std::io::{self, BufWriter, Write};
 use std::path::{Path, PathBuf};
@@ -22,13 +20,9 @@ use tracing::trace;
 
 use super::metadata::{create_compressed_metadata_file, search_for_section};
 use super::rmeta_link;
-use crate::common;
 // Public for ArchiveBuilderBuilder::extract_bundled_libs
 pub use crate::errors::ExtractBundledLibsError;
-use crate::errors::{
-    ArchiveBuildFailure, DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorCreatingImportLibrary,
-    ErrorWritingDEFFile, UnknownArchiveKind,
-};
+use crate::errors::{ArchiveBuildFailure, ErrorCreatingImportLibrary, UnknownArchiveKind};
 
 /// An item to be included in an import library.
 /// This is a slimmed down version of `COFFShortExport` from `ar-archive-writer`.
@@ -85,66 +79,57 @@ pub trait ArchiveBuilderBuilder {
         items: Vec<ImportLibraryItem>,
         output_path: &Path,
     ) {
-        if common::is_mingw_gnu_toolchain(&sess.target) {
-            // The binutils linker used on -windows-gnu targets cannot read the import
-            // libraries generated by LLVM: in our attempts, the linker produced an .EXE
-            // that loaded but crashed with an AV upon calling one of the imported
-            // functions. Therefore, use binutils to create the import library instead,
-            // by writing a .DEF file to the temp dir and calling binutils's dlltool.
-            create_mingw_dll_import_lib(sess, lib_name, items, output_path);
-        } else {
-            trace!("creating import library");
-            trace!("  dll_name {:#?}", lib_name);
-            trace!("  output_path {}", output_path.display());
-            trace!(
-                "  import names: {}",
-                items
-                    .iter()
-                    .map(|ImportLibraryItem { name, .. }| name.clone())
-                    .collect::<Vec<_>>()
-                    .join(", "),
-            );
-
-            // All import names are Rust identifiers and therefore cannot contain \0 characters.
-            // FIXME: when support for #[link_name] is implemented, ensure that the import names
-            // still don't contain any \0 characters. Also need to check that the names don't
-            // contain substrings like " @" or "NONAME" that are keywords or otherwise reserved
-            // in definition files.
-
-            let mut file = match fs::File::create_new(&output_path) {
-                Ok(file) => file,
-                Err(error) => sess
-                    .dcx()
-                    .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() }),
-            };
+        trace!("creating import library");
+        trace!("  dll_name {:#?}", lib_name);
+        trace!("  output_path {}", output_path.display());
+        trace!(
+            "  import names: {}",
+            items
+                .iter()
+                .map(|ImportLibraryItem { name, .. }| name.clone())
+                .collect::<Vec<_>>()
+                .join(", "),
+        );
+
+        // All import names are Rust identifiers and therefore cannot contain \0 characters.
+        // FIXME: when support for #[link_name] is implemented, ensure that the import names
+        // still don't contain any \0 characters. Also need to check that the names don't
+        // contain substrings like " @" or "NONAME" that are keywords or otherwise reserved
+        // in definition files.
+
+        let mut file = match fs::File::create_new(&output_path) {
+            Ok(file) => file,
+            Err(error) => sess
+                .dcx()
+                .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() }),
+        };
 
-            let exports =
-                items.into_iter().map(|item| item.into_coff_short_export(sess)).collect::<Vec<_>>();
-            let machine = match &sess.target.arch {
-                Arch::X86_64 => MachineTypes::AMD64,
-                Arch::X86 => MachineTypes::I386,
-                Arch::AArch64 => MachineTypes::ARM64,
-                Arch::Arm64EC => MachineTypes::ARM64EC,
-                Arch::Arm => MachineTypes::ARMNT,
-                cpu => panic!("unsupported cpu type {cpu}"),
-            };
+        let exports =
+            items.into_iter().map(|item| item.into_coff_short_export(sess)).collect::<Vec<_>>();
+        let machine = match &sess.target.arch {
+            Arch::X86_64 => MachineTypes::AMD64,
+            Arch::X86 => MachineTypes::I386,
+            Arch::AArch64 => MachineTypes::ARM64,
+            Arch::Arm64EC => MachineTypes::ARM64EC,
+            Arch::Arm => MachineTypes::ARMNT,
+            cpu => panic!("unsupported cpu type {cpu}"),
+        };
 
-            if let Err(error) = ar_archive_writer::write_import_library(
-                &mut file,
-                lib_name,
-                &exports,
-                machine,
-                !sess.target.is_like_msvc,
-                // Enable compatibility with MSVC's `/WHOLEARCHIVE` flag.
-                // Without this flag a duplicate symbol error would be emitted
-                // when linking a rust staticlib using `/WHOLEARCHIVE`.
-                // See #129020
-                true,
-                &[],
-            ) {
-                sess.dcx()
-                    .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() });
-            }
+        if let Err(error) = ar_archive_writer::write_import_library(
+            &mut file,
+            lib_name,
+            &exports,
+            machine,
+            !sess.target.is_like_msvc,
+            // Enable compatibility with MSVC's `/WHOLEARCHIVE` flag.
+            // Without this flag a duplicate symbol error would be emitted
+            // when linking a rust staticlib using `/WHOLEARCHIVE`.
+            // See #129020
+            true,
+            &[],
+        ) {
+            sess.dcx()
+                .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() });
         }
     }
 
@@ -185,129 +170,6 @@ pub trait ArchiveBuilderBuilder {
     }
 }
 
-fn create_mingw_dll_import_lib(
-    sess: &Session,
-    lib_name: &str,
-    items: Vec<ImportLibraryItem>,
-    output_path: &Path,
-) {
-    let def_file_path = output_path.with_extension("def");
-
-    let def_file_content = format!(
-        "EXPORTS\n{}",
-        items
-            .into_iter()
-            .map(|ImportLibraryItem { name, ordinal, .. }| {
-                match ordinal {
-                    Some(n) => format!("{name} @{n} NONAME"),
-                    None => name,
-                }
-            })
-            .collect::<Vec<String>>()
-            .join("\n")
-    );
-
-    match std::fs::write(&def_file_path, def_file_content) {
-        Ok(_) => {}
-        Err(e) => {
-            sess.dcx().emit_fatal(ErrorWritingDEFFile { error: e });
-        }
-    };
-
-    // --no-leading-underscore: For the `import_name_type` feature to work, we need to be
-    // able to control the *exact* spelling of each of the symbols that are being imported:
-    // hence we don't want `dlltool` adding leading underscores automatically.
-    let dlltool = find_binutils_dlltool(sess);
-    // temp_prefix doesn't handle paths with spaces so
-    // use a relative path and set the current working directory
-    let cwd = output_path.parent().unwrap_or(output_path);
-    let temp_prefix = lib_name;
-    // dlltool target architecture args from:
-    // https://github.com/llvm/llvm-project-release-prs/blob/llvmorg-15.0.6/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp#L69
-    let (dlltool_target_arch, dlltool_target_bitness) = match &sess.target.arch {
-        Arch::X86_64 => ("i386:x86-64", "--64"),
-        Arch::X86 => ("i386", "--32"),
-        Arch::AArch64 => ("arm64", "--64"),
-        Arch::Arm => ("arm", "--32"),
-        arch => panic!("unsupported arch {arch}"),
-    };
-    let mut dlltool_cmd = std::process::Command::new(&dlltool);
-    dlltool_cmd
-        .arg("-d")
-        .arg(def_file_path)
-        .arg("-D")
-        .arg(lib_name)
-        .arg("-l")
-        .arg(&output_path)
-        .arg("-m")
-        .arg(dlltool_target_arch)
-        .arg("-f")
-        .arg(dlltool_target_bitness)
-        .arg("--no-leading-underscore")
-        .arg("--temp-prefix")
-        .arg(temp_prefix)
-        .current_dir(cwd);
-
-    match dlltool_cmd.output() {
-        Err(e) => {
-            sess.dcx().emit_fatal(ErrorCallingDllTool {
-                dlltool_path: dlltool.to_string_lossy(),
-                error: e,
-            });
-        }
-        // dlltool returns '0' on failure, so check for error output instead.
-        Ok(output) if !output.stderr.is_empty() => {
-            sess.dcx().emit_fatal(DlltoolFailImportLibrary {
-                dlltool_path: dlltool.to_string_lossy(),
-                dlltool_args: dlltool_cmd
-                    .get_args()
-                    .map(|arg| arg.to_string_lossy())
-                    .collect::<Vec<_>>()
-                    .join(" "),
-                stdout: String::from_utf8_lossy(&output.stdout),
-                stderr: String::from_utf8_lossy(&output.stderr),
-            })
-        }
-        _ => {}
-    }
-}
-
-fn find_binutils_dlltool(sess: &Session) -> OsString {
-    assert!(sess.target.options.is_like_windows && !sess.target.options.is_like_msvc);
-    if let Some(dlltool_path) = &sess.opts.cg.dlltool {
-        return dlltool_path.clone().into_os_string();
-    }
-
-    let tool_name: OsString = if sess.host.options.is_like_windows {
-        // If we're compiling on Windows, always use "dlltool.exe".
-        "dlltool.exe"
-    } else {
-        // On other platforms, use the architecture-specific name.
-        match sess.target.arch {
-            Arch::X86_64 => "x86_64-w64-mingw32-dlltool",
-            Arch::X86 => "i686-w64-mingw32-dlltool",
-            Arch::AArch64 => "aarch64-w64-mingw32-dlltool",
-
-            // For non-standard architectures (e.g., aarch32) fallback to "dlltool".
-            _ => "dlltool",
-        }
-    }
-    .into();
-
-    // NOTE: it's not clear how useful it is to explicitly search PATH.
-    for dir in env::split_paths(&env::var_os("PATH").unwrap_or_default()) {
-        let full_path = dir.join(&tool_name);
-        if full_path.is_file() {
-            return full_path.into_os_string();
-        }
-    }
-
-    // The user didn't specify the location of the dlltool binary, and we weren't able
-    // to find the appropriate one on the PATH. Just return the name of the tool
-    // and let the invocation fail with a hopefully useful error message.
-    tool_name
-}
-
 pub enum AddArchiveKind<'a> {
     Rlib(/*skip*/ &'a dyn Fn(&str, ArchiveEntryKind) -> bool),
     Other,

compiler/rustc_codegen_ssa/src/errors.rs

@@ -1103,32 +1103,6 @@ pub struct FailedToGetLayout<'tcx> {
     pub err: LayoutError<'tcx>,
 }
 
-#[derive(Diagnostic)]
-#[diag(
-    "dlltool could not create import library with {$dlltool_path} {$dlltool_args}:
-{$stdout}
-{$stderr}"
-)]
-pub(crate) struct DlltoolFailImportLibrary<'a> {
-    pub dlltool_path: Cow<'a, str>,
-    pub dlltool_args: String,
-    pub stdout: Cow<'a, str>,
-    pub stderr: Cow<'a, str>,
-}
-
-#[derive(Diagnostic)]
-#[diag("error writing .DEF file: {$error}")]
-pub(crate) struct ErrorWritingDEFFile {
-    pub error: std::io::Error,
-}
-
-#[derive(Diagnostic)]
-#[diag("error calling dlltool '{$dlltool_path}': {$error}")]
-pub(crate) struct ErrorCallingDllTool<'a> {
-    pub dlltool_path: Cow<'a, str>,
-    pub error: std::io::Error,
-}
-
 #[derive(Diagnostic)]
 #[diag("failed to create remark directory: {$error}")]
 pub(crate) struct ErrorCreatingRemarkDir {

compiler/rustc_interface/src/tests.rs

@@ -580,7 +580,6 @@ fn test_codegen_options_tracking_hash() {
     // tidy-alphabetical-start
     untracked!(codegen_units, Some(42));
     untracked!(default_linker_libraries, true);
-    untracked!(dlltool, Some(PathBuf::from("custom_dlltool.exe")));
     untracked!(extra_filename, String::from("extra-filename"));
     untracked!(incremental, Some(String::from("abc")));
     // `link_arg` is omitted because it just forwards to `link_args`.

compiler/rustc_interface/src/util.rs

@@ -8,7 +8,7 @@ use std::{env, thread};
 use rand::{RngCore, rng};
 use rustc_ast as ast;
 use rustc_attr_parsing::ShouldEmit;
-use rustc_codegen_ssa::back::archive::{ArArchiveBuilderBuilder, ArchiveBuilderBuilder};
+use rustc_codegen_ssa::back::archive::ArArchiveBuilderBuilder;
 use rustc_codegen_ssa::back::link::link_binary;
 use rustc_codegen_ssa::target_features::cfg_target_feature;
 use rustc_codegen_ssa::traits::CodegenBackend;
@@ -443,7 +443,7 @@ impl CodegenBackend for DummyCodegenBackend {
 
         link_binary(
             sess,
-            &DummyArchiveBuilderBuilder,
+            &ArArchiveBuilderBuilder,
             compiled_modules,
             crate_info,
             metadata,
@@ -453,28 +453,6 @@ impl CodegenBackend for DummyCodegenBackend {
     }
 }
 
-struct DummyArchiveBuilderBuilder;
-
-impl ArchiveBuilderBuilder for DummyArchiveBuilderBuilder {
-    fn new_archive_builder<'a>(
-        &self,
-        sess: &'a Session,
-    ) -> Box<dyn rustc_codegen_ssa::back::archive::ArchiveBuilder + 'a> {
-        ArArchiveBuilderBuilder.new_archive_builder(sess)
-    }
-
-    fn create_dll_import_lib(
-        &self,
-        sess: &Session,
-        _lib_name: &str,
-        _items: Vec<rustc_codegen_ssa::back::archive::ImportLibraryItem>,
-        output_path: &Path,
-    ) {
-        // Build an empty static library to avoid calling an external dlltool on mingw
-        ArArchiveBuilderBuilder.new_archive_builder(sess).build(output_path);
-    }
-}
-
 // This is used for rustdoc, but it uses similar machinery to codegen backend
 // loading, so we leave the code here. It is potentially useful for other tools
 // that want to invoke the rustc binary while linking to rustc as well.

compiler/rustc_session/src/options.rs

@@ -2084,8 +2084,9 @@ options! {
         line-tables-only, limited, or full; default: 0)"),
     default_linker_libraries: bool = (false, parse_bool, [UNTRACKED],
         "allow the linker to link its default libraries (default: no)"),
-    dlltool: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
-        "import library generation tool (ignored except when targeting windows-gnu)"),
+    dlltool: () = ((), parse_ignore, [UNTRACKED],
+        "this option has been removed",
+        removed: Warn),
     #[rustc_lint_opt_deny_field_access("use `Session::dwarf_version` instead of this field")]
     dwarf_version: Option<u32> = (None, parse_opt_number, [TRACKED],
         "version of DWARF debug information to emit (default: 2 or 4, depending on platform)"),

compiler/rustc_target/src/spec/mod.rs

@@ -644,7 +644,7 @@ bitflags::bitflags! {
         const LIBC        = 1 << 1;
         /// libgcc/libunwind (e.g. on `windows-gnu`, `fuchsia`, `fortanix`, `gnullvm` targets)
         const UNWIND      = 1 << 2;
-        /// Linker, dlltool, and their necessary libraries (e.g. on `windows-gnu` and for `rust-lld`)
+        /// Linker and its necessary libraries (e.g. for `rust-lld`)
         const LINKER      = 1 << 3;
         /// Sanitizer runtime libraries
         const SANITIZERS  = 1 << 4;

src/bootstrap/src/core/build_steps/dist.rs

@@ -224,7 +224,7 @@ fn make_win_dist(plat_root: &Path, target: TargetSelection, builder: &Builder<'_
     } else {
         "gcc.exe"
     };
-    let target_tools = [compiler, "ld.exe", "dlltool.exe", "libwinpthread-1.dll"];
+    let target_tools = [compiler, "ld.exe", "libwinpthread-1.dll"];
 
     // Libraries necessary to link the windows-gnu toolchains.
     // System libraries will be preferred if they are available (see #67429).