Need support Windows-style DLL export function names

[liigo]

#[no_mangle]
pub extern "stdcall" fn add(x: i32, y: i32) -> i32 {
    x + y
}

After compiled to DLL, the exported function name is add@8.
But we need a way to export it as add (instead of add@x).
Most Windows API are named without "@x".

[klutzy]

it's stdcall symbol decoration. Win32 stdcall requires symbol exported as _<name>@<size of parameters>. (So most windows apis are actually exported with @x)

[liigo]

@klutzy Can you tell me which windows api is exported with @x in its name?

[klutzy]

It's just that dependency walker understands stdcall convention.

$ nm /c/Program\ Files/Microsoft\ SDKs/Windows/v7.1/Lib/User32.lib 2>&1 | grep MessageBoxW
00000000 I __imp__MessageBoxW@16
00000000 T _MessageBoxW@16

Indeed gcc also adds @x:

$ cat c.c
#include <windows.h>
__stdcall int add(int a, int b) { return a + b; }
void call_stdcall(void) { MessageBoxW(0, 0, 0, 0); }

$ gcc -c c.c -o c.o
$ nm c.o
00000000 b .bss
00000000 d .data
00000000 r .eh_frame
00000000 r .rdata$zzz
00000000 t .text
         U __imp__MessageBoxW@16
00000000 T _add@8
0000000f T _call_stdcall

[alexcrichton]

Closing, it sounds like this is normal behavior.

[liigo]

@alexcrichton @klutzy You misunderstand.
I'm not saying export "FnName@xx" names is a wrong behavior. I just saying we need a new feature to export "FnName"(without @XX) names to follow Windows-DLL-style on Windows platform. Most Windows DLL functions (including Windows API) can be load dynamically by GetProcAddress, for example:
GetProcAddress(hModule, "MessageBoxW") // not "MessageBoxW@16"
Most 3rd plugin systems (Lua extensions etc.) on Windows depend on this.

[alexcrichton]

Do you have some example code which does not work as expected? If C++ is doing the same thing it seems like there's no bug here.

[klutzy]

Ok, I now understand what you mean: you want symbol dllexported as other name.

However this is usually done by linker and no language support is required, even on C/C++.
You must prepare .def file with EXPORTS section and give it to linker. For example:

$ cat c.c
__stdcall void std_func(void) {}

$ cat c.def
LIBRARY c
EXPORTS
  std_func=std_func@0

$ gcc c.c c.def -shared -o c.dll  # (c.def will be passed to ld)

\> dumpbin /exports c.dll
...
    ordinal hint RVA      name

          1    0 00001280 std_func

then c.dll has _std_func rather than _std_func@0.
(I don't know much about VC toolchain, but I've heard that it also need .def file.)
So what you really need is to write .def file and pass it to linker.

However, we don't explicitly export symbols so adding .def files will cause other pub symbols not exported. This should be fixed - see #7196.

(Or, the easiest solution is using extern "C" rather than extern "stdcall".)

[liigo]

Let's leave C/C++ aside, we talk about Rust: How to do it? (and can we make it easier?)

[klutzy]

Basically same: you can write .def file and give it to linker.

$ cat a.rs
#![crate_type = "dylib"]
#[no_mangle]
pub extern "stdcall" fn std_func() {}

$ cat a.def
LIBRARY a
EXPORTS
  std_func=std_func@0

$ rustc a.rs -C link-args="a.def"

(but this currently causes other symbols not exported as described at #7196)

[liigo]

@alexcrichton

Rust: (compile to a DLL)

#[no_mangle]
pub extern "stdcall" fn add(x: i32, y: i32) -> i32 {
    x + y
}

C/C++ (or others):

typedef int (__stdcall *PFN_ADD) (int x, int y);
PFN_ADD pAdd = (PFN_ADD) GetProcAddress(hDllModule, "add"); // load fn by name
pAdd(1, 2);

I expect that Rust DLL export a function named "add" (not "add@x"), and can be load by this name in other languages. Most 3rd plugin systems expected this, such as Lua extensions.

NOTE: I'm not filing a bug (I don't think there is a bug), I'm asking for new feature.

[liigo]

@klutzy Thank you! I tried it, and it works.