|
| 1 | +use rustc_hir::def_id::{DefId, LocalDefId}; |
| 2 | +use rustc_hir::{self as hir, FnSig, ForeignItemKind, LanguageItems}; |
| 3 | +use rustc_infer::infer::DefineOpaqueTypes; |
| 4 | +use rustc_middle::ty::{self, Instance, Ty}; |
| 5 | +use rustc_session::{declare_lint, declare_lint_pass}; |
| 6 | +use rustc_span::Span; |
| 7 | +use rustc_trait_selection::infer::TyCtxtInferExt; |
| 8 | + |
| 9 | +use crate::lints::RedefiningRuntimeSymbolsDiag; |
| 10 | +use crate::{LateContext, LateLintPass, LintContext}; |
| 11 | + |
| 12 | +declare_lint! { |
| 13 | + /// The `invalid_runtime_symbol_definitions` lint checks the signature of items whose |
| 14 | + /// symbol name is a runtime symbols expected by `core`. |
| 15 | + /// |
| 16 | + /// ### Example |
| 17 | + /// |
| 18 | + /// ```rust,compile_fail |
| 19 | + /// #[unsafe(no_mangle)] |
| 20 | + /// pub fn strlen() {} // invalid definition of the `strlen` function |
| 21 | + /// ``` |
| 22 | + /// |
| 23 | + /// {{produces}} |
| 24 | + /// |
| 25 | + /// ### Explanation |
| 26 | + /// |
| 27 | + /// Up-most care is required when defining runtime symbols assumed and |
| 28 | + /// used by the standard library. They must follow the C specification, not use any |
| 29 | + /// standard-library facility or undefined behavior may occur. |
| 30 | + /// |
| 31 | + /// The symbols currently checked are `memcpy`, `memmove`, `memset`, `memcmp`, |
| 32 | + /// `bcmp` and `strlen`. |
| 33 | + /// |
| 34 | + /// [^1]: https://doc.rust-lang.org/core/index.html#how-to-use-the-core-library |
| 35 | + pub INVALID_RUNTIME_SYMBOL_DEFINITIONS, |
| 36 | + Deny, |
| 37 | + "invalid definition of a symbol used by the standard library" |
| 38 | +} |
| 39 | + |
| 40 | +declare_lint_pass!(RuntimeSymbols => [INVALID_RUNTIME_SYMBOL_DEFINITIONS]); |
| 41 | + |
| 42 | +static EXPECTED_SYMBOLS: &[ExpectedSymbol] = &[ |
| 43 | + ExpectedSymbol { symbol: "memcpy", lang: LanguageItems::memcpy_fn }, |
| 44 | + ExpectedSymbol { symbol: "memmove", lang: LanguageItems::memmove_fn }, |
| 45 | + ExpectedSymbol { symbol: "memset", lang: LanguageItems::memset_fn }, |
| 46 | + ExpectedSymbol { symbol: "memcmp", lang: LanguageItems::memcmp_fn }, |
| 47 | + ExpectedSymbol { symbol: "bcmp", lang: LanguageItems::bcmp_fn }, |
| 48 | + ExpectedSymbol { symbol: "strlen", lang: LanguageItems::strlen_fn }, |
| 49 | +]; |
| 50 | + |
| 51 | +#[derive(Copy, Clone, Debug)] |
| 52 | +struct ExpectedSymbol { |
| 53 | + symbol: &'static str, |
| 54 | + lang: fn(&LanguageItems) -> Option<DefId>, |
| 55 | +} |
| 56 | + |
| 57 | +impl<'tcx> LateLintPass<'tcx> for RuntimeSymbols { |
| 58 | + fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) { |
| 59 | + // Bail-out if the item is not a function/method or static. |
| 60 | + match item.kind { |
| 61 | + hir::ItemKind::Fn { sig, ident: _, generics, body: _, has_body: _ } => { |
| 62 | + // Generic functions cannot have the same runtime symbol as we do not allow |
| 63 | + // any symbol attributes. |
| 64 | + if !generics.params.is_empty() { |
| 65 | + return; |
| 66 | + } |
| 67 | + |
| 68 | + // Try to get the overridden symbol name of this function (our mangling |
| 69 | + // cannot ever conflict with runtime symbols, so no need to check for those). |
| 70 | + let Some(symbol_name) = rustc_symbol_mangling::symbol_name_from_attrs( |
| 71 | + cx.tcx, |
| 72 | + rustc_middle::ty::InstanceKind::Item(item.owner_id.to_def_id()), |
| 73 | + ) else { |
| 74 | + return; |
| 75 | + }; |
| 76 | + |
| 77 | + check_fn(cx, &symbol_name, sig, item.owner_id.def_id); |
| 78 | + } |
| 79 | + hir::ItemKind::Static(..) => { |
| 80 | + // Compute the symbol name of this static (without mangling, as our mangling |
| 81 | + // cannot ever conflict with runtime symbols). |
| 82 | + let Some(symbol_name) = rustc_symbol_mangling::symbol_name_from_attrs( |
| 83 | + cx.tcx, |
| 84 | + rustc_middle::ty::InstanceKind::Item(item.owner_id.to_def_id()), |
| 85 | + ) else { |
| 86 | + return; |
| 87 | + }; |
| 88 | + |
| 89 | + let def_id = item.owner_id.def_id; |
| 90 | + |
| 91 | + check_static(cx, &symbol_name, def_id, item.span); |
| 92 | + } |
| 93 | + hir::ItemKind::ForeignMod { abi: _, items } => { |
| 94 | + for item in items { |
| 95 | + let item = cx.tcx.hir_foreign_item(*item); |
| 96 | + |
| 97 | + let did = item.owner_id.def_id; |
| 98 | + let instance = Instance::new_raw( |
| 99 | + did.to_def_id(), |
| 100 | + ty::List::identity_for_item(cx.tcx, did), |
| 101 | + ); |
| 102 | + let symbol_name = cx.tcx.symbol_name(instance); |
| 103 | + |
| 104 | + match item.kind { |
| 105 | + ForeignItemKind::Fn(fn_sig, _idents, _generics) => { |
| 106 | + check_fn(cx, &symbol_name.name, fn_sig, did); |
| 107 | + } |
| 108 | + ForeignItemKind::Static(..) => { |
| 109 | + check_static(cx, &symbol_name.name, did, item.span); |
| 110 | + } |
| 111 | + ForeignItemKind::Type => return, |
| 112 | + } |
| 113 | + } |
| 114 | + } |
| 115 | + _ => return, |
| 116 | + } |
| 117 | + } |
| 118 | +} |
| 119 | + |
| 120 | +fn check_fn(cx: &LateContext<'_>, symbol_name: &str, sig: FnSig<'_>, did: LocalDefId) { |
| 121 | + let Some(expected_symbol) = EXPECTED_SYMBOLS.iter().find(|es| es.symbol == symbol_name) else { |
| 122 | + // The symbol name does not correspond to a runtime symbols, bail out |
| 123 | + return; |
| 124 | + }; |
| 125 | + |
| 126 | + let Some(expected_def_id) = (expected_symbol.lang)(&cx.tcx.lang_items()) else { |
| 127 | + // Can't find the corresponding language item, bail out |
| 128 | + return; |
| 129 | + }; |
| 130 | + |
| 131 | + // Get the two function signatures |
| 132 | + let lang_sig = cx.tcx.normalize_erasing_regions( |
| 133 | + cx.typing_env(), |
| 134 | + cx.tcx.fn_sig(expected_def_id).instantiate_identity(), |
| 135 | + ); |
| 136 | + let user_sig = cx |
| 137 | + .tcx |
| 138 | + .normalize_erasing_regions(cx.typing_env(), cx.tcx.fn_sig(did).instantiate_identity()); |
| 139 | + |
| 140 | + // Compare the two signatures with an inference context |
| 141 | + let infcx = cx.tcx.infer_ctxt().build(cx.typing_mode()); |
| 142 | + let cause = rustc_middle::traits::ObligationCause::misc(sig.span, did); |
| 143 | + let result = infcx.at(&cause, cx.param_env).eq(DefineOpaqueTypes::No, lang_sig, user_sig); |
| 144 | + |
| 145 | + // If they don't match, emit our own mismatch signatures |
| 146 | + if let Err(_terr) = result { |
| 147 | + // Create fn pointers for diagnostics purpose |
| 148 | + let expected = Ty::new_fn_ptr(cx.tcx, lang_sig); |
| 149 | + let actual = Ty::new_fn_ptr(cx.tcx, user_sig); |
| 150 | + |
| 151 | + cx.emit_span_lint( |
| 152 | + INVALID_RUNTIME_SYMBOL_DEFINITIONS, |
| 153 | + sig.span, |
| 154 | + RedefiningRuntimeSymbolsDiag::FnDef { |
| 155 | + symbol_name: symbol_name.to_string(), |
| 156 | + found_fn_sig: actual, |
| 157 | + expected_fn_sig: expected, |
| 158 | + }, |
| 159 | + ); |
| 160 | + } |
| 161 | +} |
| 162 | + |
| 163 | +fn check_static<'tcx>(cx: &LateContext<'tcx>, symbol_name: &str, did: LocalDefId, sp: Span) { |
| 164 | + let Some(expected_symbol) = EXPECTED_SYMBOLS.iter().find(|es| es.symbol == symbol_name) else { |
| 165 | + // The symbol name does not correspond to a runtime symbols, bail out |
| 166 | + return; |
| 167 | + }; |
| 168 | + |
| 169 | + let Some(expected_def_id) = (expected_symbol.lang)(&cx.tcx.lang_items()) else { |
| 170 | + // Can't find the corresponding language item, bail out |
| 171 | + return; |
| 172 | + }; |
| 173 | + |
| 174 | + // Get the static type |
| 175 | + let static_ty = cx.tcx.type_of(did).instantiate_identity().skip_norm_wip(); |
| 176 | + |
| 177 | + // Peel Option<...> and get the inner type (see std weak! macro with #[linkage = "extern_weak"]) |
| 178 | + let inner_static_ty: Ty<'_> = match static_ty.kind() { |
| 179 | + ty::Adt(def, args) if Some(def.did()) == cx.tcx.lang_items().option_type() => { |
| 180 | + args.type_at(0) |
| 181 | + } |
| 182 | + _ => static_ty, |
| 183 | + }; |
| 184 | + |
| 185 | + // Get the expected symbol function signature |
| 186 | + let lang_sig = cx.tcx.normalize_erasing_regions( |
| 187 | + cx.typing_env(), |
| 188 | + cx.tcx.fn_sig(expected_def_id).instantiate_identity(), |
| 189 | + ); |
| 190 | + |
| 191 | + let expected = Ty::new_fn_ptr(cx.tcx, lang_sig); |
| 192 | + |
| 193 | + // Compare the expected function signature with the static type, report an error if they don't match |
| 194 | + if expected != inner_static_ty { |
| 195 | + cx.emit_span_lint( |
| 196 | + INVALID_RUNTIME_SYMBOL_DEFINITIONS, |
| 197 | + sp, |
| 198 | + RedefiningRuntimeSymbolsDiag::Static { |
| 199 | + static_ty, |
| 200 | + symbol_name: symbol_name.to_string(), |
| 201 | + expected_fn_sig: expected, |
| 202 | + }, |
| 203 | + ); |
| 204 | + } |
| 205 | +} |
0 commit comments