Varargs are completely unchecked if passed as generics

[joshuabogue]

I am trying to call the function DftiSetValue from the Intel Math Library. The function has the layout MKL_LONG DftiSetValue(DFTI_DESCRIPTOR_HANDLE, enum DFTI_CONFIG_PARAM, ...), the first is an 8 byte pointer (windows 64 bit), the second is an enum which is 4 bytes long, and the last parameter is a floating point number.

I can call this function from c++ just fine as a float or double, but cannot call this from rust without making it a double. This is with the enum being treated as 32 bit int, and I get an error if I try to call it with a u4 from the ux package. According to the documentation this function should be a float because I am using floating point fft precision.

I have attached some code that shows the fft being called with some sample values and you can see that one time it is called and returns all zeros which is incorrect and the second time it is called it comes back correctly with non-zero values.

Example.zip

[Mark-Simulacrum]

cc @dlrobertson @eddyb

[eddyb]

According to the documentation this function should be a float because I am using floating point fft precision.

float is automatically promoted to double when passed via varargs, AFAIK.
I forget if we do this automatically for you.

[dlrobertson]

From the C Standard.

The type of an argument in a variable argument list will never be an integer type smaller than int, nor will it ever be float.

And indeed if you were to attempt to use va_arg with a float with gcc you would get something like the following.

$ gcc -std=c11 -o ./test test.c
In file included from test.c:2:
test.c: In function ‘add’:
test.c:10:25: warning: ‘float’ is promoted to ‘double’ when passed through ‘...’
   10 |         f += va_arg(ap, float);
      |                         ^
test.c:10:25: note: (so you should pass ‘double’ not ‘float’ to ‘va_arg’)
test.c:10:25: note: if this code is reached, the program will abort
$ ./test
Illegal instruction

It would be trivial to automatically promote floats to double like we do for integers smaller than an int. I'd rather make programmers explicitly change their use of VaList::arg instead of automatically promoting, but this has caused some confusion, so it might be worth adding.

[Enselic]

Triage: Would be great if someone could produce a minimized reproducer of this problem. Right now the .zip contains almost 600 lines of Rust code.

[workingjubilee]

I see the problem.

When the type is an instantiated one, we do check to see if it is "C-variadic safe", and demand people correctly pass the argument, casting if necessary. The problem is that when the type is still generic, we can't check that until it is monomorphized.

[workingjubilee]

This code should not compile:

//@ compile-flags: --edition 2021
use core::ffi;

extern "C" {
    fn printf(ptr: *const ffi::c_char, ...) -> ffi::c_int;
}

fn generic_printf<T>(c: &ffi::CStr, arg: T) {
    unsafe { printf(c.as_ptr(), arg) };
}

fn main() {
    generic_printf(c"%d", 2u8);
    generic_printf(c"%f", 3.333_f32);
    generic_printf(c"%s", vec![6, 2, 8, 3, 1, 8, 5, 3, 0]);
}