Function call ABI check ignores ZSTs

[theemathas]

The following code has no UB according to Miri. This seems rather suspect.

use std::mem::transmute;

extern "C" fn foo(_: (), _: i32) {}

fn main() {
    let f = unsafe { transmute::<extern "C" fn((), i32), extern "C" fn(i32)>(foo) };
    f(0);
}

[theemathas]

The following code has UB, but Miri gives the wrong error message:

use std::mem::transmute;

extern "C" fn foo(_: ()) {}

fn main() {
    let f = unsafe { transmute::<extern "C" fn(()), extern "C" fn(i32)>(foo) };
    f(0);
}

error: Undefined Behavior: calling a function with more arguments than it expected
 --> src/main.rs:3:1
  |
3 | extern "C" fn foo(_: ()) {}
  | ^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
  |
  = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
  = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
  = note: stack backtrace:
          0: foo
              at src/main.rs:3:1: 3:25
          1: main
              at src/main.rs:7:5: 7:9

note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace

[RalfJung]

Yeah, we currently skip all "ignored" arguments. I forgot why, it might have been something about the MIR we generate for closures relying in that.

[bjorn3]

For the Rust ABI ZSTs always use PassMode::Ignore so skipping is fine, but for the C ABI, they can use PassMode::Indirect so they must not be skipped.

[RalfJung]

Miri only ignores arguments that are actually PassMode::Ignore on the current target.

But that's still not fine, Miri should check the ABI compatibility rules as documented.

[RalfJung]

This applies even to uninhabited ZST, as reported in #4992:

use std::mem::transmute;

enum Never {}

fn foo(x: Never) {
    let ptr = &raw const x;
    println!("{ptr:p}");
}

fn main() {
    let f = unsafe { transmute::<fn(Never), fn(())>(foo) };
    f(());
}

[RalfJung]

Specifically the compiler relies on this when coercing non-capturing closures to function pointers, as in this example. The closure takes a self argument as they all do, but we invoke it as just a fn().

[theemathas]

I thought that extern "rust-call" had a special ABI?

[RalfJung]

It does special magic for the arguments, but this is about the closure's captured environment.