rustc_monomorphize/mono_checks/
abi_check.rs

1//! This module ensures that if a function's ABI requires a particular target feature,
2//! that target feature is enabled both on the callee and all callers.
3use rustc_abi::{BackendRepr, RegKind};
4use rustc_hir::{CRATE_HIR_ID, HirId};
5use rustc_middle::mir::{self, Location, traversal};
6use rustc_middle::ty::layout::LayoutCx;
7use rustc_middle::ty::{self, Instance, InstanceKind, Ty, TyCtxt, TypingEnv};
8use rustc_session::lint::builtin::WASM_C_ABI;
9use rustc_span::def_id::DefId;
10use rustc_span::{DUMMY_SP, Span, Symbol, sym};
11use rustc_target::callconv::{ArgAbi, Conv, FnAbi, PassMode};
12use rustc_target::spec::{HasWasmCAbiOpt, WasmCAbi};
13
14use crate::errors;
15
16fn uses_vector_registers(mode: &PassMode, repr: &BackendRepr) -> bool {
17    match mode {
18        PassMode::Ignore | PassMode::Indirect { .. } => false,
19        PassMode::Cast { pad_i32: _, cast } => {
20            cast.prefix.iter().any(|r| r.is_some_and(|x| x.kind == RegKind::Vector))
21                || cast.rest.unit.kind == RegKind::Vector
22        }
23        PassMode::Direct(..) | PassMode::Pair(..) => matches!(repr, BackendRepr::SimdVector { .. }),
24    }
25}
26
27/// Checks whether a certain function ABI is compatible with the target features currently enabled
28/// for a certain function.
29/// `is_call` indicates whether this is a call-site check or a definition-site check;
30/// this is only relevant for the wording in the emitted error.
31fn do_check_simd_vector_abi<'tcx>(
32    tcx: TyCtxt<'tcx>,
33    abi: &FnAbi<'tcx, Ty<'tcx>>,
34    def_id: DefId,
35    is_call: bool,
36    loc: impl Fn() -> (Span, HirId),
37) {
38    // We check this on all functions, including those using the "Rust" ABI.
39    // For the "Rust" ABI it would be a bug if the lint ever triggered, but better safe than sorry.
40    let feature_def = tcx.sess.target.features_for_correct_vector_abi();
41    let codegen_attrs = tcx.codegen_fn_attrs(def_id);
42    let have_feature = |feat: Symbol| {
43        tcx.sess.unstable_target_features.contains(&feat)
44            || codegen_attrs.target_features.iter().any(|x| x.name == feat)
45    };
46    for arg_abi in abi.args.iter().chain(std::iter::once(&abi.ret)) {
47        let size = arg_abi.layout.size;
48        if uses_vector_registers(&arg_abi.mode, &arg_abi.layout.backend_repr) {
49            // Find the first feature that provides at least this vector size.
50            let feature = match feature_def.iter().find(|(bits, _)| size.bits() <= *bits) {
51                Some((_, feature)) => feature,
52                None => {
53                    let (span, _hir_id) = loc();
54                    tcx.dcx().emit_err(errors::AbiErrorUnsupportedVectorType {
55                        span,
56                        ty: arg_abi.layout.ty,
57                        is_call,
58                    });
59                    continue;
60                }
61            };
62            if !have_feature(Symbol::intern(feature)) {
63                // Emit error.
64                let (span, _hir_id) = loc();
65                tcx.dcx().emit_err(errors::AbiErrorDisabledVectorType {
66                    span,
67                    required_feature: feature,
68                    ty: arg_abi.layout.ty,
69                    is_call,
70                });
71            }
72        }
73    }
74    // The `vectorcall` ABI is special in that it requires SSE2 no matter which types are being passed.
75    if abi.conv == Conv::X86VectorCall && !have_feature(sym::sse2) {
76        let (span, _hir_id) = loc();
77        tcx.dcx().emit_err(errors::AbiRequiredTargetFeature {
78            span,
79            required_feature: "sse2",
80            abi: "vectorcall",
81            is_call,
82        });
83    }
84}
85
86/// Determines whether the given argument is passed the same way on the old and new wasm ABIs.
87fn wasm_abi_safe<'tcx>(tcx: TyCtxt<'tcx>, arg: &ArgAbi<'tcx, Ty<'tcx>>) -> bool {
88    if matches!(arg.layout.backend_repr, BackendRepr::Scalar(_)) {
89        return true;
90    }
91
92    // Both the old and the new ABIs treat vector types like `v128` the same
93    // way.
94    if uses_vector_registers(&arg.mode, &arg.layout.backend_repr) {
95        return true;
96    }
97
98    // This matches `unwrap_trivial_aggregate` in the wasm ABI logic.
99    if arg.layout.is_aggregate() {
100        let cx = LayoutCx::new(tcx, TypingEnv::fully_monomorphized());
101        if let Some(unit) = arg.layout.homogeneous_aggregate(&cx).ok().and_then(|ha| ha.unit()) {
102            let size = arg.layout.size;
103            // Ensure there's just a single `unit` element in `arg`.
104            if unit.size == size {
105                return true;
106            }
107        }
108    }
109
110    // Zero-sized types are dropped in both ABIs, so they're safe
111    if arg.layout.is_zst() {
112        return true;
113    }
114
115    false
116}
117
118/// Warns against usage of `extern "C"` on wasm32-unknown-unknown that is affected by the
119/// ABI transition.
120fn do_check_wasm_abi<'tcx>(
121    tcx: TyCtxt<'tcx>,
122    abi: &FnAbi<'tcx, Ty<'tcx>>,
123    is_call: bool,
124    loc: impl Fn() -> (Span, HirId),
125) {
126    // Only proceed for `extern "C" fn` on wasm32-unknown-unknown (same check as what `adjust_for_foreign_abi` uses to call `compute_wasm_abi_info`),
127    // and only proceed if `wasm_c_abi_opt` indicates we should emit the lint.
128    if !(tcx.sess.target.arch == "wasm32"
129        && tcx.sess.target.os == "unknown"
130        && tcx.wasm_c_abi_opt() == WasmCAbi::Legacy { with_lint: true }
131        && abi.conv == Conv::C)
132    {
133        return;
134    }
135    // Warn against all types whose ABI will change. Return values are not affected by this change.
136    for arg_abi in abi.args.iter() {
137        if wasm_abi_safe(tcx, arg_abi) {
138            continue;
139        }
140        let (span, hir_id) = loc();
141        tcx.emit_node_span_lint(
142            WASM_C_ABI,
143            hir_id,
144            span,
145            errors::WasmCAbiTransition { ty: arg_abi.layout.ty, is_call },
146        );
147        // Let's only warn once per function.
148        break;
149    }
150}
151
152/// Checks that the ABI of a given instance of a function does not contain vector-passed arguments
153/// or return values for which the corresponding target feature is not enabled.
154fn check_instance_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) {
155    let typing_env = ty::TypingEnv::fully_monomorphized();
156    let Ok(abi) = tcx.fn_abi_of_instance(typing_env.as_query_input((instance, ty::List::empty())))
157    else {
158        // An error will be reported during codegen if we cannot determine the ABI of this
159        // function.
160        return;
161    };
162    let loc = || {
163        let def_id = instance.def_id();
164        (
165            tcx.def_span(def_id),
166            def_id.as_local().map(|did| tcx.local_def_id_to_hir_id(did)).unwrap_or(CRATE_HIR_ID),
167        )
168    };
169    do_check_simd_vector_abi(tcx, abi, instance.def_id(), /*is_call*/ false, loc);
170    do_check_wasm_abi(tcx, abi, /*is_call*/ false, loc);
171}
172
173/// Checks that a call expression does not try to pass a vector-passed argument which requires a
174/// target feature that the caller does not have, as doing so causes UB because of ABI mismatch.
175fn check_call_site_abi<'tcx>(
176    tcx: TyCtxt<'tcx>,
177    callee: Ty<'tcx>,
178    caller: InstanceKind<'tcx>,
179    loc: impl Fn() -> (Span, HirId) + Copy,
180) {
181    if callee.fn_sig(tcx).abi().is_rustic_abi() {
182        // we directly handle the soundness of Rust ABIs
183        return;
184    }
185    let typing_env = ty::TypingEnv::fully_monomorphized();
186    let callee_abi = match *callee.kind() {
187        ty::FnPtr(..) => {
188            tcx.fn_abi_of_fn_ptr(typing_env.as_query_input((callee.fn_sig(tcx), ty::List::empty())))
189        }
190        ty::FnDef(def_id, args) => {
191            // Intrinsics are handled separately by the compiler.
192            if tcx.intrinsic(def_id).is_some() {
193                return;
194            }
195            let instance = ty::Instance::expect_resolve(tcx, typing_env, def_id, args, DUMMY_SP);
196            tcx.fn_abi_of_instance(typing_env.as_query_input((instance, ty::List::empty())))
197        }
198        _ => {
199            panic!("Invalid function call");
200        }
201    };
202
203    let Ok(callee_abi) = callee_abi else {
204        // ABI failed to compute; this will not get through codegen.
205        return;
206    };
207    do_check_simd_vector_abi(tcx, callee_abi, caller.def_id(), /*is_call*/ true, loc);
208    do_check_wasm_abi(tcx, callee_abi, /*is_call*/ true, loc);
209}
210
211fn check_callees_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>, body: &mir::Body<'tcx>) {
212    // Check all function call terminators.
213    for (bb, _data) in traversal::mono_reachable(body, tcx, instance) {
214        let terminator = body.basic_blocks[bb].terminator();
215        match terminator.kind {
216            mir::TerminatorKind::Call { ref func, ref fn_span, .. }
217            | mir::TerminatorKind::TailCall { ref func, ref fn_span, .. } => {
218                let callee_ty = func.ty(body, tcx);
219                let callee_ty = instance.instantiate_mir_and_normalize_erasing_regions(
220                    tcx,
221                    ty::TypingEnv::fully_monomorphized(),
222                    ty::EarlyBinder::bind(callee_ty),
223                );
224                check_call_site_abi(tcx, callee_ty, body.source.instance, || {
225                    let loc = Location {
226                        block: bb,
227                        statement_index: body.basic_blocks[bb].statements.len(),
228                    };
229                    (
230                        *fn_span,
231                        body.source_info(loc)
232                            .scope
233                            .lint_root(&body.source_scopes)
234                            .unwrap_or(CRATE_HIR_ID),
235                    )
236                });
237            }
238            _ => {}
239        }
240    }
241}
242
243pub(crate) fn check_feature_dependent_abi<'tcx>(
244    tcx: TyCtxt<'tcx>,
245    instance: Instance<'tcx>,
246    body: &'tcx mir::Body<'tcx>,
247) {
248    check_instance_abi(tcx, instance);
249    check_callees_abi(tcx, instance, body);
250}
rustc_monomorphize/mono_checks/abi_check.rs

rustc_monomorphize/mono_checks/
abi_check.rs
