Why does this code always print 0.000000?

[iahung2]

LibC.cs

using System;
using System.Runtime.InteropServices;

unsafe class LibC {
	#if WINDOWS
		const string libc = "msvcrt";
	#else
		const string libc = "libc";
	#endif
	
	[DllImport(libc, CallingConvention = CallingConvention.Cdecl), SuppressGCTransition]
	public static extern int printf(byte* format, double x);
	
	public static int print(double x) {
		unsafe {
			var format = "%f\n"u8;
			fixed (byte* fmt = &format[0])
			{
				return printf(fmt, x);
			}
		}
	}
}

test.cs

using System;
using static LibC;

namespace ConsoleApp1
{
	class Program
	{
		static void Main(string[] args) {
			print(0.12345);
		}
	}
}

[hez2010]

I believe you need to use __arglist as printf is a variadic function, and you also need to use %lf to format double values:

using System;
using System.Runtime.InteropServices;

unsafe class Program
{
    [DllImport("msvcrt.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]
    private static extern int wprintf(char* format, __arglist);

    [DllImport("msvcrt.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    private static extern int printf(byte* format, __arglist);

    static void Main(string[] args)
    {
        ReadOnlySpan<char> str = "%d %d %d %lf %lf %lf\n";
        fixed (char* p = str)
            wprintf(p, __arglist(1, 2, 3, 10.4, 23.5, 53.3));

        ReadOnlySpan<byte> str2 = "%d %d %d %lf %lf %lf\n"u8;
        fixed (byte* p = str2)
            printf(p, __arglist(1, 2, 3, 10.4, 23.5, 53.3));
    }
}

Also note that you cannot use SuppressGCTransition for variadic function.

[huoyaoyuan]

No, %lf has no effect. This looks like an interop bugfeature.

[huoyaoyuan]

On win-x86, it correctly prints 0.123450. (dotnet run -r win-x86).
On win-x64, it prints 0.000000.

Looks like an interop bug. Sample disassembly:

; Method CSPlayground.Program:Main(System.String[]) (FullOpts)
G_M000_IG01:                ;; offset=0x0000
       push     rbp
       sub      rsp, 48
       vzeroupper 
       lea      rbp, [rsp+0x30]

G_M000_IG02:                ;; offset=0x000D
       mov      rcx, 0x28773E42ED0
       mov      bword ptr [rbp-0x08], rcx
       vmovsd   xmm1, qword ptr [reloc @RWD00]
       mov      rax, 0x7FF84D4BC890

G_M000_IG03:                ;; offset=0x002D
       call     rax ; CSPlayground.Program:printf(ulong,double)
       xor      eax, eax
       mov      bword ptr [rbp-0x08], rax
       cmp      dword ptr [(reloc 0x7fff70fd505c)], 0
       jne      SHORT G_M000_IG05

G_M000_IG04:                ;; offset=0x003E
       add      rsp, 48
       pop      rbp
       ret      

G_M000_IG05:                ;; offset=0x0044
       call     CORINFO_HELP_POLL_GC
       jmp      SHORT G_M000_IG04
RWD00  	dq	3FBF9A6B50B0F27Ch	;      0.12345
; Total bytes of code: 75

[huoyaoyuan]

Compiled result for C++ code on Windows x64:

void Test(void) PROC                                 ; Test
        movsd   xmm1, QWORD PTR __real@3fbf9a6b50b0f27c
        lea     rcx, OFFSET FLAT:$SG5196
        movq    rdx, xmm1
        jmp     printf
void Test(void) ENDP                                 ; Test

Looks like we are missing the movq rdx, xmm1 instruction.

https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention#varargs says:

For floating-point values only, both the integer register and the floating-point register must contain the value, in case the callee expects the value in the integer registers.

@AaronRobinsonMSFT

[huoyaoyuan]

Well, at the view of managed side, there's no information about this function should be va_args, so the JIT doesn't move the FP value to integer register for va_args.

Does it mean that declaring va_args function as normal function is unsupported?

[MichalPetryka]

Does it mean that declaring va_args function as normal function is unsupported?

I think I recall @jkoritzinsky saying it is unsupported and that we need CallConvVarArgs for that.

[huoyaoyuan]

In short:
Varargs function must be defined as varargs P/Invoke to be used correctly:

static extern void printf(byte* format, __arglist);
printf(b, __arglist(0.12345));

Varargs is only supported on Windows x86/x64. For x86 it matches cdecl which only uses stack, but on x64 there's only fastcall. There is no way to correctly invoke printf on Unix or ARM.