extern(C) and name mangling

[Dave P.]

On Wednesday, 16 December 2020 at 04:17:13 UTC, Mike Parker wrote:
> On Tuesday, 15 December 2020 at 22:04:12 UTC, Dave P. wrote:
>> [...]
>
> Mangling does not play any role in passing and calling function 
> pointers between D and C. It only plays a role in linking and 
> loading. You can declare function pointers in D and C without 
> any name whatsoever.
>
> What matters is that both sides agree on the number and type of 
> parameters accepted by the function that's pointed to, and that 
> they both agree on the calling convention. I don't believe 
> extern(C) has any effect on templated functions. However, the D 
> calling convention is defined to be identical to the C calling 
> convention on the host system for everything except Windows x86.

Oh interesting, so I only need extern(C) for declaring symbols 
I’m linking to and
for symbols I want to export to C. I had sort of assumed that D 
might have
different calling conventions for different things, but that 
makes things a lot easier.

> So theoretically, you should be able to pass a pointer to a 
> templated free function to C as long as the types in the 
> functions parameter list match those the C function expects. I 
> don't know if I'd do that myself, though.
>
>> [...]
>
> There's no such thing as C name mangling. C functions are *not* 
> mangled (though some platforms do prepend an underscore to 
> symbol names). What extern(C) does is to turn off D name 
> mangling.
>

Yeah, I was playing a bit loose with the terminology and 
referring to the
leading underscore.

> So what you're asking for is a way to retain the D name 
> mangling on an extern C function. The way to do that is with 
> `pragma(mangle, "new_name")`. To match the original D function 
> mangling, declare the function first without extern(C) and 
> print `func.mangleof`. Use that as the parameter to 
> pragma(mangle).
>
> I can't imagine any benefit you'd get from doing that, though.

Agreed!