Merge branch 'cc-work' of https://github.com/LemonBoy/zig into LemonBoy-cc-work

15 files changed, 163 insertions, 164 deletions

diff --git a/lib/std/os/linux/arm-eabi.zig b/lib/std/os/linux/arm-eabi.zig
index c457e10beb..879805696c 100644
--- a/lib/std/os/linux/arm-eabi.zig
+++ b/lib/std/os/linux/arm-eabi.zig
@@ -97,7 +97,7 @@ pub extern fn getThreadPointer() usize {
     );
 }
 
-pub nakedcc fn restore() void {
+pub fn restore() callconv(.Naked) void {
     return asm volatile ("svc #0"
         :
         : [number] "{r7}" (@as(usize, SYS_sigreturn))
@@ -105,7 +105,7 @@ pub nakedcc fn restore() void {
     );
 }
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("svc #0"
         :
         : [number] "{r7}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/arm64.zig b/lib/std/os/linux/arm64.zig
index ac2bb3bfdf..f565bea489 100644
--- a/lib/std/os/linux/arm64.zig
+++ b/lib/std/os/linux/arm64.zig
@@ -90,7 +90,7 @@ pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, a
 
 pub const restore = restore_rt;
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("svc #0"
         :
         : [number] "{x8}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/i386.zig b/lib/std/os/linux/i386.zig
index 3345f9904d..7652ece43e 100644
--- a/lib/std/os/linux/i386.zig
+++ b/lib/std/os/linux/i386.zig
@@ -102,7 +102,7 @@ pub fn socketcall(call: usize, args: [*]usize) usize {
 /// This matches the libc clone function.
 pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, arg: usize, ptid: *i32, tls: usize, ctid: *i32) usize;
 
-pub nakedcc fn restore() void {
+pub fn restore() callconv(.Naked) void {
     return asm volatile ("int $0x80"
         :
         : [number] "{eax}" (@as(usize, SYS_sigreturn))
@@ -110,7 +110,7 @@ pub nakedcc fn restore() void {
     );
 }
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("int $0x80"
         :
         : [number] "{eax}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/mipsel.zig b/lib/std/os/linux/mipsel.zig
index 60408c1e84..5193133f6c 100644
--- a/lib/std/os/linux/mipsel.zig
+++ b/lib/std/os/linux/mipsel.zig
@@ -144,7 +144,7 @@ pub fn syscall6(
 /// This matches the libc clone function.
 pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, arg: usize, ptid: *i32, tls: usize, ctid: *i32) usize;
 
-pub nakedcc fn restore() void {
+pub fn restore() callconv(.Naked) void {
     return asm volatile ("syscall"
         :
         : [number] "{$2}" (@as(usize, SYS_sigreturn))
@@ -152,7 +152,7 @@ pub nakedcc fn restore() void {
     );
 }
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("syscall"
         :
         : [number] "{$2}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig
index b7c59a9039..2259dad78e 100644
--- a/lib/std/os/linux/riscv64.zig
+++ b/lib/std/os/linux/riscv64.zig
@@ -89,7 +89,7 @@ pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, a
 
 pub const restore = restore_rt;
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("ecall"
         :
         : [number] "{x17}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig
index d037b3c6ae..d6067f9b18 100644
--- a/lib/std/os/linux/x86_64.zig
+++ b/lib/std/os/linux/x86_64.zig
@@ -90,7 +90,7 @@ pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: usize,
 
 pub const restore = restore_rt;
 
-pub nakedcc fn restore_rt() void {
+pub fn restore_rt() callconv(.Naked) void {
     return asm volatile ("syscall"
         :
         : [number] "{rax}" (@as(usize, SYS_rt_sigreturn))
diff --git a/lib/std/os/test.zig b/lib/std/os/test.zig
index 09e8c24899..877b95af1f 100644
--- a/lib/std/os/test.zig
+++ b/lib/std/os/test.zig
@@ -166,7 +166,7 @@ test "sigaltstack" {
 // analyzed
 const dl_phdr_info = if (@hasDecl(os, "dl_phdr_info")) os.dl_phdr_info else c_void;
 
-export fn iter_fn(info: *dl_phdr_info, size: usize, data: ?*usize) i32 {
+extern fn iter_fn(info: *dl_phdr_info, size: usize, data: ?*usize) i32 {
     if (builtin.os == .windows or builtin.os == .wasi or builtin.os == .macosx)
         return 0;
 
diff --git a/lib/std/os/uefi/protocols/simple_text_input_protocol.zig b/lib/std/os/uefi/protocols/simple_text_input_protocol.zig
index e1c5f6446f..b56ff728ef 100644
--- a/lib/std/os/uefi/protocols/simple_text_input_protocol.zig
+++ b/lib/std/os/uefi/protocols/simple_text_input_protocol.zig
@@ -27,4 +27,3 @@ pub const SimpleTextInputProtocol = extern struct {
         .node = [_]u8{ 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b },
     };
 };
-
diff --git a/lib/std/os/windows/advapi32.zig b/lib/std/os/windows/advapi32.zig
index 940f10994c..6364c5bddb 100644
--- a/lib/std/os/windows/advapi32.zig
+++ b/lib/std/os/windows/advapi32.zig
@@ -1,23 +1,23 @@
 usingnamespace @import("bits.zig");
 
-pub extern "advapi32" stdcallcc fn RegOpenKeyExW(
+pub extern "advapi32" fn RegOpenKeyExW(
     hKey: HKEY,
     lpSubKey: LPCWSTR,
     ulOptions: DWORD,
     samDesired: REGSAM,
     phkResult: *HKEY,
-) LSTATUS;
+) callconv(.Stdcall) LSTATUS;
 
-pub extern "advapi32" stdcallcc fn RegQueryValueExW(
+pub extern "advapi32" fn RegQueryValueExW(
     hKey: HKEY,
     lpValueName: LPCWSTR,
     lpReserved: LPDWORD,
     lpType: LPDWORD,
     lpData: LPBYTE,
     lpcbData: LPDWORD,
-) LSTATUS;
+) callconv(.Stdcall) LSTATUS;
 
 // RtlGenRandom is known as SystemFunction036 under advapi32
 // http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx */
-pub extern "advapi32" stdcallcc fn SystemFunction036(output: [*]u8, length: ULONG) BOOL;
+pub extern "advapi32" fn SystemFunction036(output: [*]u8, length: ULONG) callconv(.Stdcall) BOOL;
 pub const RtlGenRandom = SystemFunction036;
diff --git a/lib/std/os/windows/bits.zig b/lib/std/os/windows/bits.zig
index def987bd23..7d87ae075a 100644
--- a/lib/std/os/windows/bits.zig
+++ b/lib/std/os/windows/bits.zig
@@ -892,7 +892,7 @@ pub const EXCEPTION_POINTERS = extern struct {
     ContextRecord: *c_void,
 };
 
-pub const VECTORED_EXCEPTION_HANDLER = stdcallcc fn (ExceptionInfo: *EXCEPTION_POINTERS) c_long;
+pub const VECTORED_EXCEPTION_HANDLER = fn (ExceptionInfo: *EXCEPTION_POINTERS) callconv(.Stdcall) c_long;
 
 pub const OBJECT_ATTRIBUTES = extern struct {
     Length: ULONG,
diff --git a/lib/std/os/windows/kernel32.zig b/lib/std/os/windows/kernel32.zig
index 33e56abce1..1af68f4abd 100644
--- a/lib/std/os/windows/kernel32.zig
+++ b/lib/std/os/windows/kernel32.zig
@@ -1,22 +1,22 @@
 usingnamespace @import("bits.zig");
 
-pub extern "kernel32" stdcallcc fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) ?*c_void;
-pub extern "kernel32" stdcallcc fn RemoveVectoredExceptionHandler(Handle: HANDLE) c_ulong;
+pub extern "kernel32" fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) callconv(.Stdcall) ?*c_void;
+pub extern "kernel32" fn RemoveVectoredExceptionHandler(Handle: HANDLE) callconv(.Stdcall) c_ulong;
 
-pub extern "kernel32" stdcallcc fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) BOOL;
+pub extern "kernel32" fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CloseHandle(hObject: HANDLE) BOOL;
+pub extern "kernel32" fn CloseHandle(hObject: HANDLE) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CreateDirectoryW(lpPathName: [*]const u16, lpSecurityAttributes: ?*SECURITY_ATTRIBUTES) BOOL;
+pub extern "kernel32" fn CreateDirectoryW(lpPathName: [*]const u16, lpSecurityAttributes: ?*SECURITY_ATTRIBUTES) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CreateEventExW(
+pub extern "kernel32" fn CreateEventExW(
     lpEventAttributes: ?*SECURITY_ATTRIBUTES,
     lpName: [*:0]const u16,
     dwFlags: DWORD,
     dwDesiredAccess: DWORD,
-) ?HANDLE;
+) callconv(.Stdcall) ?HANDLE;
 
-pub extern "kernel32" stdcallcc fn CreateFileW(
+pub extern "kernel32" fn CreateFileW(
     lpFileName: [*]const u16, // TODO null terminated pointer type
     dwDesiredAccess: DWORD,
     dwShareMode: DWORD,
@@ -24,16 +24,16 @@ pub extern "kernel32" stdcallcc fn CreateFileW(
     dwCreationDisposition: DWORD,
     dwFlagsAndAttributes: DWORD,
     hTemplateFile: ?HANDLE,
-) HANDLE;
+) callconv(.Stdcall) HANDLE;
 
-pub extern "kernel32" stdcallcc fn CreatePipe(
+pub extern "kernel32" fn CreatePipe(
     hReadPipe: *HANDLE,
     hWritePipe: *HANDLE,
     lpPipeAttributes: *const SECURITY_ATTRIBUTES,
     nSize: DWORD,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CreateProcessW(
+pub extern "kernel32" fn CreateProcessW(
     lpApplicationName: ?LPWSTR,
     lpCommandLine: LPWSTR,
     lpProcessAttributes: ?*SECURITY_ATTRIBUTES,
@@ -44,15 +44,15 @@ pub extern "kernel32" stdcallcc fn CreateProcessW(
     lpCurrentDirectory: ?LPWSTR,
     lpStartupInfo: *STARTUPINFOW,
     lpProcessInformation: *PROCESS_INFORMATION,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn CreateSymbolicLinkW(lpSymlinkFileName: [*]const u16, lpTargetFileName: [*]const u16, dwFlags: DWORD) BOOLEAN;
+pub extern "kernel32" fn CreateSymbolicLinkW(lpSymlinkFileName: [*]const u16, lpTargetFileName: [*]const u16, dwFlags: DWORD) callconv(.Stdcall) BOOLEAN;
 
-pub extern "kernel32" stdcallcc fn CreateIoCompletionPort(FileHandle: HANDLE, ExistingCompletionPort: ?HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD) ?HANDLE;
+pub extern "kernel32" fn CreateIoCompletionPort(FileHandle: HANDLE, ExistingCompletionPort: ?HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD) callconv(.Stdcall) ?HANDLE;
 
-pub extern "kernel32" stdcallcc fn CreateThread(lpThreadAttributes: ?LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?LPDWORD) ?HANDLE;
+pub extern "kernel32" fn CreateThread(lpThreadAttributes: ?LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?LPDWORD) callconv(.Stdcall) ?HANDLE;
 
-pub extern "kernel32" stdcallcc fn DeviceIoControl(
+pub extern "kernel32" fn DeviceIoControl(
     h: HANDLE,
     dwIoControlCode: DWORD,
     lpInBuffer: ?*const c_void,
@@ -61,107 +61,107 @@ pub extern "kernel32" stdcallcc fn DeviceIoControl(
     nOutBufferSize: DWORD,
     lpBytesReturned: ?*DWORD,
     lpOverlapped: ?*OVERLAPPED,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn DeleteFileW(lpFileName: [*]const u16) BOOL;
+pub extern "kernel32" fn DeleteFileW(lpFileName: [*]const u16) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: *HANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) BOOL;
+pub extern "kernel32" fn DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: *HANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn ExitProcess(exit_code: UINT) noreturn;
+pub extern "kernel32" fn ExitProcess(exit_code: UINT) callconv(.Stdcall) noreturn;
 
-pub extern "kernel32" stdcallcc fn FindFirstFileW(lpFileName: [*]const u16, lpFindFileData: *WIN32_FIND_DATAW) HANDLE;
-pub extern "kernel32" stdcallcc fn FindClose(hFindFile: HANDLE) BOOL;
-pub extern "kernel32" stdcallcc fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAW) BOOL;
+pub extern "kernel32" fn FindFirstFileW(lpFileName: [*]const u16, lpFindFileData: *WIN32_FIND_DATAW) callconv(.Stdcall) HANDLE;
+pub extern "kernel32" fn FindClose(hFindFile: HANDLE) callconv(.Stdcall) BOOL;
+pub extern "kernel32" fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAW) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn FormatMessageW(dwFlags: DWORD, lpSource: ?LPVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: ?*va_list) DWORD;
+pub extern "kernel32" fn FormatMessageW(dwFlags: DWORD, lpSource: ?LPVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: ?*va_list) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn FreeEnvironmentStringsW(penv: [*]u16) BOOL;
+pub extern "kernel32" fn FreeEnvironmentStringsW(penv: [*]u16) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetCommandLineA() LPSTR;
+pub extern "kernel32" fn GetCommandLineA() callconv(.Stdcall) LPSTR;
 
-pub extern "kernel32" stdcallcc fn GetConsoleMode(in_hConsoleHandle: HANDLE, out_lpMode: *DWORD) BOOL;
+pub extern "kernel32" fn GetConsoleMode(in_hConsoleHandle: HANDLE, out_lpMode: *DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO) BOOL;
+pub extern "kernel32" fn GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) DWORD;
+pub extern "kernel32" fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetCurrentThread() HANDLE;
-pub extern "kernel32" stdcallcc fn GetCurrentThreadId() DWORD;
+pub extern "kernel32" fn GetCurrentThread() callconv(.Stdcall) HANDLE;
+pub extern "kernel32" fn GetCurrentThreadId() callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetEnvironmentStringsW() ?[*]u16;
+pub extern "kernel32" fn GetEnvironmentStringsW() callconv(.Stdcall) ?[*]u16;
 
-pub extern "kernel32" stdcallcc fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: LPWSTR, nSize: DWORD) DWORD;
+pub extern "kernel32" fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *DWORD) BOOL;
+pub extern "kernel32" fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) BOOL;
+pub extern "kernel32" fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetFileAttributesW(lpFileName: [*]const WCHAR) DWORD;
+pub extern "kernel32" fn GetFileAttributesW(lpFileName: [*]const WCHAR) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetModuleFileNameW(hModule: ?HMODULE, lpFilename: [*]u16, nSize: DWORD) DWORD;
+pub extern "kernel32" fn GetModuleFileNameW(hModule: ?HMODULE, lpFilename: [*]u16, nSize: DWORD) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetModuleHandleW(lpModuleName: ?[*]const WCHAR) HMODULE;
+pub extern "kernel32" fn GetModuleHandleW(lpModuleName: ?[*]const WCHAR) callconv(.Stdcall) HMODULE;
 
-pub extern "kernel32" stdcallcc fn GetLastError() DWORD;
+pub extern "kernel32" fn GetLastError() callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetFileInformationByHandle(
+pub extern "kernel32" fn GetFileInformationByHandle(
     hFile: HANDLE,
     lpFileInformation: *BY_HANDLE_FILE_INFORMATION,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetFileInformationByHandleEx(
+pub extern "kernel32" fn GetFileInformationByHandleEx(
     in_hFile: HANDLE,
     in_FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
     out_lpFileInformation: *c_void,
     in_dwBufferSize: DWORD,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetFinalPathNameByHandleW(
+pub extern "kernel32" fn GetFinalPathNameByHandleW(
     hFile: HANDLE,
     lpszFilePath: [*]u16,
     cchFilePath: DWORD,
     dwFlags: DWORD,
-) DWORD;
+) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn GetOverlappedResult(hFile: HANDLE, lpOverlapped: *OVERLAPPED, lpNumberOfBytesTransferred: *DWORD, bWait: BOOL) BOOL;
+pub extern "kernel32" fn GetOverlappedResult(hFile: HANDLE, lpOverlapped: *OVERLAPPED, lpNumberOfBytesTransferred: *DWORD, bWait: BOOL) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetProcessHeap() ?HANDLE;
-pub extern "kernel32" stdcallcc fn GetQueuedCompletionStatus(CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: *ULONG_PTR, lpOverlapped: *?*OVERLAPPED, dwMilliseconds: DWORD) BOOL;
+pub extern "kernel32" fn GetProcessHeap() callconv(.Stdcall) ?HANDLE;
+pub extern "kernel32" fn GetQueuedCompletionStatus(CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: *ULONG_PTR, lpOverlapped: *?*OVERLAPPED, dwMilliseconds: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetSystemInfo(lpSystemInfo: *SYSTEM_INFO) void;
-pub extern "kernel32" stdcallcc fn GetSystemTimeAsFileTime(*FILETIME) void;
+pub extern "kernel32" fn GetSystemInfo(lpSystemInfo: *SYSTEM_INFO) callconv(.Stdcall) void;
+pub extern "kernel32" fn GetSystemTimeAsFileTime(*FILETIME) callconv(.Stdcall) void;
 
-pub extern "kernel32" stdcallcc fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) ?HANDLE;
-pub extern "kernel32" stdcallcc fn HeapDestroy(hHeap: HANDLE) BOOL;
-pub extern "kernel32" stdcallcc fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void, dwBytes: SIZE_T) ?*c_void;
-pub extern "kernel32" stdcallcc fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) SIZE_T;
-pub extern "kernel32" stdcallcc fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) SIZE_T;
-pub extern "kernel32" stdcallcc fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) BOOL;
+pub extern "kernel32" fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) callconv(.Stdcall) ?HANDLE;
+pub extern "kernel32" fn HeapDestroy(hHeap: HANDLE) callconv(.Stdcall) BOOL;
+pub extern "kernel32" fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void, dwBytes: SIZE_T) callconv(.Stdcall) ?*c_void;
+pub extern "kernel32" fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) callconv(.Stdcall) SIZE_T;
+pub extern "kernel32" fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) callconv(.Stdcall) SIZE_T;
+pub extern "kernel32" fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn GetStdHandle(in_nStdHandle: DWORD) ?HANDLE;
+pub extern "kernel32" fn GetStdHandle(in_nStdHandle: DWORD) callconv(.Stdcall) ?HANDLE;
 
-pub extern "kernel32" stdcallcc fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) ?*c_void;
+pub extern "kernel32" fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) callconv(.Stdcall) ?*c_void;
 
-pub extern "kernel32" stdcallcc fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void) BOOL;
+pub extern "kernel32" fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*const c_void) BOOL;
+pub extern "kernel32" fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*const c_void) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) ?LPVOID;
-pub extern "kernel32" stdcallcc fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) BOOL;
+pub extern "kernel32" fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) callconv(.Stdcall) ?LPVOID;
+pub extern "kernel32" fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn MoveFileExW(
+pub extern "kernel32" fn MoveFileExW(
     lpExistingFileName: [*]const u16,
     lpNewFileName: [*]const u16,
     dwFlags: DWORD,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn PostQueuedCompletionStatus(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: ?*OVERLAPPED) BOOL;
+pub extern "kernel32" fn PostQueuedCompletionStatus(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: ?*OVERLAPPED) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn QueryPerformanceCounter(lpPerformanceCount: *LARGE_INTEGER) BOOL;
+pub extern "kernel32" fn QueryPerformanceCounter(lpPerformanceCount: *LARGE_INTEGER) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn QueryPerformanceFrequency(lpFrequency: *LARGE_INTEGER) BOOL;
+pub extern "kernel32" fn QueryPerformanceFrequency(lpFrequency: *LARGE_INTEGER) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn ReadDirectoryChangesW(
+pub extern "kernel32" fn ReadDirectoryChangesW(
     hDirectory: HANDLE,
     lpBuffer: [*]align(@alignOf(FILE_NOTIFY_INFORMATION)) u8,
     nBufferLength: DWORD,
@@ -170,79 +170,79 @@ pub extern "kernel32" stdcallcc fn ReadDirectoryChangesW(
     lpBytesReturned: ?*DWORD,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn ReadFile(
+pub extern "kernel32" fn ReadFile(
     in_hFile: HANDLE,
     out_lpBuffer: [*]u8,
     in_nNumberOfBytesToRead: DWORD,
     out_lpNumberOfBytesRead: ?*DWORD,
     in_out_lpOverlapped: ?*OVERLAPPED,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn RemoveDirectoryW(lpPathName: [*]const u16) BOOL;
+pub extern "kernel32" fn RemoveDirectoryW(lpPathName: [*]const u16) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) BOOL;
+pub extern "kernel32" fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn SetFilePointerEx(
+pub extern "kernel32" fn SetFilePointerEx(
     in_fFile: HANDLE,
     in_liDistanceToMove: LARGE_INTEGER,
     out_opt_ldNewFilePointer: ?*LARGE_INTEGER,
     in_dwMoveMethod: DWORD,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn SetFileTime(
+pub extern "kernel32" fn SetFileTime(
     hFile: HANDLE,
     lpCreationTime: ?*const FILETIME,
     lpLastAccessTime: ?*const FILETIME,
     lpLastWriteTime: ?*const FILETIME,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) BOOL;
+pub extern "kernel32" fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn Sleep(dwMilliseconds: DWORD) void;
+pub extern "kernel32" fn Sleep(dwMilliseconds: DWORD) callconv(.Stdcall) void;
 
-pub extern "kernel32" stdcallcc fn SwitchToThread() BOOL;
+pub extern "kernel32" fn SwitchToThread() callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) BOOL;
+pub extern "kernel32" fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn TlsAlloc() DWORD;
+pub extern "kernel32" fn TlsAlloc() callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn TlsFree(dwTlsIndex: DWORD) BOOL;
+pub extern "kernel32" fn TlsFree(dwTlsIndex: DWORD) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) DWORD;
+pub extern "kernel32" fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL) DWORD;
+pub extern "kernel32" fn WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn WaitForMultipleObjects(nCount: DWORD, lpHandle: [*]const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) DWORD;
+pub extern "kernel32" fn WaitForMultipleObjects(nCount: DWORD, lpHandle: [*]const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn WaitForMultipleObjectsEx(
+pub extern "kernel32" fn WaitForMultipleObjectsEx(
     nCount: DWORD,
     lpHandle: [*]const HANDLE,
     bWaitAll: BOOL,
     dwMilliseconds: DWORD,
     bAlertable: BOOL,
-) DWORD;
+) callconv(.Stdcall) DWORD;
 
-pub extern "kernel32" stdcallcc fn WriteFile(
+pub extern "kernel32" fn WriteFile(
     in_hFile: HANDLE,
     in_lpBuffer: [*]const u8,
     in_nNumberOfBytesToWrite: DWORD,
     out_lpNumberOfBytesWritten: ?*DWORD,
     in_out_lpOverlapped: ?*OVERLAPPED,
-) BOOL;
+) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn WriteFileEx(hFile: HANDLE, lpBuffer: [*]const u8, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) BOOL;
+pub extern "kernel32" fn WriteFileEx(hFile: HANDLE, lpBuffer: [*]const u8, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn LoadLibraryW(lpLibFileName: [*]const u16) ?HMODULE;
+pub extern "kernel32" fn LoadLibraryW(lpLibFileName: [*]const u16) callconv(.Stdcall) ?HMODULE;
 
-pub extern "kernel32" stdcallcc fn GetProcAddress(hModule: HMODULE, lpProcName: [*]const u8) ?FARPROC;
+pub extern "kernel32" fn GetProcAddress(hModule: HMODULE, lpProcName: [*]const u8) callconv(.Stdcall) ?FARPROC;
 
-pub extern "kernel32" stdcallcc fn FreeLibrary(hModule: HMODULE) BOOL;
+pub extern "kernel32" fn FreeLibrary(hModule: HMODULE) callconv(.Stdcall) BOOL;
 
-pub extern "kernel32" stdcallcc fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
-pub extern "kernel32" stdcallcc fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
-pub extern "kernel32" stdcallcc fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
-pub extern "kernel32" stdcallcc fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
+pub extern "kernel32" fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
+pub extern "kernel32" fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
+pub extern "kernel32" fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
+pub extern "kernel32" fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
 
-pub extern "kernel32" stdcallcc fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*c_void, Context: ?*c_void) BOOL;
+pub extern "kernel32" fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*c_void, Context: ?*c_void) callconv(.Stdcall) BOOL;
diff --git a/lib/std/os/windows/ntdll.zig b/lib/std/os/windows/ntdll.zig
index 84de0ca946..695cd77274 100644
--- a/lib/std/os/windows/ntdll.zig
+++ b/lib/std/os/windows/ntdll.zig
@@ -1,14 +1,14 @@
 usingnamespace @import("bits.zig");
 
-pub extern "NtDll" stdcallcc fn RtlCaptureStackBackTrace(FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: **c_void, BackTraceHash: ?*DWORD) WORD;
-pub extern "NtDll" stdcallcc fn NtQueryInformationFile(
+pub extern "NtDll" fn RtlCaptureStackBackTrace(FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: **c_void, BackTraceHash: ?*DWORD) callconv(.Stdcall) WORD;
+pub extern "NtDll" fn NtQueryInformationFile(
     FileHandle: HANDLE,
     IoStatusBlock: *IO_STATUS_BLOCK,
     FileInformation: *c_void,
     Length: ULONG,
     FileInformationClass: FILE_INFORMATION_CLASS,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtCreateFile(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtCreateFile(
     FileHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
     ObjectAttributes: *OBJECT_ATTRIBUTES,
@@ -20,8 +20,8 @@ pub extern "NtDll" stdcallcc fn NtCreateFile(
     CreateOptions: ULONG,
     EaBuffer: ?*c_void,
     EaLength: ULONG,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtDeviceIoControlFile(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtDeviceIoControlFile(
     FileHandle: HANDLE,
     Event: ?HANDLE,
     ApcRoutine: ?IO_APC_ROUTINE,
@@ -32,17 +32,17 @@ pub extern "NtDll" stdcallcc fn NtDeviceIoControlFile(
     InputBufferLength: ULONG,
     OutputBuffer: ?PVOID,
     OutputBufferLength: ULONG,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtClose(Handle: HANDLE) NTSTATUS;
-pub extern "NtDll" stdcallcc fn RtlDosPathNameToNtPathName_U(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtClose(Handle: HANDLE) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn RtlDosPathNameToNtPathName_U(
     DosPathName: [*]const u16,
     NtPathName: *UNICODE_STRING,
     NtFileNamePart: ?*?[*]const u16,
     DirectoryInfo: ?*CURDIR,
-) BOOL;
-pub extern "NtDll" stdcallcc fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) void;
+) callconv(.Stdcall) BOOL;
+pub extern "NtDll" fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) callconv(.Stdcall) void;
 
-pub extern "NtDll" stdcallcc fn NtQueryDirectoryFile(
+pub extern "NtDll" fn NtQueryDirectoryFile(
     FileHandle: HANDLE,
     Event: ?HANDLE,
     ApcRoutine: ?IO_APC_ROUTINE,
@@ -54,22 +54,22 @@ pub extern "NtDll" stdcallcc fn NtQueryDirectoryFile(
     ReturnSingleEntry: BOOLEAN,
     FileName: ?*UNICODE_STRING,
     RestartScan: BOOLEAN,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtCreateKeyedEvent(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtCreateKeyedEvent(
     KeyedEventHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
     ObjectAttributes: ?PVOID,
     Flags: ULONG,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtReleaseKeyedEvent(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtReleaseKeyedEvent(
     EventHandle: HANDLE,
     Key: *const c_void,
     Alertable: BOOLEAN,
     Timeout: ?*LARGE_INTEGER,
-) NTSTATUS;
-pub extern "NtDll" stdcallcc fn NtWaitForKeyedEvent(
+) callconv(.Stdcall) NTSTATUS;
+pub extern "NtDll" fn NtWaitForKeyedEvent(
     EventHandle: HANDLE,
     Key: *const c_void,
     Alertable: BOOLEAN,
     Timeout: ?*LARGE_INTEGER,
-) NTSTATUS;
+) callconv(.Stdcall) NTSTATUS;
diff --git a/lib/std/os/windows/ole32.zig b/lib/std/os/windows/ole32.zig
index 39c12d074c..a472089078 100644
--- a/lib/std/os/windows/ole32.zig
+++ b/lib/std/os/windows/ole32.zig
@@ -1,6 +1,6 @@
 usingnamespace @import("bits.zig");
 
-pub extern "ole32" stdcallcc fn CoTaskMemFree(pv: LPVOID) void;
-pub extern "ole32" stdcallcc fn CoUninitialize() void;
-pub extern "ole32" stdcallcc fn CoGetCurrentProcess() DWORD;
-pub extern "ole32" stdcallcc fn CoInitializeEx(pvReserved: LPVOID, dwCoInit: DWORD) HRESULT;
+pub extern "ole32" fn CoTaskMemFree(pv: LPVOID) callconv(.Stdcall) void;
+pub extern "ole32" fn CoUninitialize() callconv(.Stdcall) void;
+pub extern "ole32" fn CoGetCurrentProcess() callconv(.Stdcall) DWORD;
+pub extern "ole32" fn CoInitializeEx(pvReserved: LPVOID, dwCoInit: DWORD) callconv(.Stdcall) HRESULT;
diff --git a/lib/std/os/windows/shell32.zig b/lib/std/os/windows/shell32.zig
index c178997aad..aa1667d01d 100644
--- a/lib/std/os/windows/shell32.zig
+++ b/lib/std/os/windows/shell32.zig
@@ -1,3 +1,3 @@
 usingnamespace @import("bits.zig");
 
-pub extern "shell32" stdcallcc fn SHGetKnownFolderPath(rfid: *const KNOWNFOLDERID, dwFlags: DWORD, hToken: ?HANDLE, ppszPath: *[*]WCHAR) HRESULT;
+pub extern "shell32" fn SHGetKnownFolderPath(rfid: *const KNOWNFOLDERID, dwFlags: DWORD, hToken: ?HANDLE, ppszPath: *[*]WCHAR) callconv(.Stdcall) HRESULT;
diff --git a/lib/std/os/windows/ws2_32.zig b/lib/std/os/windows/ws2_32.zig
index c3dece2909..70cb62ac51 100644
--- a/lib/std/os/windows/ws2_32.zig
+++ b/lib/std/os/windows/ws2_32.zig
@@ -315,30 +315,30 @@ const IOC_WS2 = 0x08000000;
 
 pub const SIO_BASE_HANDLE = IOC_OUT | IOC_WS2 | 34;
 
-pub extern "ws2_32" stdcallcc fn WSAStartup(
+pub extern "ws2_32" fn WSAStartup(
     wVersionRequired: WORD,
     lpWSAData: *WSADATA,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSACleanup() c_int;
-pub extern "ws2_32" stdcallcc fn WSAGetLastError() c_int;
-pub extern "ws2_32" stdcallcc fn WSASocketA(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSACleanup() callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSAGetLastError() callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSASocketA(
     af: c_int,
     type: c_int,
     protocol: c_int,
     lpProtocolInfo: ?*WSAPROTOCOL_INFOA,
     g: GROUP,
     dwFlags: DWORD,
-) SOCKET;
-pub extern "ws2_32" stdcallcc fn WSASocketW(
+) callconv(.Stdcall) SOCKET;
+pub extern "ws2_32" fn WSASocketW(
     af: c_int,
     type: c_int,
     protocol: c_int,
     lpProtocolInfo: ?*WSAPROTOCOL_INFOW,
     g: GROUP,
     dwFlags: DWORD,
-) SOCKET;
-pub extern "ws2_32" stdcallcc fn closesocket(s: SOCKET) c_int;
-pub extern "ws2_32" stdcallcc fn WSAIoctl(
+) callconv(.Stdcall) SOCKET;
+pub extern "ws2_32" fn closesocket(s: SOCKET) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSAIoctl(
     s: SOCKET,
     dwIoControlCode: DWORD,
     lpvInBuffer: ?*const c_void,
@@ -348,18 +348,18 @@ pub extern "ws2_32" stdcallcc fn WSAIoctl(
     lpcbBytesReturned: LPDWORD,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
-pub extern "ws2_32" stdcallcc fn accept(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn accept(
     s: SOCKET,
     addr: ?*sockaddr,
     addrlen: socklen_t,
-) SOCKET;
-pub extern "ws2_32" stdcallcc fn connect(
+) callconv(.Stdcall) SOCKET;
+pub extern "ws2_32" fn connect(
     s: SOCKET,
     name: *const sockaddr,
     namelen: socklen_t,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSARecv(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSARecv(
     s: SOCKET,
     lpBuffers: [*]const WSABUF,
     dwBufferCount: DWORD,
@@ -367,8 +367,8 @@ pub extern "ws2_32" stdcallcc fn WSARecv(
     lpFlags: *DWORD,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSARecvFrom(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSARecvFrom(
     s: SOCKET,
     lpBuffers: [*]const WSABUF,
     dwBufferCount: DWORD,
@@ -378,8 +378,8 @@ pub extern "ws2_32" stdcallcc fn WSARecvFrom(
     lpFromlen: socklen_t,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSASend(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSASend(
     s: SOCKET,
     lpBuffers: [*]WSABUF,
     dwBufferCount: DWORD,
@@ -387,8 +387,8 @@ pub extern "ws2_32" stdcallcc fn WSASend(
     dwFlags: DWORD,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
-pub extern "ws2_32" stdcallcc fn WSASendTo(
+) callconv(.Stdcall) c_int;
+pub extern "ws2_32" fn WSASendTo(
     s: SOCKET,
     lpBuffers: [*]WSABUF,
     dwBufferCount: DWORD,
@@ -398,4 +398,4 @@ pub extern "ws2_32" stdcallcc fn WSASendTo(
     iTolen: socklen_t,
     lpOverlapped: ?*WSAOVERLAPPED,
     lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
-) c_int;
+) callconv(.Stdcall) c_int;