make it possible to silence linker warnings with a crate-level attribute

this was slightly complicated because codegen_ssa doesn't have access to a tcx.

Author: jyn514

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -15,13 +15,14 @@ use rustc_ast::CRATE_NODE_ID;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::memmap::Mmap;
 use rustc_data_structures::temp_dir::MaybeTempDir;
-use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, FatalError};
+use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, FatalError, LintDiagnostic};
 use rustc_fs_util::{fix_windows_verbatim_for_gcc, try_canonicalize};
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
-use rustc_macros::Diagnostic;
+use rustc_macros::LintDiagnostic;
 use rustc_metadata::fs::{METADATA_FILENAME, copy_to_stdout, emit_wrapper_file};
 use rustc_metadata::{find_native_static_library, walk_native_lib_search_dirs};
 use rustc_middle::bug;
+use rustc_middle::lint::lint_level;
 use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::middle::dependency_format::Linkage;
 use rustc_middle::middle::exported_symbols::SymbolExportKind;
@@ -30,6 +31,7 @@ use rustc_session::config::{
     OutputType, PrintKind, SplitDwarfKind, Strip,
 };
 use rustc_session::cstore::DllImport;
+use rustc_session::lint::builtin::LINKER_MESSAGES;
 use rustc_session::output::{check_file_is_writeable, invalid_output_for_target, out_filename};
 use rustc_session::search_paths::PathKind;
 use rustc_session::utils::NativeLibKind;
@@ -763,7 +765,7 @@ fn link_dwarf_object(sess: &Session, cg_results: &CodegenResults, executable_out
     }
 }
 
-#[derive(Diagnostic)]
+#[derive(LintDiagnostic)]
 #[diag(codegen_ssa_linker_output)]
 /// Translating this is kind of useless. We don't pass translation flags to the linker, so we'd just
 /// end up with inconsistent languages within the same diagnostic.
@@ -1055,6 +1057,13 @@ fn link_natively(
                 sess.dcx().abort_if_errors();
             }
 
+            let (level, src) = codegen_results.crate_info.lint_levels.linker_messages;
+            let lint = |msg| {
+                lint_level(sess, LINKER_MESSAGES, level, src, 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 = escape_string(&prog.stderr);
@@ -1063,12 +1072,10 @@ fn link_natively(
                     .strip_prefix("warning: ")
                     .unwrap_or(&stderr)
                     .replace(": warning: ", ": ");
-                sess.dcx().emit_warn(LinkerOutput { inner: format!("linker stderr: {stderr}") });
+                lint(format!("linker stderr: {stderr}"));
             }
             if !prog.stdout.is_empty() && sess.opts.verbose {
-                sess.dcx().emit_warn(LinkerOutput {
-                    inner: format!("linker stdout: {}", escape_string(&prog.stdout)),
-                });
+                lint(format!("linker stdout: {}", escape_string(&prog.stdout)))
             }
         }
         Err(e) => {

compiler/rustc_codegen_ssa/src/lib.rs

@@ -29,18 +29,23 @@ use rustc_ast as ast;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::unord::UnordMap;
+use rustc_hir::CRATE_HIR_ID;
 use rustc_hir::def_id::CrateNum;
 use rustc_macros::{Decodable, Encodable, HashStable};
 use rustc_middle::dep_graph::WorkProduct;
+use rustc_middle::lint::LintLevelSource;
 use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::middle::dependency_format::Dependencies;
 use rustc_middle::middle::exported_symbols::SymbolExportKind;
+use rustc_middle::ty::TyCtxt;
 use rustc_middle::util::Providers;
 use rustc_serialize::opaque::{FileEncoder, MemDecoder};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use rustc_session::Session;
 use rustc_session::config::{CrateType, OutputFilenames, OutputType, RUST_CGU_EXT};
 use rustc_session::cstore::{self, CrateSource};
+use rustc_session::lint::Level;
+use rustc_session::lint::builtin::LINKER_MESSAGES;
 use rustc_session::utils::NativeLibKind;
 use rustc_span::symbol::Symbol;
 
@@ -303,3 +308,19 @@ impl CodegenResults {
         Ok((codegen_results, outputs))
     }
 }
+
+/// A list of lint levels used in codegen.
+///
+/// When using `-Z link-only`, we don't have access to the tcx and must work
+/// solely from the `.rlink` file. `Lint`s are defined too early to be encodeable.
+/// Instead, encode exactly the information we need.
+#[derive(Copy, Clone, Debug, Encodable, Decodable)]
+pub struct CodegenLintLevels {
+    linker_messages: (Level, LintLevelSource),
+}
+
+impl CodegenLintLevels {
+    pub fn from_tcx(tcx: TyCtxt<'_>) -> Self {
+        Self { linker_messages: tcx.lint_level_at_node(LINKER_MESSAGES, CRATE_HIR_ID) }
+    }
+}

compiler/rustc_lint/src/levels.rs

@@ -130,12 +130,17 @@ fn lints_that_dont_need_to_run(tcx: TyCtxt<'_>, (): ()) -> FxIndexSet<LintId> {
             !has_future_breakage && !lint.eval_always
         })
         .filter_map(|lint| {
-            let lint_level = map.lint_level_id_at_node(tcx, LintId::of(lint), CRATE_HIR_ID);
-            if matches!(lint_level, (Level::Allow, ..))
-                || (matches!(lint_level, (.., LintLevelSource::Default)))
-                    && lint.default_level(tcx.sess.edition()) == Level::Allow
-            {
-                Some(LintId::of(lint))
+            if !lint.eval_always {
+                let lint_level =
+                    map.lint_level_id_at_node(Some(tcx), tcx.sess, LintId::of(lint), CRATE_HIR_ID);
+                if matches!(lint_level, (Level::Allow, ..))
+                    || (matches!(lint_level, (.., LintLevelSource::Default)))
+                        && lint.default_level(tcx.sess.edition()) == Level::Allow
+                {
+                    Some(LintId::of(lint))
+                } else {
+                    None
+                }
             } else {
                 None
             }
@@ -248,8 +253,8 @@ impl LintLevelsProvider for LintLevelQueryMap<'_> {
     fn insert(&mut self, id: LintId, lvl: LevelAndSource) {
         self.specs.specs.get_mut_or_insert_default(self.cur.local_id).insert(id, lvl);
     }
-    fn get_lint_level(&self, lint: &'static Lint, _: &Session) -> LevelAndSource {
-        self.specs.lint_level_id_at_node(self.tcx, LintId::of(lint), self.cur)
+    fn get_lint_level(&self, lint: &'static Lint, sess: &Session) -> LevelAndSource {
+        self.specs.lint_level_id_at_node(Some(self.tcx), sess, LintId::of(lint), self.cur)
     }
     fn push_expectation(&mut self, id: LintExpectationId, expectation: LintExpectation) {
         self.specs.expectations.push((id, expectation))

compiler/rustc_lint_defs/src/builtin.rs

@@ -60,6 +60,7 @@ declare_lint_pass! {
         LARGE_ASSIGNMENTS,
         LATE_BOUND_LIFETIME_ARGUMENTS,
         LEGACY_DERIVE_HELPERS,
+        LINKER_MESSAGES,
         LONG_RUNNING_CONST_EVAL,
         LOSSY_PROVENANCE_CASTS,
         MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
@@ -4080,6 +4081,39 @@ declare_lint! {
     "call to foreign functions or function pointers with FFI-unwind ABI"
 }
 
+declare_lint! {
+    /// The `linker_messages` lint forwards warnings from the linker.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore (needs CLI args, platform-specific)
+    /// extern "C" {
+    ///   fn foo();
+    /// }
+    /// fn main () { unsafe { foo(); } }
+    /// ```
+    ///
+    /// On Linux, using `gcc -Wl,--warn-unresolved-symbols` as a linker, this will produce
+    ///
+    /// ```text
+    /// warning: linker stderr: rust-lld: undefined symbol: foo
+    ///          >>> referenced by rust_out.69edbd30df4ae57d-cgu.0
+    ///          >>>               rust_out.rust_out.69edbd30df4ae57d-cgu.0.rcgu.o:(rust_out::main::h3a90094b06757803)
+    ///   |
+    ///   = note: `#[warn(linker_messages)]` on by default
+    ///
+    /// warning: 1 warning emitted
+    /// ```
+    ///
+    /// ### Explanation
+    ///
+    /// Linkers emit platform-specific and program-specific warnings that cannot be predicted in advance by the rust compiler.
+    /// They are forwarded by default, but can be disabled by adding `#![allow(linker_messages)]` at the crate root.
+    pub LINKER_MESSAGES,
+    Warn,
+    "warnings emitted at runtime by the target-specific linker program"
+}
+
 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_lint_defs/src/lib.rs

@@ -161,7 +161,19 @@ impl<HCX: rustc_hir::HashStableContext> ToStableHashKey<HCX> for LintExpectation
 /// Setting for how to handle a lint.
 ///
 /// See: <https://doc.rust-lang.org/rustc/lints/levels.html>
-#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash, HashStable_Generic)]
+#[derive(
+    Clone,
+    Copy,
+    PartialEq,
+    PartialOrd,
+    Eq,
+    Ord,
+    Debug,
+    Hash,
+    Encodable,
+    Decodable,
+    HashStable_Generic
+)]
 pub enum Level {
     /// The `allow` level will not issue any message.
     Allow,

compiler/rustc_middle/src/lint.rs

@@ -3,8 +3,8 @@ use std::cmp;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_errors::{Diag, MultiSpan};
-use rustc_hir::{HirId, ItemLocalId};
-use rustc_macros::HashStable;
+use rustc_hir::{CRATE_HIR_ID, HirId, ItemLocalId};
+use rustc_macros::{Decodable, Encodable, HashStable};
 use rustc_session::Session;
 use rustc_session::lint::builtin::{self, FORBIDDEN_LINT_GROUPS};
 use rustc_session::lint::{FutureIncompatibilityReason, Level, Lint, LintExpectationId, LintId};
@@ -15,7 +15,7 @@ use tracing::instrument;
 use crate::ty::TyCtxt;
 
 /// How a lint level was set.
-#[derive(Clone, Copy, PartialEq, Eq, HashStable, Debug)]
+#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, HashStable, Debug)]
 pub enum LintLevelSource {
     /// Lint is at the default level as declared in rustc.
     Default,
@@ -119,7 +119,7 @@ impl ShallowLintLevelMap {
     #[instrument(level = "trace", skip(self, tcx), ret)]
     fn probe_for_lint_level(
         &self,
-        tcx: TyCtxt<'_>,
+        tcx: Option<TyCtxt<'_>>,
         id: LintId,
         start: HirId,
     ) -> (Option<Level>, LintLevelSource) {
@@ -132,31 +132,38 @@ impl ShallowLintLevelMap {
         let mut owner = start.owner;
         let mut specs = &self.specs;
 
-        for parent in tcx.hir().parent_id_iter(start) {
-            if parent.owner != owner {
-                owner = parent.owner;
-                specs = &tcx.shallow_lint_levels_on(owner).specs;
-            }
-            if let Some(map) = specs.get(&parent.local_id)
-                && let Some(&(level, src)) = map.get(&id)
-            {
-                return (Some(level), src);
+        if let Some(tcx) = tcx {
+            for parent in tcx.hir().parent_id_iter(start) {
+                if parent.owner != owner {
+                    owner = parent.owner;
+                    specs = &tcx.shallow_lint_levels_on(owner).specs;
+                }
+                if let Some(map) = specs.get(&parent.local_id)
+                    && let Some(&(level, src)) = map.get(&id)
+                {
+                    return (Some(level), src);
+                }
             }
         }
 
         (None, LintLevelSource::Default)
     }
 
     /// Fetch and return the user-visible lint level for the given lint at the given HirId.
-    #[instrument(level = "trace", skip(self, tcx), ret)]
+    #[instrument(level = "trace", skip(self, tcx, sess), ret)]
     pub fn lint_level_id_at_node(
         &self,
-        tcx: TyCtxt<'_>,
+        tcx: Option<TyCtxt<'_>>,
+        sess: &Session,
         lint: LintId,
         cur: HirId,
     ) -> (Level, LintLevelSource) {
+        assert!(
+            tcx.is_some() || cur == CRATE_HIR_ID,
+            "must pass in a tcx to access any level other than the root"
+        );
         let (level, mut src) = self.probe_for_lint_level(tcx, lint, cur);
-        let level = reveal_actual_level(level, &mut src, tcx.sess, lint, |lint| {
+        let level = reveal_actual_level(level, &mut src, sess, lint, |lint| {
             self.probe_for_lint_level(tcx, lint, cur)
         });
         (level, src)
@@ -166,14 +173,19 @@ impl ShallowLintLevelMap {
 impl TyCtxt<'_> {
     /// Fetch and return the user-visible lint level for the given lint at the given HirId.
     pub fn lint_level_at_node(self, lint: &'static Lint, id: HirId) -> (Level, LintLevelSource) {
-        self.shallow_lint_levels_on(id.owner).lint_level_id_at_node(self, LintId::of(lint), id)
+        self.shallow_lint_levels_on(id.owner).lint_level_id_at_node(
+            Some(self),
+            self.sess,
+            LintId::of(lint),
+            id,
+        )
     }
 }
 
 /// This struct represents a lint expectation and holds all required information
 /// to emit the `unfulfilled_lint_expectations` lint if it is unfulfilled after
 /// the `LateLintPass` has completed.
-#[derive(Clone, Debug, HashStable)]
+#[derive(Clone, Debug, Encodable, Decodable, HashStable)]
 pub struct LintExpectation {
     /// The reason for this expectation that can optionally be added as part of
     /// the attribute. It will be displayed as part of the lint message.