Rollup merge of rust-lang#149937 - jyn514:linker-info, r=mati865

try enabling `linker-messages` by default again

- Split out `linker-info` from `linker-messages`
- Make `linker-messages` warn-by-default; keep `linker-info` deny-by-default

Helps with rust-lang#136096.

Author: JonathanBrouwer

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -22,6 +22,7 @@ use rustc_errors::{DiagCtxtHandle, LintDiagnostic};
 use rustc_fs_util::{TempDirBuilder, fix_windows_verbatim_for_gcc, try_canonicalize};
 use rustc_hir::attrs::NativeLibKind;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
+use rustc_lint_defs::builtin::LINKER_INFO;
 use rustc_macros::LintDiagnostic;
 use rustc_metadata::fs::{METADATA_FILENAME, copy_to_stdout, emit_wrapper_file};
 use rustc_metadata::{
@@ -60,7 +61,8 @@ use super::rpath::{self, RPathConfig};
 use super::{apple, versioned_llvm_target};
 use crate::base::needs_allocator_shim_for_linking;
 use crate::{
-    CodegenResults, CompiledModule, CrateInfo, NativeLib, errors, looks_like_rust_object_file,
+    CodegenLintLevels, CodegenResults, CompiledModule, CrateInfo, NativeLib, errors,
+    looks_like_rust_object_file,
 };
 
 pub fn ensure_removed(dcx: DiagCtxtHandle<'_>, path: &Path) {
@@ -670,6 +672,145 @@ struct LinkerOutput {
     inner: String,
 }
 
+fn is_msvc_link_exe(sess: &Session) -> bool {
+    let (linker_path, flavor) = linker_and_flavor(sess);
+    sess.target.is_like_msvc
+        && flavor == LinkerFlavor::Msvc(Lld::No)
+        // Match exactly "link.exe"
+        && linker_path.to_str() == Some("link.exe")
+}
+
+fn is_macos_ld(sess: &Session) -> bool {
+    let (_, flavor) = linker_and_flavor(sess);
+    sess.target.is_like_darwin && matches!(flavor, LinkerFlavor::Darwin(_, Lld::No))
+}
+
+fn is_windows_gnu_ld(sess: &Session) -> bool {
+    let (_, flavor) = linker_and_flavor(sess);
+    sess.target.is_like_windows
+        && !sess.target.is_like_msvc
+        && matches!(flavor, LinkerFlavor::Gnu(_, Lld::No))
+}
+
+fn report_linker_output(sess: &Session, levels: CodegenLintLevels, stdout: &[u8], stderr: &[u8]) {
+    let mut escaped_stderr = escape_string(&stderr);
+    let mut escaped_stdout = escape_string(&stdout);
+    let mut linker_info = String::new();
+
+    info!("linker stderr:\n{}", &escaped_stderr);
+    info!("linker stdout:\n{}", &escaped_stdout);
+
+    fn for_each(bytes: &[u8], mut f: impl FnMut(&str, &mut String)) -> String {
+        let mut output = String::new();
+        if let Ok(str) = str::from_utf8(bytes) {
+            info!("line: {str}");
+            output = String::with_capacity(str.len());
+            for line in str.lines() {
+                f(line.trim(), &mut output);
+            }
+        }
+        escape_string(output.trim().as_bytes())
+    }
+
+    if is_msvc_link_exe(sess) {
+        info!("inferred MSVC link.exe");
+
+        escaped_stdout = for_each(&stdout, |line, output| {
+            // Hide some progress messages from link.exe that we don't care about.
+            // See https://github.com/chromium/chromium/blob/bfa41e41145ffc85f041384280caf2949bb7bd72/build/toolchain/win/tool_wrapper.py#L144-L146
+            if line.starts_with("   Creating library")
+                || line.starts_with("Generating code")
+                || line.starts_with("Finished generating code")
+            {
+                linker_info += line;
+                linker_info += "\r\n";
+            } else {
+                *output += line;
+                *output += "\r\n"
+            }
+        });
+    } else if is_macos_ld(sess) {
+        info!("inferred macOS LD");
+
+        // FIXME: Tracked by https://github.com/rust-lang/rust/issues/136113
+        let deployment_mismatch = |line: &str| {
+            line.starts_with("ld: warning: object file (")
+                && line.contains("was built for newer 'macOS' version")
+                && line.contains("than being linked")
+        };
+        // FIXME: This is a real warning we would like to show, but it hits too many crates
+        // to want to turn it on immediately.
+        let search_path = |line: &str| {
+            line.starts_with("ld: warning: search path '") && line.ends_with("' not found")
+        };
+        escaped_stderr = for_each(&stderr, |line, output| {
+            // This duplicate library warning is just not helpful at all.
+            if line.starts_with("ld: warning: ignoring duplicate libraries: ")
+                || deployment_mismatch(line)
+                || search_path(line)
+            {
+                linker_info += line;
+                linker_info += "\n";
+            } else {
+                *output += line;
+                *output += "\n"
+            }
+        });
+    } else if is_windows_gnu_ld(sess) {
+        info!("inferred Windows GNU LD");
+
+        let mut saw_exclude_symbol = false;
+        // See https://github.com/rust-lang/rust/issues/112368.
+        // FIXME: maybe check that binutils is older than 2.40 before downgrading this warning?
+        let exclude_symbols = |line: &str| {
+            line.starts_with("Warning: .drectve `-exclude-symbols:")
+                && line.ends_with("' unrecognized")
+        };
+        escaped_stderr = for_each(&stderr, |line, output| {
+            if exclude_symbols(line) {
+                saw_exclude_symbol = true;
+                linker_info += line;
+                linker_info += "\n";
+            } else if saw_exclude_symbol && line == "Warning: corrupt .drectve at end of def file" {
+                linker_info += line;
+                linker_info += "\n";
+            } else {
+                *output += line;
+                *output += "\n"
+            }
+        });
+    }
+
+    let lint_msg = |msg| {
+        lint_level(sess, LINKER_MESSAGES, levels.linker_messages, None, |diag| {
+            LinkerOutput { inner: msg }.decorate_lint(diag)
+        })
+    };
+    let lint_info = |msg| {
+        lint_level(sess, LINKER_INFO, levels.linker_info, None, |diag| {
+            LinkerOutput { inner: msg }.decorate_lint(diag)
+        })
+    };
+
+    if !escaped_stderr.is_empty() {
+        // We already print `warning:` at the start of the diagnostic. Remove it from the linker output if present.
+        escaped_stderr =
+            escaped_stderr.strip_prefix("warning: ").unwrap_or(&escaped_stderr).to_owned();
+        // Windows GNU LD prints uppercase Warning
+        escaped_stderr = escaped_stderr
+            .strip_prefix("Warning: ")
+            .unwrap_or(&escaped_stderr)
+            .replace(": warning: ", ": ");
+        lint_msg(format!("linker stderr: {escaped_stderr}"));
+    }
+    if !escaped_stdout.is_empty() {
+        lint_msg(format!("linker stdout: {}", escaped_stdout))
+    }
+    if !linker_info.is_empty() {
+        lint_info(linker_info);
+    }
+}
+
 /// Create a dynamic library or executable.
 ///
 /// This will invoke the system linker/cc to create the resulting file. This links to all upstream
@@ -856,11 +997,6 @@ fn link_natively(
 
     match prog {
         Ok(prog) => {
-            let is_msvc_link_exe = sess.target.is_like_msvc
-                && flavor == LinkerFlavor::Msvc(Lld::No)
-                // Match exactly "link.exe"
-                && linker_path.to_str() == Some("link.exe");
-
             if !prog.status.success() {
                 let mut output = prog.stderr.clone();
                 output.extend_from_slice(&prog.stdout);
@@ -880,7 +1016,7 @@ fn link_natively(
                 if let Some(code) = prog.status.code() {
                     // All Microsoft `link.exe` linking ror codes are
                     // four digit numbers in the range 1000 to 9999 inclusive
-                    if is_msvc_link_exe && (code < 1000 || code > 9999) {
+                    if is_msvc_link_exe(sess) && (code < 1000 || code > 9999) {
                         let is_vs_installed = find_msvc_tools::find_vs_version().is_ok();
                         let has_linker =
                             find_msvc_tools::find_tool(sess.target.arch.desc(), "link.exe")
@@ -912,48 +1048,13 @@ fn link_natively(
                 sess.dcx().abort_if_errors();
             }
 
-            let stderr = escape_string(&prog.stderr);
-            let mut stdout = escape_string(&prog.stdout);
-            info!("linker stderr:\n{}", &stderr);
-            info!("linker stdout:\n{}", &stdout);
-
-            // Hide some progress messages from link.exe that we don't care about.
-            // See https://github.com/chromium/chromium/blob/bfa41e41145ffc85f041384280caf2949bb7bd72/build/toolchain/win/tool_wrapper.py#L144-L146
-            if is_msvc_link_exe {
-                if let Ok(str) = str::from_utf8(&prog.stdout) {
-                    let mut output = String::with_capacity(str.len());
-                    for line in stdout.lines() {
-                        if line.starts_with("   Creating library")
-                            || line.starts_with("Generating code")
-                            || line.starts_with("Finished generating code")
-                        {
-                            continue;
-                        }
-                        output += line;
-                        output += "\r\n"
-                    }
-                    stdout = escape_string(output.trim().as_bytes())
-                }
-            }
-
-            let level = codegen_results.crate_info.lint_levels.linker_messages;
-            let lint = |msg| {
-                lint_level(sess, LINKER_MESSAGES, level, None, |diag| {
-                    LinkerOutput { inner: msg }.decorate_lint(diag)
-                })
-            };
-
-            if !prog.stderr.is_empty() {
-                // We already print `warning:` at the start of the diagnostic. Remove it from the linker output if present.
-                let stderr = stderr
-                    .strip_prefix("warning: ")
-                    .unwrap_or(&stderr)
-                    .replace(": warning: ", ": ");
-                lint(format!("linker stderr: {stderr}"));
-            }
-            if !stdout.is_empty() {
-                lint(format!("linker stdout: {}", stdout))
-            }
+            info!("reporting linker output: flavor={flavor:?}");
+            report_linker_output(
+                sess,
+                codegen_results.crate_info.lint_levels,
+                &prog.stdout,
+                &prog.stderr,
+            );
         }
         Err(e) => {
             let linker_not_found = e.kind() == io::ErrorKind::NotFound;

compiler/rustc_codegen_ssa/src/lib.rs

@@ -24,6 +24,7 @@ use rustc_data_structures::unord::UnordMap;
 use rustc_hir::CRATE_HIR_ID;
 use rustc_hir::attrs::{CfgEntry, NativeLibKind, WindowsSubsystemKind};
 use rustc_hir::def_id::CrateNum;
+use rustc_lint_defs::builtin::LINKER_INFO;
 use rustc_macros::{Decodable, Encodable};
 use rustc_metadata::EncodedMetadata;
 use rustc_middle::dep_graph::WorkProduct;
@@ -361,10 +362,14 @@ impl CodegenResults {
 #[derive(Copy, Clone, Debug, Encodable, Decodable)]
 pub struct CodegenLintLevels {
     linker_messages: LevelAndSource,
+    linker_info: LevelAndSource,
 }
 
 impl CodegenLintLevels {
     pub fn from_tcx(tcx: TyCtxt<'_>) -> Self {
-        Self { linker_messages: tcx.lint_level_at_node(LINKER_MESSAGES, CRATE_HIR_ID) }
+        Self {
+            linker_messages: tcx.lint_level_at_node(LINKER_MESSAGES, CRATE_HIR_ID),
+            linker_info: tcx.lint_level_at_node(LINKER_INFO, CRATE_HIR_ID),
+        }
     }
 }

compiler/rustc_lint_defs/src/builtin.rs

@@ -60,6 +60,7 @@ declare_lint_pass! {
         LARGE_ASSIGNMENTS,
         LATE_BOUND_LIFETIME_ARGUMENTS,
         LEGACY_DERIVE_HELPERS,
+        LINKER_INFO,
         LINKER_MESSAGES,
         LONG_RUNNING_CONST_EVAL,
         LOSSY_PROVENANCE_CASTS,
@@ -4063,10 +4064,44 @@ declare_lint! {
     /// and actionable warning of similar quality to our other diagnostics. See this tracking
     /// issue for more details: <https://github.com/rust-lang/rust/issues/136096>.
     pub LINKER_MESSAGES,
-    Allow,
+    Warn,
     "warnings emitted at runtime by the target-specific linker program"
 }
 
+declare_lint! {
+    /// The `linker_info` lint forwards warnings from the linker that are known to be informational-only.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore (needs CLI args, platform-specific)
+    /// #[warn(linker_info)]
+    /// fn main () {}
+    /// ```
+    ///
+    /// On MacOS, using `-C link-arg=-lc` and the default linker, this will produce
+    ///
+    /// ```text
+    /// warning: linker stderr: ld: ignoring duplicate libraries: '-lc'
+    ///   |
+    /// note: the lint level is defined here
+    ///  --> ex.rs:1:9
+    ///   |
+    /// 1 | #![warn(linker_info)]
+    ///   |         ^^^^^^^^^^^^^^^
+    /// ```
+    ///
+    /// ### Explanation
+    ///
+    /// Many linkers are very "chatty" and print lots of information that is not necessarily
+    /// indicative of an issue. This output has been ignored for many years and is often not
+    /// actionable by developers. It is silenced unless the developer specifically requests for it
+    /// to be printed. See this tracking issue for more details:
+    /// <https://github.com/rust-lang/rust/issues/136096>.
+    pub LINKER_INFO,
+    Allow,
+    "linker warnings known to be informational-only and not indicative of a problem"
+}
+
 declare_lint! {
     /// The `named_arguments_used_positionally` lint detects cases where named arguments are only
     /// used positionally in format strings. This usage is valid but potentially very confusing.

compiler/rustc_passes/src/check_attr.rs

@@ -1589,7 +1589,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         } else if attr.has_any_name(&[sym::allow, sym::warn, sym::deny, sym::forbid, sym::expect])
             && let Some(meta) = attr.meta_item_list()
             && meta.iter().any(|meta| {
-                meta.meta_item().map_or(false, |item| item.path == sym::linker_messages)
+                meta.meta_item().map_or(false, |item| {
+                    item.path == sym::linker_messages || item.path == sym::linker_info
+                })
             })
         {
             if hir_id != CRATE_HIR_ID {

compiler/rustc_passes/src/errors.rs

@@ -318,7 +318,7 @@ pub(crate) enum UnusedNote {
     #[note("`default_method_body_is_const` has been replaced with `const` on traits")]
     DefaultMethodBodyConst,
     #[note(
-        "the `linker_messages` lint can only be controlled at the root of a crate that needs to be linked"
+        "the `linker_messages` and `linker_info` lints can only be controlled at the root of a crate that needs to be linked"
     )]
     LinkerMessagesBinaryCrateOnly,
 }

compiler/rustc_span/src/symbol.rs

@@ -1362,6 +1362,7 @@ symbols! {
         link_section,
         linkage,
         linker,
+        linker_info,
         linker_messages,
         linkonce,
         linkonce_odr,

src/tools/tidy/src/ui_tests.rs

@@ -215,6 +215,7 @@ fn check_unexpected_extension(check: &mut RunningCheck, file_path: &Path, ext: &
         "fixed",  // expected source file after applying fixes
         "md",     // test directory descriptions
         "ftl",    // translation tests
+        "ps1",    // powershell scripts, used for fake linkers on Windows
     ];
 
     const EXTENSION_EXCEPTION_PATHS: &[&str] = &[

tests/run-make/macos-deployment-target-warning/foo.c

@@ -0,0 +1 @@
+void foo() {}

tests/run-make/macos-deployment-target-warning/main.rs

@@ -0,0 +1,8 @@
+#![warn(linker_info, linker_messages)]
+unsafe extern "C" {
+    safe fn foo();
+}
+
+fn main() {
+    foo();
+}

tests/run-make/macos-deployment-target-warning/rmake.rs

@@ -0,0 +1,29 @@
+//@ only-apple
+//! Tests that deployment target linker warnings are shown as `linker-info`, not `linker-messages`
+
+use run_make_support::external_deps::c_cxx_compiler::cc;
+use run_make_support::external_deps::llvm::llvm_ar;
+use run_make_support::{bare_rustc, diff};
+
+fn main() {
+    let cwd = std::env::current_dir().unwrap().to_str().unwrap().to_owned();
+
+    cc().arg("-c").arg("-mmacosx-version-min=15.5").output("foo.o").input("foo.c").run();
+    llvm_ar().obj_to_ar().output_input("libfoo.a", "foo.o").run();
+
+    let warnings = bare_rustc()
+        .arg("-L")
+        .arg(format!("native={cwd}"))
+        .arg("-lstatic=foo")
+        .link_arg("-mmacosx-version-min=11.2")
+        .input("main.rs")
+        .crate_type("bin")
+        .run()
+        .stderr_utf8();
+
+    diff()
+        .expected_file("warnings.txt")
+        .actual_text("(rustc -W linker-info)", &warnings)
+        .normalize(r"\(.*/rmake_out/", "(TEST_DIR/")
+        .run()
+}