492 lines
12 KiB
Rust
492 lines
12 KiB
Rust
//@ check-pass
|
|
//@ aux-build:external_extern_fn.rs
|
|
#![crate_type = "lib"]
|
|
|
|
mod redeclared_different_signature {
|
|
mod a {
|
|
extern "C" {
|
|
fn clash(x: u8);
|
|
}
|
|
}
|
|
mod b {
|
|
extern "C" {
|
|
fn clash(x: u64); //~ WARN `clash` redeclared with a different signature
|
|
}
|
|
}
|
|
}
|
|
|
|
mod redeclared_same_signature {
|
|
mod a {
|
|
extern "C" {
|
|
fn no_clash(x: u8);
|
|
}
|
|
}
|
|
mod b {
|
|
extern "C" {
|
|
fn no_clash(x: u8);
|
|
}
|
|
}
|
|
}
|
|
|
|
extern crate external_extern_fn;
|
|
mod extern_no_clash {
|
|
// Should not clash with external_extern_fn::extern_fn.
|
|
extern "C" {
|
|
fn extern_fn(x: u8);
|
|
}
|
|
}
|
|
|
|
extern "C" {
|
|
fn some_other_new_name(x: i16);
|
|
|
|
#[link_name = "extern_link_name"]
|
|
fn some_new_name(x: i16);
|
|
|
|
#[link_name = "link_name_same"]
|
|
fn both_names_different(x: i16);
|
|
}
|
|
|
|
fn link_name_clash() {
|
|
extern "C" {
|
|
fn extern_link_name(x: u32);
|
|
//~^ WARN `extern_link_name` redeclared with a different signature
|
|
|
|
#[link_name = "some_other_new_name"]
|
|
//~^ WARN `some_other_extern_link_name` redeclares `some_other_new_name` with a different
|
|
fn some_other_extern_link_name(x: u32);
|
|
|
|
#[link_name = "link_name_same"]
|
|
//~^ WARN `other_both_names_different` redeclares `link_name_same` with a different
|
|
fn other_both_names_different(x: u32);
|
|
}
|
|
}
|
|
|
|
mod a {
|
|
extern "C" {
|
|
fn different_mod(x: u8);
|
|
}
|
|
}
|
|
mod b {
|
|
extern "C" {
|
|
fn different_mod(x: u64); //~ WARN `different_mod` redeclared with a different signature
|
|
}
|
|
}
|
|
|
|
extern "C" {
|
|
fn variadic_decl(x: u8, ...);
|
|
}
|
|
|
|
fn variadic_clash() {
|
|
extern "C" {
|
|
fn variadic_decl(x: u8); //~ WARN `variadic_decl` redeclared with a different signature
|
|
}
|
|
}
|
|
|
|
#[no_mangle]
|
|
fn no_mangle_name(x: u8) {}
|
|
|
|
extern "C" {
|
|
#[link_name = "unique_link_name"]
|
|
fn link_name_specified(x: u8);
|
|
}
|
|
|
|
fn tricky_no_clash() {
|
|
extern "C" {
|
|
// Shouldn't warn, because the declaration above actually declares a different symbol (and
|
|
// Rust's name resolution rules around shadowing will handle this gracefully).
|
|
fn link_name_specified() -> u32;
|
|
|
|
// The case of a no_mangle name colliding with an extern decl (see #28179) is related but
|
|
// shouldn't be reported by ClashingExternDeclarations, because this is an example of
|
|
// unmangled name clash causing bad behaviour in functions with a defined body.
|
|
fn no_mangle_name() -> u32;
|
|
}
|
|
}
|
|
|
|
mod banana {
|
|
mod one {
|
|
#[repr(C)]
|
|
struct Banana {
|
|
weight: u32,
|
|
length: u16,
|
|
}
|
|
extern "C" {
|
|
fn weigh_banana(count: *const Banana) -> u64;
|
|
}
|
|
}
|
|
|
|
mod two {
|
|
#[repr(C)]
|
|
struct Banana {
|
|
weight: u32,
|
|
length: u16,
|
|
} // note: distinct type
|
|
// This should not trigger the lint because two::Banana is structurally equivalent to
|
|
// one::Banana.
|
|
extern "C" {
|
|
fn weigh_banana(count: *const Banana) -> u64;
|
|
}
|
|
}
|
|
|
|
mod three {
|
|
// This _should_ trigger the lint, because repr(packed) should generate a struct that has a
|
|
// different layout.
|
|
#[repr(C, packed)]
|
|
struct Banana {
|
|
weight: u32,
|
|
length: u16,
|
|
}
|
|
#[allow(improper_ctypes)]
|
|
extern "C" {
|
|
fn weigh_banana(count: *const Banana) -> u64;
|
|
//~^ WARN `weigh_banana` redeclared with a different signature
|
|
}
|
|
}
|
|
|
|
mod four {
|
|
// This _should_ trigger the lint, because the type is not repr(C).
|
|
struct Banana {
|
|
weight: u32,
|
|
length: u16,
|
|
}
|
|
#[allow(improper_ctypes)]
|
|
extern "C" {
|
|
fn weigh_banana(count: *const Banana) -> u64;
|
|
//~^ WARN `weigh_banana` redeclared with a different signature
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3-field structs can't be distinguished by ScalarPair, side-stepping some shortucts
|
|
// the logic used to (incorrectly) take.
|
|
mod banana3 {
|
|
mod one {
|
|
#[repr(C)]
|
|
struct Banana {
|
|
weight: u32,
|
|
length: u16,
|
|
color: u8,
|
|
}
|
|
extern "C" {
|
|
fn weigh_banana3(count: *const Banana) -> u64;
|
|
}
|
|
}
|
|
|
|
mod two {
|
|
#[repr(C)]
|
|
struct Banana {
|
|
weight: u32,
|
|
length: u16,
|
|
color: u8,
|
|
} // note: distinct type
|
|
// This should not trigger the lint because two::Banana is structurally equivalent to
|
|
// one::Banana.
|
|
extern "C" {
|
|
fn weigh_banana3(count: *const Banana) -> u64;
|
|
}
|
|
}
|
|
|
|
mod three {
|
|
// This _should_ trigger the lint, because repr(packed) should generate a struct that has a
|
|
// different layout.
|
|
#[repr(C, packed)]
|
|
struct Banana {
|
|
weight: u32,
|
|
length: u16,
|
|
color: u8,
|
|
}
|
|
#[allow(improper_ctypes)]
|
|
extern "C" {
|
|
fn weigh_banana3(count: *const Banana) -> u64;
|
|
//~^ WARN `weigh_banana3` redeclared with a different signature
|
|
}
|
|
}
|
|
|
|
mod four {
|
|
// This _should_ trigger the lint, because the type is not repr(C).
|
|
struct Banana {
|
|
weight: u32,
|
|
length: u16,
|
|
color: u8,
|
|
}
|
|
#[allow(improper_ctypes)]
|
|
extern "C" {
|
|
fn weigh_banana3(count: *const Banana) -> u64;
|
|
//~^ WARN `weigh_banana3` redeclared with a different signature
|
|
}
|
|
}
|
|
}
|
|
|
|
mod sameish_members {
|
|
mod a {
|
|
#[repr(C)]
|
|
struct Point {
|
|
x: i16,
|
|
y: i16,
|
|
}
|
|
|
|
extern "C" {
|
|
fn draw_point(p: Point);
|
|
}
|
|
}
|
|
mod b {
|
|
#[repr(C)]
|
|
struct Point {
|
|
coordinates: [i16; 2],
|
|
}
|
|
|
|
// It's possible we are overconservative for this case, as accessing the elements of the
|
|
// coordinates array might end up correctly accessing `.x` and `.y`. However, this may not
|
|
// always be the case, for every architecture and situation. This is also a really odd
|
|
// thing to do anyway.
|
|
extern "C" {
|
|
fn draw_point(p: Point);
|
|
//~^ WARN `draw_point` redeclared with a different signature
|
|
}
|
|
}
|
|
}
|
|
|
|
mod same_sized_members_clash {
|
|
mod a {
|
|
#[repr(C)]
|
|
struct Point3 {
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
}
|
|
extern "C" {
|
|
fn origin() -> Point3;
|
|
}
|
|
}
|
|
mod b {
|
|
#[repr(C)]
|
|
struct Point3 {
|
|
x: i32,
|
|
y: i32,
|
|
z: i32, // NOTE: Incorrectly redeclared as i32
|
|
}
|
|
extern "C" {
|
|
fn origin() -> Point3; //~ WARN `origin` redeclared with a different signature
|
|
}
|
|
}
|
|
}
|
|
|
|
mod transparent {
|
|
#[repr(transparent)]
|
|
struct T(usize);
|
|
mod a {
|
|
use super::T;
|
|
extern "C" {
|
|
fn transparent() -> T;
|
|
fn transparent_incorrect() -> T;
|
|
}
|
|
}
|
|
|
|
mod b {
|
|
extern "C" {
|
|
// Shouldn't warn here, because repr(transparent) guarantees that T's layout is the
|
|
// same as just the usize.
|
|
fn transparent() -> usize;
|
|
|
|
// Should warn, because there's a signedness conversion here:
|
|
fn transparent_incorrect() -> isize;
|
|
//~^ WARN `transparent_incorrect` redeclared with a different signature
|
|
}
|
|
}
|
|
}
|
|
|
|
mod missing_return_type {
|
|
mod a {
|
|
extern "C" {
|
|
fn missing_return_type() -> usize;
|
|
}
|
|
}
|
|
|
|
mod b {
|
|
extern "C" {
|
|
// This should output a warning because we can't assume that the first declaration is
|
|
// the correct one -- if this one is the correct one, then calling the usize-returning
|
|
// version would allow reads into uninitialised memory.
|
|
fn missing_return_type();
|
|
//~^ WARN `missing_return_type` redeclared with a different signature
|
|
}
|
|
}
|
|
}
|
|
|
|
mod non_zero_and_non_null {
|
|
mod a {
|
|
extern "C" {
|
|
fn non_zero_usize() -> core::num::NonZero<usize>;
|
|
fn non_null_ptr() -> core::ptr::NonNull<usize>;
|
|
}
|
|
}
|
|
mod b {
|
|
extern "C" {
|
|
// If there's a clash in either of these cases you're either gaining an incorrect
|
|
// invariant that the value is non-zero, or you're missing out on that invariant. Both
|
|
// cases are warning for, from both a caller-convenience and optimisation perspective.
|
|
fn non_zero_usize() -> usize;
|
|
//~^ WARN `non_zero_usize` redeclared with a different signature
|
|
fn non_null_ptr() -> *const usize;
|
|
//~^ WARN `non_null_ptr` redeclared with a different signature
|
|
}
|
|
}
|
|
}
|
|
|
|
// See #75739
|
|
mod non_zero_transparent {
|
|
mod a1 {
|
|
extern "C" {
|
|
fn f1() -> std::num::NonZero<usize>;
|
|
}
|
|
}
|
|
|
|
mod b1 {
|
|
#[repr(transparent)]
|
|
struct X(std::num::NonZero<usize>);
|
|
|
|
extern "C" {
|
|
fn f1() -> X;
|
|
}
|
|
}
|
|
|
|
mod a2 {
|
|
extern "C" {
|
|
fn f2() -> std::num::NonZero<usize>;
|
|
}
|
|
}
|
|
|
|
mod b2 {
|
|
#[repr(transparent)]
|
|
struct X1(std::num::NonZero<usize>);
|
|
|
|
#[repr(transparent)]
|
|
struct X(X1);
|
|
|
|
extern "C" {
|
|
// Same case as above, but with two layers of newtyping.
|
|
fn f2() -> X;
|
|
}
|
|
}
|
|
|
|
mod a3 {
|
|
#[repr(transparent)]
|
|
struct X(core::ptr::NonNull<i32>);
|
|
|
|
extern "C" {
|
|
fn f3() -> X;
|
|
}
|
|
}
|
|
|
|
mod b3 {
|
|
extern "C" {
|
|
fn f3() -> core::ptr::NonNull<i32>;
|
|
}
|
|
}
|
|
|
|
mod a4 {
|
|
#[repr(transparent)]
|
|
enum E {
|
|
X(std::num::NonZero<usize>),
|
|
}
|
|
extern "C" {
|
|
fn f4() -> E;
|
|
}
|
|
}
|
|
|
|
mod b4 {
|
|
extern "C" {
|
|
fn f4() -> std::num::NonZero<usize>;
|
|
}
|
|
}
|
|
}
|
|
|
|
mod null_optimised_enums {
|
|
mod a {
|
|
extern "C" {
|
|
fn option_non_zero_usize() -> usize;
|
|
fn option_non_zero_isize() -> isize;
|
|
fn option_non_null_ptr() -> *const usize;
|
|
|
|
fn option_non_zero_usize_incorrect() -> usize;
|
|
fn option_non_null_ptr_incorrect() -> *const usize;
|
|
}
|
|
}
|
|
mod b {
|
|
extern "C" {
|
|
// This should be allowed, because these conversions are guaranteed to be FFI-safe (see
|
|
// #60300)
|
|
fn option_non_zero_usize() -> Option<core::num::NonZero<usize>>;
|
|
fn option_non_zero_isize() -> Option<core::num::NonZero<isize>>;
|
|
fn option_non_null_ptr() -> Option<core::ptr::NonNull<usize>>;
|
|
|
|
// However, these should be incorrect (note isize instead of usize)
|
|
fn option_non_zero_usize_incorrect() -> isize;
|
|
//~^ WARN `option_non_zero_usize_incorrect` redeclared with a different signature
|
|
fn option_non_null_ptr_incorrect() -> *const isize;
|
|
//~^ WARN `option_non_null_ptr_incorrect` redeclared with a different signature
|
|
}
|
|
}
|
|
}
|
|
|
|
#[allow(improper_ctypes)]
|
|
mod unknown_layout {
|
|
mod a {
|
|
extern "C" {
|
|
pub fn generic(l: Link<u32>);
|
|
}
|
|
#[repr(C)]
|
|
pub struct Link<T> {
|
|
pub item: T,
|
|
pub next: *const Link<T>,
|
|
}
|
|
}
|
|
|
|
mod b {
|
|
extern "C" {
|
|
pub fn generic(l: Link<u32>);
|
|
}
|
|
#[repr(C)]
|
|
pub struct Link<T> {
|
|
pub item: T,
|
|
pub next: *const Link<T>,
|
|
}
|
|
}
|
|
}
|
|
|
|
mod hidden_niche {
|
|
mod a {
|
|
extern "C" {
|
|
fn hidden_niche_transparent() -> usize;
|
|
fn hidden_niche_transparent_no_niche() -> usize;
|
|
fn hidden_niche_unsafe_cell() -> usize;
|
|
}
|
|
}
|
|
mod b {
|
|
use std::cell::UnsafeCell;
|
|
use std::num::NonZero;
|
|
|
|
#[repr(transparent)]
|
|
struct Transparent {
|
|
x: NonZero<usize>,
|
|
}
|
|
|
|
#[repr(transparent)]
|
|
struct TransparentNoNiche {
|
|
y: UnsafeCell<NonZero<usize>>,
|
|
}
|
|
|
|
extern "C" {
|
|
fn hidden_niche_transparent() -> Option<Transparent>;
|
|
|
|
fn hidden_niche_transparent_no_niche() -> Option<TransparentNoNiche>;
|
|
//~^ WARN redeclared with a different signature
|
|
//~| WARN block uses type `Option<TransparentNoNiche>`, which is not FFI-safe
|
|
|
|
fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZero<usize>>>;
|
|
//~^ WARN redeclared with a different signature
|
|
//~| WARN block uses type `Option<UnsafeCell<NonZero<usize>>>`, which is not FFI-safe
|
|
}
|
|
}
|
|
}
|