authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2020-11-19 19:03:08+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2020-11-19 19:03:08+02:00
logcf819b95fe7dec15f4ed87cd4bd8ae0be8ce7fdf
tree612ec79d1895e59d3ac50a8a2b8c0d59d34d2772
parent25ec2dbc1e2302d1138749262b588d3e438fcd55
parent3a28b659bd66a1312f5586b7fc8afdd6c6a32eb2
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #6829 from tadeokondrak/error-unsupported-callconv

stage1: Compile error instead of falling back to C for unsupported cc

17 files changed, 388 insertions(+), 252 deletions(-)

doc/langref.html.in+2-2
...@@ -4191,7 +4191,7 @@ test "noreturn" {...@@ -4191,7 +4191,7 @@ test "noreturn" {
4191 <p>Another use case for {#syntax#}noreturn{#endsyntax#} is the {#syntax#}exit{#endsyntax#} function:</p>4191 <p>Another use case for {#syntax#}noreturn{#endsyntax#} is the {#syntax#}exit{#endsyntax#} function:</p>
4192 {#code_begin|test#}4192 {#code_begin|test#}
4193 {#target_windows#}4193 {#target_windows#}
4194pub extern "kernel32" fn ExitProcess(exit_code: c_uint) callconv(.Stdcall) noreturn;4194pub extern "kernel32" fn ExitProcess(exit_code: c_uint) callconv(if (@import("builtin").arch == .i386) .Stdcall else .C) noreturn;
41954195
4196test "foo" {4196test "foo" {
4197 const value = bar() catch ExitProcess(1);4197 const value = bar() catch ExitProcess(1);
...@@ -4226,7 +4226,7 @@ export fn sub(a: i8, b: i8) i8 { return a - b; }...@@ -4226,7 +4226,7 @@ export fn sub(a: i8, b: i8) i8 { return a - b; }
4226// at link time, when linking statically, or at runtime, when linking4226// at link time, when linking statically, or at runtime, when linking
4227// dynamically.4227// dynamically.
4228// The callconv specifier changes the calling convention of the function.4228// The callconv specifier changes the calling convention of the function.
4229extern "kernel32" fn ExitProcess(exit_code: u32) callconv(.Stdcall) noreturn;4229extern "kernel32" fn ExitProcess(exit_code: u32) callconv(if (@import("builtin").arch == .i386) .Stdcall else .C) noreturn;
4230extern "c" fn atan2(a: f64, b: f64) f64;4230extern "c" fn atan2(a: f64, b: f64) f64;
42314231
4232// The @setCold builtin tells the optimizer that a function is rarely called.4232// The @setCold builtin tells the optimizer that a function is rarely called.
lib/std/debug.zig+1-1
...@@ -1801,7 +1801,7 @@ fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const c_v...@@ -1801,7 +1801,7 @@ fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const c_v
1801 os.abort();1801 os.abort();
1802}1802}
18031803
1804fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(.Stdcall) c_long {1804fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(windows.WINAPI) c_long {
1805 switch (info.ExceptionRecord.ExceptionCode) {1805 switch (info.ExceptionRecord.ExceptionCode) {
1806 windows.EXCEPTION_DATATYPE_MISALIGNMENT => handleSegfaultWindowsExtra(info, 0, "Unaligned Memory Access"),1806 windows.EXCEPTION_DATATYPE_MISALIGNMENT => handleSegfaultWindowsExtra(info, 0, "Unaligned Memory Access"),
1807 windows.EXCEPTION_ACCESS_VIOLATION => handleSegfaultWindowsExtra(info, 1, null),1807 windows.EXCEPTION_ACCESS_VIOLATION => handleSegfaultWindowsExtra(info, 1, null),
lib/std/os/windows/advapi32.zig+3-3
...@@ -11,7 +11,7 @@ pub extern "advapi32" fn RegOpenKeyExW(...@@ -11,7 +11,7 @@ pub extern "advapi32" fn RegOpenKeyExW(
11 ulOptions: DWORD,11 ulOptions: DWORD,
12 samDesired: REGSAM,12 samDesired: REGSAM,
13 phkResult: *HKEY,13 phkResult: *HKEY,
14) callconv(.Stdcall) LSTATUS;14) callconv(WINAPI) LSTATUS;
1515
16pub extern "advapi32" fn RegQueryValueExW(16pub extern "advapi32" fn RegQueryValueExW(
17 hKey: HKEY,17 hKey: HKEY,
...@@ -20,9 +20,9 @@ pub extern "advapi32" fn RegQueryValueExW(...@@ -20,9 +20,9 @@ pub extern "advapi32" fn RegQueryValueExW(
20 lpType: LPDWORD,20 lpType: LPDWORD,
21 lpData: LPBYTE,21 lpData: LPBYTE,
22 lpcbData: LPDWORD,22 lpcbData: LPDWORD,
23) callconv(.Stdcall) LSTATUS;23) callconv(WINAPI) LSTATUS;
2424
25// RtlGenRandom is known as SystemFunction036 under advapi3225// RtlGenRandom is known as SystemFunction036 under advapi32
26// http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx */26// http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx */
27pub extern "advapi32" fn SystemFunction036(output: [*]u8, length: ULONG) callconv(.Stdcall) BOOL;27pub extern "advapi32" fn SystemFunction036(output: [*]u8, length: ULONG) callconv(WINAPI) BOOL;
28pub const RtlGenRandom = SystemFunction036;28pub const RtlGenRandom = SystemFunction036;
lib/std/os/windows/bits.zig+6-1
...@@ -24,6 +24,11 @@ pub const STD_OUTPUT_HANDLE = maxInt(DWORD) - 11 + 1;...@@ -24,6 +24,11 @@ pub const STD_OUTPUT_HANDLE = maxInt(DWORD) - 11 + 1;
24/// The standard error device. Initially, this is the active console screen buffer, CONOUT$.24/// The standard error device. Initially, this is the active console screen buffer, CONOUT$.
25pub const STD_ERROR_HANDLE = maxInt(DWORD) - 12 + 1;25pub const STD_ERROR_HANDLE = maxInt(DWORD) - 12 + 1;
2626
27pub const WINAPI: builtin.CallingConvention = if (builtin.arch == .i386)
28 .Stdcall
29else
30 .C;
31
27pub const BOOL = c_int;32pub const BOOL = c_int;
28pub const BOOLEAN = BYTE;33pub const BOOLEAN = BYTE;
29pub const BYTE = u8;34pub const BYTE = u8;
...@@ -1150,7 +1155,7 @@ pub const EXCEPTION_POINTERS = extern struct {...@@ -1150,7 +1155,7 @@ pub const EXCEPTION_POINTERS = extern struct {
1150 ContextRecord: PCONTEXT,1155 ContextRecord: PCONTEXT,
1151};1156};
11521157
1153pub const VECTORED_EXCEPTION_HANDLER = fn (ExceptionInfo: *EXCEPTION_POINTERS) callconv(.Stdcall) c_long;1158pub const VECTORED_EXCEPTION_HANDLER = fn (ExceptionInfo: *EXCEPTION_POINTERS) callconv(WINAPI) c_long;
11541159
1155pub const OBJECT_ATTRIBUTES = extern struct {1160pub const OBJECT_ATTRIBUTES = extern struct {
1156 Length: ULONG,1161 Length: ULONG,
lib/std/os/windows/gdi32.zig+5-5
...@@ -38,13 +38,13 @@ pub extern "gdi32" fn SetPixelFormat(...@@ -38,13 +38,13 @@ pub extern "gdi32" fn SetPixelFormat(
38 hdc: ?HDC,38 hdc: ?HDC,
39 format: i32,39 format: i32,
40 ppfd: ?*const PIXELFORMATDESCRIPTOR,40 ppfd: ?*const PIXELFORMATDESCRIPTOR,
41) callconv(.Stdcall) bool;41) callconv(WINAPI) bool;
4242
43pub extern "gdi32" fn ChoosePixelFormat(43pub extern "gdi32" fn ChoosePixelFormat(
44 hdc: ?HDC,44 hdc: ?HDC,
45 ppfd: ?*const PIXELFORMATDESCRIPTOR,45 ppfd: ?*const PIXELFORMATDESCRIPTOR,
46) callconv(.Stdcall) i32;46) callconv(WINAPI) i32;
4747
48pub extern "gdi32" fn SwapBuffers(hdc: ?HDC) callconv(.Stdcall) bool;48pub extern "gdi32" fn SwapBuffers(hdc: ?HDC) callconv(WINAPI) bool;
49pub extern "gdi32" fn wglCreateContext(hdc: ?HDC) callconv(.Stdcall) ?HGLRC;49pub extern "gdi32" fn wglCreateContext(hdc: ?HDC) callconv(WINAPI) ?HGLRC;
50pub extern "gdi32" fn wglMakeCurrent(hdc: ?HDC, hglrc: ?HGLRC) callconv(.Stdcall) bool;50pub extern "gdi32" fn wglMakeCurrent(hdc: ?HDC, hglrc: ?HGLRC) callconv(WINAPI) bool;
lib/std/os/windows/kernel32.zig+127-127
...@@ -5,22 +5,22 @@...@@ -5,22 +5,22 @@
5// and substantial portions of the software.5// and substantial portions of the software.
6usingnamespace @import("bits.zig");6usingnamespace @import("bits.zig");
77
8pub extern "kernel32" fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) callconv(.Stdcall) ?*c_void;8pub extern "kernel32" fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) callconv(WINAPI) ?*c_void;
9pub extern "kernel32" fn RemoveVectoredExceptionHandler(Handle: HANDLE) callconv(.Stdcall) c_ulong;9pub extern "kernel32" fn RemoveVectoredExceptionHandler(Handle: HANDLE) callconv(WINAPI) c_ulong;
1010
11pub extern "kernel32" fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) callconv(.Stdcall) BOOL;11pub extern "kernel32" fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) callconv(WINAPI) BOOL;
1212
13pub extern "kernel32" fn CloseHandle(hObject: HANDLE) callconv(.Stdcall) BOOL;13pub extern "kernel32" fn CloseHandle(hObject: HANDLE) callconv(WINAPI) BOOL;
1414
15pub extern "kernel32" fn CreateDirectoryW(lpPathName: [*:0]const u16, lpSecurityAttributes: ?*SECURITY_ATTRIBUTES) callconv(.Stdcall) BOOL;15pub extern "kernel32" fn CreateDirectoryW(lpPathName: [*:0]const u16, lpSecurityAttributes: ?*SECURITY_ATTRIBUTES) callconv(WINAPI) BOOL;
16pub extern "kernel32" fn SetEndOfFile(hFile: HANDLE) callconv(.Stdcall) BOOL;16pub extern "kernel32" fn SetEndOfFile(hFile: HANDLE) callconv(WINAPI) BOOL;
1717
18pub extern "kernel32" fn CreateEventExW(18pub extern "kernel32" fn CreateEventExW(
19 lpEventAttributes: ?*SECURITY_ATTRIBUTES,19 lpEventAttributes: ?*SECURITY_ATTRIBUTES,
20 lpName: [*:0]const u16,20 lpName: [*:0]const u16,
21 dwFlags: DWORD,21 dwFlags: DWORD,
22 dwDesiredAccess: DWORD,22 dwDesiredAccess: DWORD,
23) callconv(.Stdcall) ?HANDLE;23) callconv(WINAPI) ?HANDLE;
2424
25pub extern "kernel32" fn CreateFileW(25pub extern "kernel32" fn CreateFileW(
26 lpFileName: [*:0]const u16,26 lpFileName: [*:0]const u16,
...@@ -30,14 +30,14 @@ pub extern "kernel32" fn CreateFileW(...@@ -30,14 +30,14 @@ pub extern "kernel32" fn CreateFileW(
30 dwCreationDisposition: DWORD,30 dwCreationDisposition: DWORD,
31 dwFlagsAndAttributes: DWORD,31 dwFlagsAndAttributes: DWORD,
32 hTemplateFile: ?HANDLE,32 hTemplateFile: ?HANDLE,
33) callconv(.Stdcall) HANDLE;33) callconv(WINAPI) HANDLE;
3434
35pub extern "kernel32" fn CreatePipe(35pub extern "kernel32" fn CreatePipe(
36 hReadPipe: *HANDLE,36 hReadPipe: *HANDLE,
37 hWritePipe: *HANDLE,37 hWritePipe: *HANDLE,
38 lpPipeAttributes: *const SECURITY_ATTRIBUTES,38 lpPipeAttributes: *const SECURITY_ATTRIBUTES,
39 nSize: DWORD,39 nSize: DWORD,
40) callconv(.Stdcall) BOOL;40) callconv(WINAPI) BOOL;
4141
42pub extern "kernel32" fn CreateProcessW(42pub extern "kernel32" fn CreateProcessW(
43 lpApplicationName: ?LPWSTR,43 lpApplicationName: ?LPWSTR,
...@@ -50,13 +50,13 @@ pub extern "kernel32" fn CreateProcessW(...@@ -50,13 +50,13 @@ pub extern "kernel32" fn CreateProcessW(
50 lpCurrentDirectory: ?LPWSTR,50 lpCurrentDirectory: ?LPWSTR,
51 lpStartupInfo: *STARTUPINFOW,51 lpStartupInfo: *STARTUPINFOW,
52 lpProcessInformation: *PROCESS_INFORMATION,52 lpProcessInformation: *PROCESS_INFORMATION,
53) callconv(.Stdcall) BOOL;53) callconv(WINAPI) BOOL;
5454
55pub extern "kernel32" fn CreateSymbolicLinkW(lpSymlinkFileName: [*:0]const u16, lpTargetFileName: [*:0]const u16, dwFlags: DWORD) callconv(.Stdcall) BOOLEAN;55pub extern "kernel32" fn CreateSymbolicLinkW(lpSymlinkFileName: [*:0]const u16, lpTargetFileName: [*:0]const u16, dwFlags: DWORD) callconv(WINAPI) BOOLEAN;
5656
57pub extern "kernel32" fn CreateIoCompletionPort(FileHandle: HANDLE, ExistingCompletionPort: ?HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD) callconv(.Stdcall) ?HANDLE;57pub extern "kernel32" fn CreateIoCompletionPort(FileHandle: HANDLE, ExistingCompletionPort: ?HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD) callconv(WINAPI) ?HANDLE;
5858
59pub extern "kernel32" fn CreateThread(lpThreadAttributes: ?LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?LPDWORD) callconv(.Stdcall) ?HANDLE;59pub extern "kernel32" fn CreateThread(lpThreadAttributes: ?LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?LPDWORD) callconv(WINAPI) ?HANDLE;
6060
61pub extern "kernel32" fn DeviceIoControl(61pub extern "kernel32" fn DeviceIoControl(
62 h: HANDLE,62 h: HANDLE,
...@@ -67,111 +67,111 @@ pub extern "kernel32" fn DeviceIoControl(...@@ -67,111 +67,111 @@ pub extern "kernel32" fn DeviceIoControl(
67 nOutBufferSize: DWORD,67 nOutBufferSize: DWORD,
68 lpBytesReturned: ?*DWORD,68 lpBytesReturned: ?*DWORD,
69 lpOverlapped: ?*OVERLAPPED,69 lpOverlapped: ?*OVERLAPPED,
70) callconv(.Stdcall) BOOL;70) callconv(WINAPI) BOOL;
7171
72pub extern "kernel32" fn DeleteFileW(lpFileName: [*:0]const u16) callconv(.Stdcall) BOOL;72pub extern "kernel32" fn DeleteFileW(lpFileName: [*:0]const u16) callconv(WINAPI) BOOL;
7373
74pub extern "kernel32" fn DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: *HANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) callconv(.Stdcall) BOOL;74pub extern "kernel32" fn DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: *HANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) callconv(WINAPI) BOOL;
7575
76pub extern "kernel32" fn ExitProcess(exit_code: UINT) callconv(.Stdcall) noreturn;76pub extern "kernel32" fn ExitProcess(exit_code: UINT) callconv(WINAPI) noreturn;
7777
78pub extern "kernel32" fn FindFirstFileW(lpFileName: [*:0]const u16, lpFindFileData: *WIN32_FIND_DATAW) callconv(.Stdcall) HANDLE;78pub extern "kernel32" fn FindFirstFileW(lpFileName: [*:0]const u16, lpFindFileData: *WIN32_FIND_DATAW) callconv(WINAPI) HANDLE;
79pub extern "kernel32" fn FindClose(hFindFile: HANDLE) callconv(.Stdcall) BOOL;79pub extern "kernel32" fn FindClose(hFindFile: HANDLE) callconv(WINAPI) BOOL;
80pub extern "kernel32" fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAW) callconv(.Stdcall) BOOL;80pub extern "kernel32" fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAW) callconv(WINAPI) BOOL;
8181
82pub extern "kernel32" fn FormatMessageW(dwFlags: DWORD, lpSource: ?LPVOID, dwMessageId: Win32Error, dwLanguageId: DWORD, lpBuffer: [*]u16, nSize: DWORD, Arguments: ?*va_list) callconv(.Stdcall) DWORD;82pub extern "kernel32" fn FormatMessageW(dwFlags: DWORD, lpSource: ?LPVOID, dwMessageId: Win32Error, dwLanguageId: DWORD, lpBuffer: [*]u16, nSize: DWORD, Arguments: ?*va_list) callconv(WINAPI) DWORD;
8383
84pub extern "kernel32" fn FreeEnvironmentStringsW(penv: [*:0]u16) callconv(.Stdcall) BOOL;84pub extern "kernel32" fn FreeEnvironmentStringsW(penv: [*:0]u16) callconv(WINAPI) BOOL;
8585
86pub extern "kernel32" fn GetCommandLineA() callconv(.Stdcall) LPSTR;86pub extern "kernel32" fn GetCommandLineA() callconv(WINAPI) LPSTR;
87pub extern "kernel32" fn GetCommandLineW() callconv(.Stdcall) LPWSTR;87pub extern "kernel32" fn GetCommandLineW() callconv(WINAPI) LPWSTR;
8888
89pub extern "kernel32" fn GetConsoleMode(in_hConsoleHandle: HANDLE, out_lpMode: *DWORD) callconv(.Stdcall) BOOL;89pub extern "kernel32" fn GetConsoleMode(in_hConsoleHandle: HANDLE, out_lpMode: *DWORD) callconv(WINAPI) BOOL;
9090
91pub extern "kernel32" fn GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO) callconv(.Stdcall) BOOL;91pub extern "kernel32" fn GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO) callconv(WINAPI) BOOL;
92pub extern "kernel32" fn FillConsoleOutputCharacterA(hConsoleOutput: HANDLE, cCharacter: TCHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD) callconv(.Stdcall) BOOL;92pub extern "kernel32" fn FillConsoleOutputCharacterA(hConsoleOutput: HANDLE, cCharacter: TCHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD) callconv(WINAPI) BOOL;
93pub extern "kernel32" fn FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD) callconv(.Stdcall) BOOL;93pub extern "kernel32" fn FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD) callconv(WINAPI) BOOL;
94pub extern "kernel32" fn SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) callconv(.Stdcall) BOOL;94pub extern "kernel32" fn SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) callconv(WINAPI) BOOL;
9595
96pub extern "kernel32" fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) callconv(.Stdcall) DWORD;96pub extern "kernel32" fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) callconv(WINAPI) DWORD;
9797
98pub extern "kernel32" fn GetCurrentThread() callconv(.Stdcall) HANDLE;98pub extern "kernel32" fn GetCurrentThread() callconv(WINAPI) HANDLE;
99pub extern "kernel32" fn GetCurrentThreadId() callconv(.Stdcall) DWORD;99pub extern "kernel32" fn GetCurrentThreadId() callconv(WINAPI) DWORD;
100100
101pub extern "kernel32" fn GetCurrentProcess() callconv(.Stdcall) HANDLE;101pub extern "kernel32" fn GetCurrentProcess() callconv(WINAPI) HANDLE;
102102
103pub extern "kernel32" fn GetEnvironmentStringsW() callconv(.Stdcall) ?[*:0]u16;103pub extern "kernel32" fn GetEnvironmentStringsW() callconv(WINAPI) ?[*:0]u16;
104104
105pub extern "kernel32" fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: [*]u16, nSize: DWORD) callconv(.Stdcall) DWORD;105pub extern "kernel32" fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: [*]u16, nSize: DWORD) callconv(WINAPI) DWORD;
106106
107pub extern "kernel32" fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *DWORD) callconv(.Stdcall) BOOL;107pub extern "kernel32" fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *DWORD) callconv(WINAPI) BOOL;
108108
109pub extern "kernel32" fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) callconv(.Stdcall) BOOL;109pub extern "kernel32" fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) callconv(WINAPI) BOOL;
110110
111pub extern "kernel32" fn GetFileAttributesW(lpFileName: [*]const WCHAR) callconv(.Stdcall) DWORD;111pub extern "kernel32" fn GetFileAttributesW(lpFileName: [*]const WCHAR) callconv(WINAPI) DWORD;
112112
113pub extern "kernel32" fn GetModuleFileNameW(hModule: ?HMODULE, lpFilename: [*]u16, nSize: DWORD) callconv(.Stdcall) DWORD;113pub extern "kernel32" fn GetModuleFileNameW(hModule: ?HMODULE, lpFilename: [*]u16, nSize: DWORD) callconv(WINAPI) DWORD;
114114
115pub extern "kernel32" fn GetModuleHandleW(lpModuleName: ?[*:0]const WCHAR) callconv(.Stdcall) ?HMODULE;115pub extern "kernel32" fn GetModuleHandleW(lpModuleName: ?[*:0]const WCHAR) callconv(WINAPI) ?HMODULE;
116116
117pub extern "kernel32" fn GetLastError() callconv(.Stdcall) Win32Error;117pub extern "kernel32" fn GetLastError() callconv(WINAPI) Win32Error;
118118
119pub extern "kernel32" fn GetFileInformationByHandle(119pub extern "kernel32" fn GetFileInformationByHandle(
120 hFile: HANDLE,120 hFile: HANDLE,
121 lpFileInformation: *BY_HANDLE_FILE_INFORMATION,121 lpFileInformation: *BY_HANDLE_FILE_INFORMATION,
122) callconv(.Stdcall) BOOL;122) callconv(WINAPI) BOOL;
123123
124pub extern "kernel32" fn GetFileInformationByHandleEx(124pub extern "kernel32" fn GetFileInformationByHandleEx(
125 in_hFile: HANDLE,125 in_hFile: HANDLE,
126 in_FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,126 in_FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
127 out_lpFileInformation: *c_void,127 out_lpFileInformation: *c_void,
128 in_dwBufferSize: DWORD,128 in_dwBufferSize: DWORD,
129) callconv(.Stdcall) BOOL;129) callconv(WINAPI) BOOL;
130130
131pub extern "kernel32" fn GetFinalPathNameByHandleW(131pub extern "kernel32" fn GetFinalPathNameByHandleW(
132 hFile: HANDLE,132 hFile: HANDLE,
133 lpszFilePath: [*]u16,133 lpszFilePath: [*]u16,
134 cchFilePath: DWORD,134 cchFilePath: DWORD,
135 dwFlags: DWORD,135 dwFlags: DWORD,
136) callconv(.Stdcall) DWORD;136) callconv(WINAPI) DWORD;
137137
138pub extern "kernel32" fn GetOverlappedResult(hFile: HANDLE, lpOverlapped: *OVERLAPPED, lpNumberOfBytesTransferred: *DWORD, bWait: BOOL) callconv(.Stdcall) BOOL;138pub extern "kernel32" fn GetOverlappedResult(hFile: HANDLE, lpOverlapped: *OVERLAPPED, lpNumberOfBytesTransferred: *DWORD, bWait: BOOL) callconv(WINAPI) BOOL;
139139
140pub extern "kernel32" fn GetProcessHeap() callconv(.Stdcall) ?HANDLE;140pub extern "kernel32" fn GetProcessHeap() callconv(WINAPI) ?HANDLE;
141pub extern "kernel32" fn GetQueuedCompletionStatus(CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: *ULONG_PTR, lpOverlapped: *?*OVERLAPPED, dwMilliseconds: DWORD) callconv(.Stdcall) BOOL;141pub extern "kernel32" fn GetQueuedCompletionStatus(CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: *ULONG_PTR, lpOverlapped: *?*OVERLAPPED, dwMilliseconds: DWORD) callconv(WINAPI) BOOL;
142142
143pub extern "kernel32" fn GetSystemInfo(lpSystemInfo: *SYSTEM_INFO) callconv(.Stdcall) void;143pub extern "kernel32" fn GetSystemInfo(lpSystemInfo: *SYSTEM_INFO) callconv(WINAPI) void;
144pub extern "kernel32" fn GetSystemTimeAsFileTime(*FILETIME) callconv(.Stdcall) void;144pub extern "kernel32" fn GetSystemTimeAsFileTime(*FILETIME) callconv(WINAPI) void;
145145
146pub extern "kernel32" fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) callconv(.Stdcall) ?HANDLE;146pub extern "kernel32" fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) callconv(WINAPI) ?HANDLE;
147pub extern "kernel32" fn HeapDestroy(hHeap: HANDLE) callconv(.Stdcall) BOOL;147pub extern "kernel32" fn HeapDestroy(hHeap: HANDLE) callconv(WINAPI) BOOL;
148pub extern "kernel32" fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void, dwBytes: SIZE_T) callconv(.Stdcall) ?*c_void;148pub extern "kernel32" fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void, dwBytes: SIZE_T) callconv(WINAPI) ?*c_void;
149pub extern "kernel32" fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) callconv(.Stdcall) SIZE_T;149pub extern "kernel32" fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) callconv(WINAPI) SIZE_T;
150pub extern "kernel32" fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) callconv(.Stdcall) SIZE_T;150pub extern "kernel32" fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) callconv(WINAPI) SIZE_T;
151pub extern "kernel32" fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) callconv(.Stdcall) BOOL;151pub extern "kernel32" fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) callconv(WINAPI) BOOL;
152152
153pub extern "kernel32" fn GetStdHandle(in_nStdHandle: DWORD) callconv(.Stdcall) ?HANDLE;153pub extern "kernel32" fn GetStdHandle(in_nStdHandle: DWORD) callconv(WINAPI) ?HANDLE;
154154
155pub extern "kernel32" fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) callconv(.Stdcall) ?*c_void;155pub extern "kernel32" fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) callconv(WINAPI) ?*c_void;
156156
157pub extern "kernel32" fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void) callconv(.Stdcall) BOOL;157pub extern "kernel32" fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void) callconv(WINAPI) BOOL;
158158
159pub extern "kernel32" fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*const c_void) callconv(.Stdcall) BOOL;159pub extern "kernel32" fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*const c_void) callconv(WINAPI) BOOL;
160160
161pub extern "kernel32" fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) callconv(.Stdcall) ?LPVOID;161pub extern "kernel32" fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) callconv(WINAPI) ?LPVOID;
162pub extern "kernel32" fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) callconv(.Stdcall) BOOL;162pub extern "kernel32" fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) callconv(WINAPI) BOOL;
163163
164pub extern "kernel32" fn MoveFileExW(164pub extern "kernel32" fn MoveFileExW(
165 lpExistingFileName: [*:0]const u16,165 lpExistingFileName: [*:0]const u16,
166 lpNewFileName: [*:0]const u16,166 lpNewFileName: [*:0]const u16,
167 dwFlags: DWORD,167 dwFlags: DWORD,
168) callconv(.Stdcall) BOOL;168) callconv(WINAPI) BOOL;
169169
170pub extern "kernel32" fn PostQueuedCompletionStatus(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: ?*OVERLAPPED) callconv(.Stdcall) BOOL;170pub extern "kernel32" fn PostQueuedCompletionStatus(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: ?*OVERLAPPED) callconv(WINAPI) BOOL;
171171
172pub extern "kernel32" fn QueryPerformanceCounter(lpPerformanceCount: *LARGE_INTEGER) callconv(.Stdcall) BOOL;172pub extern "kernel32" fn QueryPerformanceCounter(lpPerformanceCount: *LARGE_INTEGER) callconv(WINAPI) BOOL;
173173
174pub extern "kernel32" fn QueryPerformanceFrequency(lpFrequency: *LARGE_INTEGER) callconv(.Stdcall) BOOL;174pub extern "kernel32" fn QueryPerformanceFrequency(lpFrequency: *LARGE_INTEGER) callconv(WINAPI) BOOL;
175175
176pub extern "kernel32" fn ReadDirectoryChangesW(176pub extern "kernel32" fn ReadDirectoryChangesW(
177 hDirectory: HANDLE,177 hDirectory: HANDLE,
...@@ -182,7 +182,7 @@ pub extern "kernel32" fn ReadDirectoryChangesW(...@@ -182,7 +182,7 @@ pub extern "kernel32" fn ReadDirectoryChangesW(
182 lpBytesReturned: ?*DWORD,182 lpBytesReturned: ?*DWORD,
183 lpOverlapped: ?*OVERLAPPED,183 lpOverlapped: ?*OVERLAPPED,
184 lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,184 lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
185) callconv(.Stdcall) BOOL;185) callconv(WINAPI) BOOL;
186186
187pub extern "kernel32" fn ReadFile(187pub extern "kernel32" fn ReadFile(
188 in_hFile: HANDLE,188 in_hFile: HANDLE,
...@@ -190,43 +190,43 @@ pub extern "kernel32" fn ReadFile(...@@ -190,43 +190,43 @@ pub extern "kernel32" fn ReadFile(
190 in_nNumberOfBytesToRead: DWORD,190 in_nNumberOfBytesToRead: DWORD,
191 out_lpNumberOfBytesRead: ?*DWORD,191 out_lpNumberOfBytesRead: ?*DWORD,
192 in_out_lpOverlapped: ?*OVERLAPPED,192 in_out_lpOverlapped: ?*OVERLAPPED,
193) callconv(.Stdcall) BOOL;193) callconv(WINAPI) BOOL;
194194
195pub extern "kernel32" fn RemoveDirectoryW(lpPathName: [*:0]const u16) callconv(.Stdcall) BOOL;195pub extern "kernel32" fn RemoveDirectoryW(lpPathName: [*:0]const u16) callconv(WINAPI) BOOL;
196196
197pub extern "kernel32" fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) callconv(.Stdcall) BOOL;197pub extern "kernel32" fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) callconv(WINAPI) BOOL;
198198
199pub extern "kernel32" fn SetFilePointerEx(199pub extern "kernel32" fn SetFilePointerEx(
200 in_fFile: HANDLE,200 in_fFile: HANDLE,
201 in_liDistanceToMove: LARGE_INTEGER,201 in_liDistanceToMove: LARGE_INTEGER,
202 out_opt_ldNewFilePointer: ?*LARGE_INTEGER,202 out_opt_ldNewFilePointer: ?*LARGE_INTEGER,
203 in_dwMoveMethod: DWORD,203 in_dwMoveMethod: DWORD,
204) callconv(.Stdcall) BOOL;204) callconv(WINAPI) BOOL;
205205
206pub extern "kernel32" fn SetFileTime(206pub extern "kernel32" fn SetFileTime(
207 hFile: HANDLE,207 hFile: HANDLE,
208 lpCreationTime: ?*const FILETIME,208 lpCreationTime: ?*const FILETIME,
209 lpLastAccessTime: ?*const FILETIME,209 lpLastAccessTime: ?*const FILETIME,
210 lpLastWriteTime: ?*const FILETIME,210 lpLastWriteTime: ?*const FILETIME,
211) callconv(.Stdcall) BOOL;211) callconv(WINAPI) BOOL;
212212
213pub extern "kernel32" fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) callconv(.Stdcall) BOOL;213pub extern "kernel32" fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) callconv(WINAPI) BOOL;
214214
215pub extern "kernel32" fn Sleep(dwMilliseconds: DWORD) callconv(.Stdcall) void;215pub extern "kernel32" fn Sleep(dwMilliseconds: DWORD) callconv(WINAPI) void;
216216
217pub extern "kernel32" fn SwitchToThread() callconv(.Stdcall) BOOL;217pub extern "kernel32" fn SwitchToThread() callconv(WINAPI) BOOL;
218218
219pub extern "kernel32" fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) callconv(.Stdcall) BOOL;219pub extern "kernel32" fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) callconv(WINAPI) BOOL;
220220
221pub extern "kernel32" fn TlsAlloc() callconv(.Stdcall) DWORD;221pub extern "kernel32" fn TlsAlloc() callconv(WINAPI) DWORD;
222222
223pub extern "kernel32" fn TlsFree(dwTlsIndex: DWORD) callconv(.Stdcall) BOOL;223pub extern "kernel32" fn TlsFree(dwTlsIndex: DWORD) callconv(WINAPI) BOOL;
224224
225pub extern "kernel32" fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) callconv(.Stdcall) DWORD;225pub extern "kernel32" fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) callconv(WINAPI) DWORD;
226226
227pub extern "kernel32" fn WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL) callconv(.Stdcall) DWORD;227pub extern "kernel32" fn WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL) callconv(WINAPI) DWORD;
228228
229pub extern "kernel32" fn WaitForMultipleObjects(nCount: DWORD, lpHandle: [*]const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) callconv(.Stdcall) DWORD;229pub extern "kernel32" fn WaitForMultipleObjects(nCount: DWORD, lpHandle: [*]const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) callconv(WINAPI) DWORD;
230230
231pub extern "kernel32" fn WaitForMultipleObjectsEx(231pub extern "kernel32" fn WaitForMultipleObjectsEx(
232 nCount: DWORD,232 nCount: DWORD,
...@@ -234,7 +234,7 @@ pub extern "kernel32" fn WaitForMultipleObjectsEx(...@@ -234,7 +234,7 @@ pub extern "kernel32" fn WaitForMultipleObjectsEx(
234 bWaitAll: BOOL,234 bWaitAll: BOOL,
235 dwMilliseconds: DWORD,235 dwMilliseconds: DWORD,
236 bAlertable: BOOL,236 bAlertable: BOOL,
237) callconv(.Stdcall) DWORD;237) callconv(WINAPI) DWORD;
238238
239pub extern "kernel32" fn WriteFile(239pub extern "kernel32" fn WriteFile(
240 in_hFile: HANDLE,240 in_hFile: HANDLE,
...@@ -242,49 +242,49 @@ pub extern "kernel32" fn WriteFile(...@@ -242,49 +242,49 @@ pub extern "kernel32" fn WriteFile(
242 in_nNumberOfBytesToWrite: DWORD,242 in_nNumberOfBytesToWrite: DWORD,
243 out_lpNumberOfBytesWritten: ?*DWORD,243 out_lpNumberOfBytesWritten: ?*DWORD,
244 in_out_lpOverlapped: ?*OVERLAPPED,244 in_out_lpOverlapped: ?*OVERLAPPED,
245) callconv(.Stdcall) BOOL;245) callconv(WINAPI) BOOL;
246246
247pub extern "kernel32" fn WriteFileEx(hFile: HANDLE, lpBuffer: [*]const u8, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) callconv(.Stdcall) BOOL;247pub extern "kernel32" fn WriteFileEx(hFile: HANDLE, lpBuffer: [*]const u8, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) callconv(WINAPI) BOOL;
248248
249pub extern "kernel32" fn LoadLibraryW(lpLibFileName: [*:0]const u16) callconv(.Stdcall) ?HMODULE;249pub extern "kernel32" fn LoadLibraryW(lpLibFileName: [*:0]const u16) callconv(WINAPI) ?HMODULE;
250250
251pub extern "kernel32" fn GetProcAddress(hModule: HMODULE, lpProcName: [*]const u8) callconv(.Stdcall) ?FARPROC;251pub extern "kernel32" fn GetProcAddress(hModule: HMODULE, lpProcName: [*]const u8) callconv(WINAPI) ?FARPROC;
252252
253pub extern "kernel32" fn FreeLibrary(hModule: HMODULE) callconv(.Stdcall) BOOL;253pub extern "kernel32" fn FreeLibrary(hModule: HMODULE) callconv(WINAPI) BOOL;
254254
255pub extern "kernel32" fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;255pub extern "kernel32" fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
256pub extern "kernel32" fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;256pub extern "kernel32" fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
257pub extern "kernel32" fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;257pub extern "kernel32" fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
258pub extern "kernel32" fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;258pub extern "kernel32" fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
259259
260pub extern "kernel32" fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*c_void, Context: ?*c_void) callconv(.Stdcall) BOOL;260pub extern "kernel32" fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*c_void, Context: ?*c_void) callconv(WINAPI) BOOL;
261261
262pub extern "kernel32" fn K32EmptyWorkingSet(hProcess: HANDLE) callconv(.Stdcall) BOOL;262pub extern "kernel32" fn K32EmptyWorkingSet(hProcess: HANDLE) callconv(WINAPI) BOOL;
263pub extern "kernel32" fn K32EnumDeviceDrivers(lpImageBase: [*]LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) callconv(.Stdcall) BOOL;263pub extern "kernel32" fn K32EnumDeviceDrivers(lpImageBase: [*]LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) callconv(WINAPI) BOOL;
264pub extern "kernel32" fn K32EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID) callconv(.Stdcall) BOOL;264pub extern "kernel32" fn K32EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID) callconv(WINAPI) BOOL;
265pub extern "kernel32" fn K32EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID) callconv(.Stdcall) BOOL;265pub extern "kernel32" fn K32EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID) callconv(WINAPI) BOOL;
266pub extern "kernel32" fn K32EnumProcessModules(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD) callconv(.Stdcall) BOOL;266pub extern "kernel32" fn K32EnumProcessModules(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD) callconv(WINAPI) BOOL;
267pub extern "kernel32" fn K32EnumProcessModulesEx(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD) callconv(.Stdcall) BOOL;267pub extern "kernel32" fn K32EnumProcessModulesEx(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD) callconv(WINAPI) BOOL;
268pub extern "kernel32" fn K32EnumProcesses(lpidProcess: [*]DWORD, cb: DWORD, cbNeeded: LPDWORD) callconv(.Stdcall) BOOL;268pub extern "kernel32" fn K32EnumProcesses(lpidProcess: [*]DWORD, cb: DWORD, cbNeeded: LPDWORD) callconv(WINAPI) BOOL;
269pub extern "kernel32" fn K32GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;269pub extern "kernel32" fn K32GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
270pub extern "kernel32" fn K32GetDeviceDriverBaseNameW(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;270pub extern "kernel32" fn K32GetDeviceDriverBaseNameW(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
271pub extern "kernel32" fn K32GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;271pub extern "kernel32" fn K32GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
272pub extern "kernel32" fn K32GetDeviceDriverFileNameW(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;272pub extern "kernel32" fn K32GetDeviceDriverFileNameW(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
273pub extern "kernel32" fn K32GetMappedFileNameA(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;273pub extern "kernel32" fn K32GetMappedFileNameA(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
274pub extern "kernel32" fn K32GetMappedFileNameW(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;274pub extern "kernel32" fn K32GetMappedFileNameW(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
275pub extern "kernel32" fn K32GetModuleBaseNameA(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;275pub extern "kernel32" fn K32GetModuleBaseNameA(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
276pub extern "kernel32" fn K32GetModuleBaseNameW(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;276pub extern "kernel32" fn K32GetModuleBaseNameW(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
277pub extern "kernel32" fn K32GetModuleFileNameExA(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;277pub extern "kernel32" fn K32GetModuleFileNameExA(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
278pub extern "kernel32" fn K32GetModuleFileNameExW(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;278pub extern "kernel32" fn K32GetModuleFileNameExW(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
279pub extern "kernel32" fn K32GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD) callconv(.Stdcall) BOOL;279pub extern "kernel32" fn K32GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD) callconv(WINAPI) BOOL;
280pub extern "kernel32" fn K32GetPerformanceInfo(pPerformanceInformation: PPERFORMACE_INFORMATION, cb: DWORD) callconv(.Stdcall) BOOL;280pub extern "kernel32" fn K32GetPerformanceInfo(pPerformanceInformation: PPERFORMACE_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
281pub extern "kernel32" fn K32GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;281pub extern "kernel32" fn K32GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
282pub extern "kernel32" fn K32GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;282pub extern "kernel32" fn K32GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
283pub extern "kernel32" fn K32GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD) callconv(.Stdcall) BOOL;283pub extern "kernel32" fn K32GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD) callconv(WINAPI) BOOL;
284pub extern "kernel32" fn K32GetWsChanges(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD) callconv(.Stdcall) BOOL;284pub extern "kernel32" fn K32GetWsChanges(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
285pub extern "kernel32" fn K32GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD) callconv(.Stdcall) BOOL;285pub extern "kernel32" fn K32GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD) callconv(WINAPI) BOOL;
286pub extern "kernel32" fn K32InitializeProcessForWsWatch(hProcess: HANDLE) callconv(.Stdcall) BOOL;286pub extern "kernel32" fn K32InitializeProcessForWsWatch(hProcess: HANDLE) callconv(WINAPI) BOOL;
287pub extern "kernel32" fn K32QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;287pub extern "kernel32" fn K32QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
288pub extern "kernel32" fn K32QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;288pub extern "kernel32" fn K32QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
289289
290pub extern "kernel32" fn FlushFileBuffers(hFile: HANDLE) callconv(.Stdcall) BOOL;290pub extern "kernel32" fn FlushFileBuffers(hFile: HANDLE) callconv(WINAPI) BOOL;
lib/std/os/windows/ntdll.zig+16-16
...@@ -7,32 +7,32 @@ usingnamespace @import("bits.zig");...@@ -7,32 +7,32 @@ usingnamespace @import("bits.zig");
77
8pub extern "NtDll" fn RtlGetVersion(8pub extern "NtDll" fn RtlGetVersion(
9 lpVersionInformation: PRTL_OSVERSIONINFOW,9 lpVersionInformation: PRTL_OSVERSIONINFOW,
10) callconv(.Stdcall) NTSTATUS;10) callconv(WINAPI) NTSTATUS;
11pub extern "NtDll" fn RtlCaptureStackBackTrace(11pub extern "NtDll" fn RtlCaptureStackBackTrace(
12 FramesToSkip: DWORD,12 FramesToSkip: DWORD,
13 FramesToCapture: DWORD,13 FramesToCapture: DWORD,
14 BackTrace: **c_void,14 BackTrace: **c_void,
15 BackTraceHash: ?*DWORD,15 BackTraceHash: ?*DWORD,
16) callconv(.Stdcall) WORD;16) callconv(WINAPI) WORD;
17pub extern "NtDll" fn NtQueryInformationFile(17pub extern "NtDll" fn NtQueryInformationFile(
18 FileHandle: HANDLE,18 FileHandle: HANDLE,
19 IoStatusBlock: *IO_STATUS_BLOCK,19 IoStatusBlock: *IO_STATUS_BLOCK,
20 FileInformation: *c_void,20 FileInformation: *c_void,
21 Length: ULONG,21 Length: ULONG,
22 FileInformationClass: FILE_INFORMATION_CLASS,22 FileInformationClass: FILE_INFORMATION_CLASS,
23) callconv(.Stdcall) NTSTATUS;23) callconv(WINAPI) NTSTATUS;
24pub extern "NtDll" fn NtSetInformationFile(24pub extern "NtDll" fn NtSetInformationFile(
25 FileHandle: HANDLE,25 FileHandle: HANDLE,
26 IoStatusBlock: *IO_STATUS_BLOCK,26 IoStatusBlock: *IO_STATUS_BLOCK,
27 FileInformation: PVOID,27 FileInformation: PVOID,
28 Length: ULONG,28 Length: ULONG,
29 FileInformationClass: FILE_INFORMATION_CLASS,29 FileInformationClass: FILE_INFORMATION_CLASS,
30) callconv(.Stdcall) NTSTATUS;30) callconv(WINAPI) NTSTATUS;
3131
32pub extern "NtDll" fn NtQueryAttributesFile(32pub extern "NtDll" fn NtQueryAttributesFile(
33 ObjectAttributes: *OBJECT_ATTRIBUTES,33 ObjectAttributes: *OBJECT_ATTRIBUTES,
34 FileAttributes: *FILE_BASIC_INFORMATION,34 FileAttributes: *FILE_BASIC_INFORMATION,
35) callconv(.Stdcall) NTSTATUS;35) callconv(WINAPI) NTSTATUS;
3636
37pub extern "NtDll" fn NtCreateFile(37pub extern "NtDll" fn NtCreateFile(
38 FileHandle: *HANDLE,38 FileHandle: *HANDLE,
...@@ -46,7 +46,7 @@ pub extern "NtDll" fn NtCreateFile(...@@ -46,7 +46,7 @@ pub extern "NtDll" fn NtCreateFile(
46 CreateOptions: ULONG,46 CreateOptions: ULONG,
47 EaBuffer: ?*c_void,47 EaBuffer: ?*c_void,
48 EaLength: ULONG,48 EaLength: ULONG,
49) callconv(.Stdcall) NTSTATUS;49) callconv(WINAPI) NTSTATUS;
50pub extern "NtDll" fn NtDeviceIoControlFile(50pub extern "NtDll" fn NtDeviceIoControlFile(
51 FileHandle: HANDLE,51 FileHandle: HANDLE,
52 Event: ?HANDLE,52 Event: ?HANDLE,
...@@ -58,7 +58,7 @@ pub extern "NtDll" fn NtDeviceIoControlFile(...@@ -58,7 +58,7 @@ pub extern "NtDll" fn NtDeviceIoControlFile(
58 InputBufferLength: ULONG,58 InputBufferLength: ULONG,
59 OutputBuffer: ?PVOID,59 OutputBuffer: ?PVOID,
60 OutputBufferLength: ULONG,60 OutputBufferLength: ULONG,
61) callconv(.Stdcall) NTSTATUS;61) callconv(WINAPI) NTSTATUS;
62pub extern "NtDll" fn NtFsControlFile(62pub extern "NtDll" fn NtFsControlFile(
63 FileHandle: HANDLE,63 FileHandle: HANDLE,
64 Event: ?HANDLE,64 Event: ?HANDLE,
...@@ -70,15 +70,15 @@ pub extern "NtDll" fn NtFsControlFile(...@@ -70,15 +70,15 @@ pub extern "NtDll" fn NtFsControlFile(
70 InputBufferLength: ULONG,70 InputBufferLength: ULONG,
71 OutputBuffer: ?PVOID,71 OutputBuffer: ?PVOID,
72 OutputBufferLength: ULONG,72 OutputBufferLength: ULONG,
73) callconv(.Stdcall) NTSTATUS;73) callconv(WINAPI) NTSTATUS;
74pub extern "NtDll" fn NtClose(Handle: HANDLE) callconv(.Stdcall) NTSTATUS;74pub extern "NtDll" fn NtClose(Handle: HANDLE) callconv(WINAPI) NTSTATUS;
75pub extern "NtDll" fn RtlDosPathNameToNtPathName_U(75pub extern "NtDll" fn RtlDosPathNameToNtPathName_U(
76 DosPathName: [*:0]const u16,76 DosPathName: [*:0]const u16,
77 NtPathName: *UNICODE_STRING,77 NtPathName: *UNICODE_STRING,
78 NtFileNamePart: ?*?[*:0]const u16,78 NtFileNamePart: ?*?[*:0]const u16,
79 DirectoryInfo: ?*CURDIR,79 DirectoryInfo: ?*CURDIR,
80) callconv(.Stdcall) BOOL;80) callconv(WINAPI) BOOL;
81pub extern "NtDll" fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) callconv(.Stdcall) void;81pub extern "NtDll" fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) callconv(WINAPI) void;
8282
83pub extern "NtDll" fn NtQueryDirectoryFile(83pub extern "NtDll" fn NtQueryDirectoryFile(
84 FileHandle: HANDLE,84 FileHandle: HANDLE,
...@@ -92,26 +92,26 @@ pub extern "NtDll" fn NtQueryDirectoryFile(...@@ -92,26 +92,26 @@ pub extern "NtDll" fn NtQueryDirectoryFile(
92 ReturnSingleEntry: BOOLEAN,92 ReturnSingleEntry: BOOLEAN,
93 FileName: ?*UNICODE_STRING,93 FileName: ?*UNICODE_STRING,
94 RestartScan: BOOLEAN,94 RestartScan: BOOLEAN,
95) callconv(.Stdcall) NTSTATUS;95) callconv(WINAPI) NTSTATUS;
96pub extern "NtDll" fn NtCreateKeyedEvent(96pub extern "NtDll" fn NtCreateKeyedEvent(
97 KeyedEventHandle: *HANDLE,97 KeyedEventHandle: *HANDLE,
98 DesiredAccess: ACCESS_MASK,98 DesiredAccess: ACCESS_MASK,
99 ObjectAttributes: ?PVOID,99 ObjectAttributes: ?PVOID,
100 Flags: ULONG,100 Flags: ULONG,
101) callconv(.Stdcall) NTSTATUS;101) callconv(WINAPI) NTSTATUS;
102pub extern "NtDll" fn NtReleaseKeyedEvent(102pub extern "NtDll" fn NtReleaseKeyedEvent(
103 EventHandle: HANDLE,103 EventHandle: HANDLE,
104 Key: *const c_void,104 Key: *const c_void,
105 Alertable: BOOLEAN,105 Alertable: BOOLEAN,
106 Timeout: ?*LARGE_INTEGER,106 Timeout: ?*LARGE_INTEGER,
107) callconv(.Stdcall) NTSTATUS;107) callconv(WINAPI) NTSTATUS;
108pub extern "NtDll" fn NtWaitForKeyedEvent(108pub extern "NtDll" fn NtWaitForKeyedEvent(
109 EventHandle: HANDLE,109 EventHandle: HANDLE,
110 Key: *const c_void,110 Key: *const c_void,
111 Alertable: BOOLEAN,111 Alertable: BOOLEAN,
112 Timeout: ?*LARGE_INTEGER,112 Timeout: ?*LARGE_INTEGER,
113) callconv(.Stdcall) NTSTATUS;113) callconv(WINAPI) NTSTATUS;
114114
115pub extern "NtDll" fn RtlSetCurrentDirectory_U(115pub extern "NtDll" fn RtlSetCurrentDirectory_U(
116 PathName: *UNICODE_STRING116 PathName: *UNICODE_STRING
117) callconv(.Stdcall) NTSTATUS;117) callconv(WINAPI) NTSTATUS;
lib/std/os/windows/ole32.zig+4-4
...@@ -5,7 +5,7 @@...@@ -5,7 +5,7 @@
5// and substantial portions of the software.5// and substantial portions of the software.
6usingnamespace @import("bits.zig");6usingnamespace @import("bits.zig");
77
8pub extern "ole32" fn CoTaskMemFree(pv: LPVOID) callconv(.Stdcall) void;8pub extern "ole32" fn CoTaskMemFree(pv: LPVOID) callconv(WINAPI) void;
9pub extern "ole32" fn CoUninitialize() callconv(.Stdcall) void;9pub extern "ole32" fn CoUninitialize() callconv(WINAPI) void;
10pub extern "ole32" fn CoGetCurrentProcess() callconv(.Stdcall) DWORD;10pub extern "ole32" fn CoGetCurrentProcess() callconv(WINAPI) DWORD;
11pub extern "ole32" fn CoInitializeEx(pvReserved: ?LPVOID, dwCoInit: DWORD) callconv(.Stdcall) HRESULT;11pub extern "ole32" fn CoInitializeEx(pvReserved: ?LPVOID, dwCoInit: DWORD) callconv(WINAPI) HRESULT;
lib/std/os/windows/psapi.zig+27-27
...@@ -5,30 +5,30 @@...@@ -5,30 +5,30 @@
5// and substantial portions of the software.5// and substantial portions of the software.
6usingnamespace @import("bits.zig");6usingnamespace @import("bits.zig");
77
8pub extern "psapi" fn EmptyWorkingSet(hProcess: HANDLE) callconv(.Stdcall) BOOL;8pub extern "psapi" fn EmptyWorkingSet(hProcess: HANDLE) callconv(WINAPI) BOOL;
9pub extern "psapi" fn EnumDeviceDrivers(lpImageBase: [*]LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) callconv(.Stdcall) BOOL;9pub extern "psapi" fn EnumDeviceDrivers(lpImageBase: [*]LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) callconv(WINAPI) BOOL;
10pub extern "psapi" fn EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID) callconv(.Stdcall) BOOL;10pub extern "psapi" fn EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID) callconv(WINAPI) BOOL;
11pub extern "psapi" fn EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID) callconv(.Stdcall) BOOL;11pub extern "psapi" fn EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID) callconv(WINAPI) BOOL;
12pub extern "psapi" fn EnumProcessModules(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD) callconv(.Stdcall) BOOL;12pub extern "psapi" fn EnumProcessModules(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD) callconv(WINAPI) BOOL;
13pub extern "psapi" fn EnumProcessModulesEx(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD) callconv(.Stdcall) BOOL;13pub extern "psapi" fn EnumProcessModulesEx(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD) callconv(WINAPI) BOOL;
14pub extern "psapi" fn EnumProcesses(lpidProcess: [*]DWORD, cb: DWORD, cbNeeded: LPDWORD) callconv(.Stdcall) BOOL;14pub extern "psapi" fn EnumProcesses(lpidProcess: [*]DWORD, cb: DWORD, cbNeeded: LPDWORD) callconv(WINAPI) BOOL;
15pub extern "psapi" fn GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;15pub extern "psapi" fn GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
16pub extern "psapi" fn GetDeviceDriverBaseNameW(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;16pub extern "psapi" fn GetDeviceDriverBaseNameW(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
17pub extern "psapi" fn GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;17pub extern "psapi" fn GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
18pub extern "psapi" fn GetDeviceDriverFileNameW(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;18pub extern "psapi" fn GetDeviceDriverFileNameW(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
19pub extern "psapi" fn GetMappedFileNameA(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;19pub extern "psapi" fn GetMappedFileNameA(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
20pub extern "psapi" fn GetMappedFileNameW(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;20pub extern "psapi" fn GetMappedFileNameW(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
21pub extern "psapi" fn GetModuleBaseNameA(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;21pub extern "psapi" fn GetModuleBaseNameA(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
22pub extern "psapi" fn GetModuleBaseNameW(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;22pub extern "psapi" fn GetModuleBaseNameW(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
23pub extern "psapi" fn GetModuleFileNameExA(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;23pub extern "psapi" fn GetModuleFileNameExA(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
24pub extern "psapi" fn GetModuleFileNameExW(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;24pub extern "psapi" fn GetModuleFileNameExW(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
25pub extern "psapi" fn GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD) callconv(.Stdcall) BOOL;25pub extern "psapi" fn GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD) callconv(WINAPI) BOOL;
26pub extern "psapi" fn GetPerformanceInfo(pPerformanceInformation: PPERFORMACE_INFORMATION, cb: DWORD) callconv(.Stdcall) BOOL;26pub extern "psapi" fn GetPerformanceInfo(pPerformanceInformation: PPERFORMACE_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
27pub extern "psapi" fn GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;27pub extern "psapi" fn GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
28pub extern "psapi" fn GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;28pub extern "psapi" fn GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
29pub extern "psapi" fn GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD) callconv(.Stdcall) BOOL;29pub extern "psapi" fn GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD) callconv(WINAPI) BOOL;
30pub extern "psapi" fn GetWsChanges(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD) callconv(.Stdcall) BOOL;30pub extern "psapi" fn GetWsChanges(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
31pub extern "psapi" fn GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD) callconv(.Stdcall) BOOL;31pub extern "psapi" fn GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD) callconv(WINAPI) BOOL;
32pub extern "psapi" fn InitializeProcessForWsWatch(hProcess: HANDLE) callconv(.Stdcall) BOOL;32pub extern "psapi" fn InitializeProcessForWsWatch(hProcess: HANDLE) callconv(WINAPI) BOOL;
33pub extern "psapi" fn QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;33pub extern "psapi" fn QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
34pub extern "psapi" fn QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;34pub extern "psapi" fn QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
lib/std/os/windows/shell32.zig+1-1
...@@ -5,4 +5,4 @@...@@ -5,4 +5,4 @@
5// and substantial portions of the software.5// and substantial portions of the software.
6usingnamespace @import("bits.zig");6usingnamespace @import("bits.zig");
77
8pub extern "shell32" fn SHGetKnownFolderPath(rfid: *const KNOWNFOLDERID, dwFlags: DWORD, hToken: ?HANDLE, ppszPath: *[*:0]WCHAR) callconv(.Stdcall) HRESULT;8pub extern "shell32" fn SHGetKnownFolderPath(rfid: *const KNOWNFOLDERID, dwFlags: DWORD, hToken: ?HANDLE, ppszPath: *[*:0]WCHAR) callconv(WINAPI) HRESULT;
lib/std/os/windows/user32.zig+12-12
...@@ -103,7 +103,7 @@ pub const CS_OWNDC = 0x0020;...@@ -103,7 +103,7 @@ pub const CS_OWNDC = 0x0020;
103pub const SW_HIDE = 0;103pub const SW_HIDE = 0;
104pub const SW_SHOW = 5;104pub const SW_SHOW = 5;
105105
106pub const WNDPROC = fn (HWND, UINT, WPARAM, LPARAM) callconv(.Stdcall) LRESULT;106pub const WNDPROC = fn (HWND, UINT, WPARAM, LPARAM) callconv(WINAPI) LRESULT;
107107
108pub const WNDCLASSEXA = extern struct {108pub const WNDCLASSEXA = extern struct {
109 cbSize: UINT = @sizeOf(WNDCLASSEXA),109 cbSize: UINT = @sizeOf(WNDCLASSEXA),
...@@ -147,13 +147,13 @@ pub extern "user32" fn CreateWindowExA(...@@ -147,13 +147,13 @@ pub extern "user32" fn CreateWindowExA(
147 hMenu: ?HMENU,147 hMenu: ?HMENU,
148 hInstance: HINSTANCE,148 hInstance: HINSTANCE,
149 lpParam: ?LPVOID,149 lpParam: ?LPVOID,
150) callconv(.Stdcall) ?HWND;150) callconv(WINAPI) ?HWND;
151151
152pub extern "user32" fn RegisterClassExA(*const WNDCLASSEXA) callconv(.Stdcall) c_ushort;152pub extern "user32" fn RegisterClassExA(*const WNDCLASSEXA) callconv(WINAPI) c_ushort;
153pub extern "user32" fn DefWindowProcA(HWND, Msg: UINT, WPARAM, LPARAM) callconv(.Stdcall) LRESULT;153pub extern "user32" fn DefWindowProcA(HWND, Msg: UINT, WPARAM, LPARAM) callconv(WINAPI) LRESULT;
154pub extern "user32" fn ShowWindow(hWnd: ?HWND, nCmdShow: i32) callconv(.Stdcall) bool;154pub extern "user32" fn ShowWindow(hWnd: ?HWND, nCmdShow: i32) callconv(WINAPI) bool;
155pub extern "user32" fn UpdateWindow(hWnd: ?HWND) callconv(.Stdcall) bool;155pub extern "user32" fn UpdateWindow(hWnd: ?HWND) callconv(WINAPI) bool;
156pub extern "user32" fn GetDC(hWnd: ?HWND) callconv(.Stdcall) ?HDC;156pub extern "user32" fn GetDC(hWnd: ?HWND) callconv(WINAPI) ?HDC;
157157
158pub extern "user32" fn PeekMessageA(158pub extern "user32" fn PeekMessageA(
159 lpMsg: ?*MSG,159 lpMsg: ?*MSG,
...@@ -161,15 +161,15 @@ pub extern "user32" fn PeekMessageA(...@@ -161,15 +161,15 @@ pub extern "user32" fn PeekMessageA(
161 wMsgFilterMin: UINT,161 wMsgFilterMin: UINT,
162 wMsgFilterMax: UINT,162 wMsgFilterMax: UINT,
163 wRemoveMsg: UINT,163 wRemoveMsg: UINT,
164) callconv(.Stdcall) bool;164) callconv(WINAPI) bool;
165165
166pub extern "user32" fn GetMessageA(166pub extern "user32" fn GetMessageA(
167 lpMsg: ?*MSG,167 lpMsg: ?*MSG,
168 hWnd: ?HWND,168 hWnd: ?HWND,
169 wMsgFilterMin: UINT,169 wMsgFilterMin: UINT,
170 wMsgFilterMax: UINT,170 wMsgFilterMax: UINT,
171) callconv(.Stdcall) bool;171) callconv(WINAPI) bool;
172172
173pub extern "user32" fn TranslateMessage(lpMsg: *const MSG) callconv(.Stdcall) bool;173pub extern "user32" fn TranslateMessage(lpMsg: *const MSG) callconv(WINAPI) bool;
174pub extern "user32" fn DispatchMessageA(lpMsg: *const MSG) callconv(.Stdcall) LRESULT;174pub extern "user32" fn DispatchMessageA(lpMsg: *const MSG) callconv(WINAPI) LRESULT;
175pub extern "user32" fn PostQuitMessage(nExitCode: i32) callconv(.Stdcall) void;175pub extern "user32" fn PostQuitMessage(nExitCode: i32) callconv(WINAPI) void;
lib/std/os/windows/ws2_32.zig+21-21
...@@ -756,9 +756,9 @@ pub const TCP_NODELAY = 0x0001;...@@ -756,9 +756,9 @@ pub const TCP_NODELAY = 0x0001;
756pub extern "ws2_32" fn WSAStartup(756pub extern "ws2_32" fn WSAStartup(
757 wVersionRequired: WORD,757 wVersionRequired: WORD,
758 lpWSAData: *WSADATA,758 lpWSAData: *WSADATA,
759) callconv(.Stdcall) c_int;759) callconv(WINAPI) c_int;
760pub extern "ws2_32" fn WSACleanup() callconv(.Stdcall) c_int;760pub extern "ws2_32" fn WSACleanup() callconv(WINAPI) c_int;
761pub extern "ws2_32" fn WSAGetLastError() callconv(.Stdcall) WinsockError;761pub extern "ws2_32" fn WSAGetLastError() callconv(WINAPI) WinsockError;
762pub extern "ws2_32" fn WSASocketA(762pub extern "ws2_32" fn WSASocketA(
763 af: c_int,763 af: c_int,
764 type: c_int,764 type: c_int,
...@@ -766,7 +766,7 @@ pub extern "ws2_32" fn WSASocketA(...@@ -766,7 +766,7 @@ pub extern "ws2_32" fn WSASocketA(
766 lpProtocolInfo: ?*WSAPROTOCOL_INFOA,766 lpProtocolInfo: ?*WSAPROTOCOL_INFOA,
767 g: GROUP,767 g: GROUP,
768 dwFlags: DWORD,768 dwFlags: DWORD,
769) callconv(.Stdcall) SOCKET;769) callconv(WINAPI) SOCKET;
770pub extern "ws2_32" fn WSASocketW(770pub extern "ws2_32" fn WSASocketW(
771 af: c_int,771 af: c_int,
772 type: c_int,772 type: c_int,
...@@ -774,8 +774,8 @@ pub extern "ws2_32" fn WSASocketW(...@@ -774,8 +774,8 @@ pub extern "ws2_32" fn WSASocketW(
774 lpProtocolInfo: ?*WSAPROTOCOL_INFOW,774 lpProtocolInfo: ?*WSAPROTOCOL_INFOW,
775 g: GROUP,775 g: GROUP,
776 dwFlags: DWORD,776 dwFlags: DWORD,
777) callconv(.Stdcall) SOCKET;777) callconv(WINAPI) SOCKET;
778pub extern "ws2_32" fn closesocket(s: SOCKET) callconv(.Stdcall) c_int;778pub extern "ws2_32" fn closesocket(s: SOCKET) callconv(WINAPI) c_int;
779pub extern "ws2_32" fn WSAIoctl(779pub extern "ws2_32" fn WSAIoctl(
780 s: SOCKET,780 s: SOCKET,
781 dwIoControlCode: DWORD,781 dwIoControlCode: DWORD,
...@@ -786,26 +786,26 @@ pub extern "ws2_32" fn WSAIoctl(...@@ -786,26 +786,26 @@ pub extern "ws2_32" fn WSAIoctl(
786 lpcbBytesReturned: LPDWORD,786 lpcbBytesReturned: LPDWORD,
787 lpOverlapped: ?*WSAOVERLAPPED,787 lpOverlapped: ?*WSAOVERLAPPED,
788 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,788 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
789) callconv(.Stdcall) c_int;789) callconv(WINAPI) c_int;
790pub extern "ws2_32" fn accept(790pub extern "ws2_32" fn accept(
791 s: SOCKET,791 s: SOCKET,
792 addr: ?*sockaddr,792 addr: ?*sockaddr,
793 addrlen: ?*c_int,793 addrlen: ?*c_int,
794) callconv(.Stdcall) SOCKET;794) callconv(WINAPI) SOCKET;
795pub extern "ws2_32" fn bind(795pub extern "ws2_32" fn bind(
796 s: SOCKET,796 s: SOCKET,
797 addr: ?*const sockaddr,797 addr: ?*const sockaddr,
798 addrlen: c_int,798 addrlen: c_int,
799) callconv(.Stdcall) c_int;799) callconv(WINAPI) c_int;
800pub extern "ws2_32" fn connect(800pub extern "ws2_32" fn connect(
801 s: SOCKET,801 s: SOCKET,
802 name: *const sockaddr,802 name: *const sockaddr,
803 namelen: c_int,803 namelen: c_int,
804) callconv(.Stdcall) c_int;804) callconv(WINAPI) c_int;
805pub extern "ws2_32" fn listen(805pub extern "ws2_32" fn listen(
806 s: SOCKET,806 s: SOCKET,
807 backlog: c_int,807 backlog: c_int,
808) callconv(.Stdcall) c_int;808) callconv(WINAPI) c_int;
809pub extern "ws2_32" fn WSARecv(809pub extern "ws2_32" fn WSARecv(
810 s: SOCKET,810 s: SOCKET,
811 lpBuffers: [*]const WSABUF,811 lpBuffers: [*]const WSABUF,
...@@ -814,7 +814,7 @@ pub extern "ws2_32" fn WSARecv(...@@ -814,7 +814,7 @@ pub extern "ws2_32" fn WSARecv(
814 lpFlags: *DWORD,814 lpFlags: *DWORD,
815 lpOverlapped: ?*WSAOVERLAPPED,815 lpOverlapped: ?*WSAOVERLAPPED,
816 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,816 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
817) callconv(.Stdcall) c_int;817) callconv(WINAPI) c_int;
818pub extern "ws2_32" fn WSARecvFrom(818pub extern "ws2_32" fn WSARecvFrom(
819 s: SOCKET,819 s: SOCKET,
820 lpBuffers: [*]const WSABUF,820 lpBuffers: [*]const WSABUF,
...@@ -825,7 +825,7 @@ pub extern "ws2_32" fn WSARecvFrom(...@@ -825,7 +825,7 @@ pub extern "ws2_32" fn WSARecvFrom(
825 lpFromlen: ?*socklen_t,825 lpFromlen: ?*socklen_t,
826 lpOverlapped: ?*WSAOVERLAPPED,826 lpOverlapped: ?*WSAOVERLAPPED,
827 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,827 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
828) callconv(.Stdcall) c_int;828) callconv(WINAPI) c_int;
829pub extern "ws2_32" fn WSASend(829pub extern "ws2_32" fn WSASend(
830 s: SOCKET,830 s: SOCKET,
831 lpBuffers: [*]WSABUF,831 lpBuffers: [*]WSABUF,
...@@ -834,7 +834,7 @@ pub extern "ws2_32" fn WSASend(...@@ -834,7 +834,7 @@ pub extern "ws2_32" fn WSASend(
834 dwFlags: DWORD,834 dwFlags: DWORD,
835 lpOverlapped: ?*WSAOVERLAPPED,835 lpOverlapped: ?*WSAOVERLAPPED,
836 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,836 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
837) callconv(.Stdcall) c_int;837) callconv(WINAPI) c_int;
838pub extern "ws2_32" fn WSASendTo(838pub extern "ws2_32" fn WSASendTo(
839 s: SOCKET,839 s: SOCKET,
840 lpBuffers: [*]WSABUF,840 lpBuffers: [*]WSABUF,
...@@ -845,35 +845,35 @@ pub extern "ws2_32" fn WSASendTo(...@@ -845,35 +845,35 @@ pub extern "ws2_32" fn WSASendTo(
845 iTolen: c_int,845 iTolen: c_int,
846 lpOverlapped: ?*WSAOVERLAPPED,846 lpOverlapped: ?*WSAOVERLAPPED,
847 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,847 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
848) callconv(.Stdcall) c_int;848) callconv(WINAPI) c_int;
849pub extern "ws2_32" fn WSAPoll(849pub extern "ws2_32" fn WSAPoll(
850 fdArray: [*]pollfd,850 fdArray: [*]pollfd,
851 fds: c_ulong,851 fds: c_ulong,
852 timeout: c_int,852 timeout: c_int,
853) callconv(.Stdcall) c_int;853) callconv(WINAPI) c_int;
854pub extern "ws2_32" fn getaddrinfo(854pub extern "ws2_32" fn getaddrinfo(
855 pNodeName: [*:0]const u8,855 pNodeName: [*:0]const u8,
856 pServiceName: [*:0]const u8,856 pServiceName: [*:0]const u8,
857 pHints: *const addrinfo,857 pHints: *const addrinfo,
858 ppResult: **addrinfo,858 ppResult: **addrinfo,
859) callconv(.Stdcall) i32;859) callconv(WINAPI) i32;
860pub extern "ws2_32" fn freeaddrinfo(860pub extern "ws2_32" fn freeaddrinfo(
861 pAddrInfo: *addrinfo,861 pAddrInfo: *addrinfo,
862) callconv(.Stdcall) void;862) callconv(WINAPI) void;
863pub extern "ws2_32" fn ioctlsocket(863pub extern "ws2_32" fn ioctlsocket(
864 s: SOCKET,864 s: SOCKET,
865 cmd: c_long,865 cmd: c_long,
866 argp: *c_ulong,866 argp: *c_ulong,
867) callconv(.Stdcall) c_int;867) callconv(WINAPI) c_int;
868pub extern "ws2_32" fn getsockname(868pub extern "ws2_32" fn getsockname(
869 s: SOCKET,869 s: SOCKET,
870 name: *sockaddr,870 name: *sockaddr,
871 namelen: *c_int,871 namelen: *c_int,
872) callconv(.Stdcall) c_int;872) callconv(WINAPI) c_int;
873pub extern "ws2_32" fn setsockopt(873pub extern "ws2_32" fn setsockopt(
874 s: SOCKET,874 s: SOCKET,
875 level: u32,875 level: u32,
876 optname: u32,876 optname: u32,
877 optval: ?*const c_void,877 optval: ?*const c_void,
878 optlen: socklen_t,878 optlen: socklen_t,
879) callconv(.Stdcall) c_int;879) callconv(WINAPI) c_int;
lib/std/start.zig+3-3
...@@ -53,7 +53,7 @@ fn _DllMainCRTStartup(...@@ -53,7 +53,7 @@ fn _DllMainCRTStartup(
53 hinstDLL: std.os.windows.HINSTANCE,53 hinstDLL: std.os.windows.HINSTANCE,
54 fdwReason: std.os.windows.DWORD,54 fdwReason: std.os.windows.DWORD,
55 lpReserved: std.os.windows.LPVOID,55 lpReserved: std.os.windows.LPVOID,
56) callconv(.Stdcall) std.os.windows.BOOL {56) callconv(std.os.windows.WINAPI) std.os.windows.BOOL {
57 if (!builtin.single_threaded and !builtin.link_libc) {57 if (!builtin.single_threaded and !builtin.link_libc) {
58 _ = @import("start_windows_tls.zig");58 _ = @import("start_windows_tls.zig");
59 }59 }
...@@ -162,7 +162,7 @@ fn _start() callconv(.Naked) noreturn {...@@ -162,7 +162,7 @@ fn _start() callconv(.Naked) noreturn {
162 @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});162 @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
163}163}
164164
165fn WinStartup() callconv(.Stdcall) noreturn {165fn WinStartup() callconv(std.os.windows.WINAPI) noreturn {
166 @setAlignStack(16);166 @setAlignStack(16);
167 if (!builtin.single_threaded) {167 if (!builtin.single_threaded) {
168 _ = @import("start_windows_tls.zig");168 _ = @import("start_windows_tls.zig");
...@@ -173,7 +173,7 @@ fn WinStartup() callconv(.Stdcall) noreturn {...@@ -173,7 +173,7 @@ fn WinStartup() callconv(.Stdcall) noreturn {
173 std.os.windows.kernel32.ExitProcess(initEventLoopAndCallMain());173 std.os.windows.kernel32.ExitProcess(initEventLoopAndCallMain());
174}174}
175175
176fn wWinMainCRTStartup() callconv(.Stdcall) noreturn {176fn wWinMainCRTStartup() callconv(std.os.windows.WINAPI) noreturn {
177 @setAlignStack(16);177 @setAlignStack(16);
178 if (!builtin.single_threaded) {178 if (!builtin.single_threaded) {
179 _ = @import("start_windows_tls.zig");179 _ = @import("start_windows_tls.zig");
src/stage1/analyze.cpp+63-4
...@@ -971,9 +971,9 @@ const char *calling_convention_name(CallingConvention cc) {...@@ -971,9 +971,9 @@ const char *calling_convention_name(CallingConvention cc) {
971 case CallingConventionFastcall: return "Fastcall";971 case CallingConventionFastcall: return "Fastcall";
972 case CallingConventionVectorcall: return "Vectorcall";972 case CallingConventionVectorcall: return "Vectorcall";
973 case CallingConventionThiscall: return "Thiscall";973 case CallingConventionThiscall: return "Thiscall";
974 case CallingConventionAPCS: return "Apcs";974 case CallingConventionAPCS: return "APCS";
975 case CallingConventionAAPCS: return "Aapcs";975 case CallingConventionAAPCS: return "AAPCS";
976 case CallingConventionAAPCSVFP: return "Aapcsvfp";976 case CallingConventionAAPCSVFP: return "AAPCSVFP";
977 }977 }
978 zig_unreachable();978 zig_unreachable();
979}979}
...@@ -1880,6 +1880,58 @@ ZigType *get_auto_err_set_type(CodeGen *g, ZigFn *fn_entry) {...@@ -1880,6 +1880,58 @@ ZigType *get_auto_err_set_type(CodeGen *g, ZigFn *fn_entry) {
1880 return err_set_type;1880 return err_set_type;
1881}1881}
18821882
1883// Sync this with get_llvm_cc in codegen.cpp
1884static Error emit_error_unless_callconv_allowed_for_target(CodeGen *g, AstNode *source_node, CallingConvention cc) {
1885 Error ret = ErrorNone;
1886 const char *allowed_platforms = nullptr;
1887 switch (cc) {
1888 case CallingConventionUnspecified:
1889 case CallingConventionC:
1890 case CallingConventionNaked:
1891 case CallingConventionAsync:
1892 break;
1893 case CallingConventionInterrupt:
1894 if (g->zig_target->arch != ZigLLVM_x86
1895 && g->zig_target->arch != ZigLLVM_x86_64
1896 && g->zig_target->arch != ZigLLVM_avr
1897 && g->zig_target->arch != ZigLLVM_msp430)
1898 {
1899 allowed_platforms = "x86, x86_64, AVR, and MSP430";
1900 }
1901 break;
1902 case CallingConventionSignal:
1903 if (g->zig_target->arch != ZigLLVM_avr)
1904 allowed_platforms = "AVR";
1905 break;
1906 case CallingConventionStdcall:
1907 case CallingConventionFastcall:
1908 case CallingConventionThiscall:
1909 if (g->zig_target->arch != ZigLLVM_x86)
1910 allowed_platforms = "x86";
1911 break;
1912 case CallingConventionVectorcall:
1913 if (g->zig_target->arch != ZigLLVM_x86
1914 && !(target_is_arm(g->zig_target) && target_arch_pointer_bit_width(g->zig_target->arch) == 64))
1915 {
1916 allowed_platforms = "x86 and AArch64";
1917 }
1918 break;
1919 case CallingConventionAPCS:
1920 case CallingConventionAAPCS:
1921 case CallingConventionAAPCSVFP:
1922 if (!target_is_arm(g->zig_target))
1923 allowed_platforms = "ARM";
1924 }
1925 if (allowed_platforms != nullptr) {
1926 add_node_error(g, source_node, buf_sprintf(
1927 "callconv '%s' is only available on %s, not %s",
1928 calling_convention_name(cc), allowed_platforms,
1929 target_arch_name(g->zig_target->arch)));
1930 ret = ErrorSemanticAnalyzeFail;
1931 }
1932 return ret;
1933}
1934
1883static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_scope, ZigFn *fn_entry,1935static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_scope, ZigFn *fn_entry,
1884 CallingConvention cc)1936 CallingConvention cc)
1885{1937{
...@@ -2014,6 +2066,9 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc...@@ -2014,6 +2066,9 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
2014 fn_entry->align_bytes = fn_type_id.alignment;2066 fn_entry->align_bytes = fn_type_id.alignment;
2015 }2067 }
20162068
2069 if ((err = emit_error_unless_callconv_allowed_for_target(g, proto_node->data.fn_proto.callconv_expr, cc)))
2070 return g->builtin_types.entry_invalid;
2071
2017 if (fn_proto->return_anytype_token != nullptr) {2072 if (fn_proto->return_anytype_token != nullptr) {
2018 if (!calling_convention_allows_zig_types(fn_type_id.cc)) {2073 if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
2019 add_node_error(g, fn_proto->return_type,2074 add_node_error(g, fn_proto->return_type,
...@@ -3577,9 +3632,13 @@ void add_var_export(CodeGen *g, ZigVar *var, const char *symbol_name, GlobalLink...@@ -3577,9 +3632,13 @@ void add_var_export(CodeGen *g, ZigVar *var, const char *symbol_name, GlobalLink
3577}3632}
35783633
3579void add_fn_export(CodeGen *g, ZigFn *fn_table_entry, const char *symbol_name, GlobalLinkageId linkage, CallingConvention cc) {3634void add_fn_export(CodeGen *g, ZigFn *fn_table_entry, const char *symbol_name, GlobalLinkageId linkage, CallingConvention cc) {
3635 CallingConvention winapi_cc = g->zig_target->arch == ZigLLVM_x86
3636 ? CallingConventionStdcall
3637 : CallingConventionC;
3638
3580 if (cc == CallingConventionC && strcmp(symbol_name, "main") == 0 && g->link_libc) {3639 if (cc == CallingConventionC && strcmp(symbol_name, "main") == 0 && g->link_libc) {
3581 g->stage1.have_c_main = true;3640 g->stage1.have_c_main = true;
3582 } else if (cc == CallingConventionStdcall && g->zig_target->os == OsWindows) {3641 } else if (cc == winapi_cc && g->zig_target->os == OsWindows) {
3583 if (strcmp(symbol_name, "WinMain") == 0) {3642 if (strcmp(symbol_name, "WinMain") == 0) {
3584 g->stage1.have_winmain = true;3643 g->stage1.have_winmain = true;
3585 } else if (strcmp(symbol_name, "wWinMain") == 0) {3644 } else if (strcmp(symbol_name, "wWinMain") == 0) {
src/stage1/codegen.cpp+17-23
...@@ -155,6 +155,7 @@ static const char *get_mangled_name(CodeGen *g, const char *original_name) {...@@ -155,6 +155,7 @@ static const char *get_mangled_name(CodeGen *g, const char *original_name) {
155 }155 }
156}156}
157157
158// Sync this with emit_error_unless_callconv_allowed_for_target in analyze.cpp
158static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {159static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
159 switch (cc) {160 switch (cc) {
160 case CallingConventionUnspecified:161 case CallingConventionUnspecified:
...@@ -164,38 +165,32 @@ static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {...@@ -164,38 +165,32 @@ static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
164 case CallingConventionNaked:165 case CallingConventionNaked:
165 zig_unreachable();166 zig_unreachable();
166 case CallingConventionStdcall:167 case CallingConventionStdcall:
167 if (g->zig_target->arch == ZigLLVM_x86)168 assert(g->zig_target->arch == ZigLLVM_x86);
168 return ZigLLVM_X86_StdCall;169 return ZigLLVM_X86_StdCall;
169 return ZigLLVM_C;
170 case CallingConventionFastcall:170 case CallingConventionFastcall:
171 if (g->zig_target->arch == ZigLLVM_x86)171 assert(g->zig_target->arch == ZigLLVM_x86);
172 return ZigLLVM_X86_FastCall;172 return ZigLLVM_X86_FastCall;
173 return ZigLLVM_C;
174 case CallingConventionVectorcall:173 case CallingConventionVectorcall:
175 if (g->zig_target->arch == ZigLLVM_x86)174 if (g->zig_target->arch == ZigLLVM_x86)
176 return ZigLLVM_X86_VectorCall;175 return ZigLLVM_X86_VectorCall;
177 if (target_is_arm(g->zig_target) &&176 if (target_is_arm(g->zig_target) &&
178 target_arch_pointer_bit_width(g->zig_target->arch) == 64)177 target_arch_pointer_bit_width(g->zig_target->arch) == 64)
179 return ZigLLVM_AArch64_VectorCall;178 return ZigLLVM_AArch64_VectorCall;
180 return ZigLLVM_C;179 zig_unreachable();
181 case CallingConventionThiscall:180 case CallingConventionThiscall:
182 if (g->zig_target->arch == ZigLLVM_x86)181 assert(g->zig_target->arch == ZigLLVM_x86);
183 return ZigLLVM_X86_ThisCall;182 return ZigLLVM_X86_ThisCall;
184 return ZigLLVM_C;
185 case CallingConventionAsync:183 case CallingConventionAsync:
186 return ZigLLVM_Fast;184 return ZigLLVM_Fast;
187 case CallingConventionAPCS:185 case CallingConventionAPCS:
188 if (target_is_arm(g->zig_target))186 assert(target_is_arm(g->zig_target));
189 return ZigLLVM_ARM_APCS;187 return ZigLLVM_ARM_APCS;
190 return ZigLLVM_C;
191 case CallingConventionAAPCS:188 case CallingConventionAAPCS:
192 if (target_is_arm(g->zig_target))189 assert(target_is_arm(g->zig_target));
193 return ZigLLVM_ARM_AAPCS;190 return ZigLLVM_ARM_AAPCS;
194 return ZigLLVM_C;
195 case CallingConventionAAPCSVFP:191 case CallingConventionAAPCSVFP:
196 if (target_is_arm(g->zig_target))192 assert(target_is_arm(g->zig_target));
197 return ZigLLVM_ARM_AAPCS_VFP;193 return ZigLLVM_ARM_AAPCS_VFP;
198 return ZigLLVM_C;
199 case CallingConventionInterrupt:194 case CallingConventionInterrupt:
200 if (g->zig_target->arch == ZigLLVM_x86 ||195 if (g->zig_target->arch == ZigLLVM_x86 ||
201 g->zig_target->arch == ZigLLVM_x86_64)196 g->zig_target->arch == ZigLLVM_x86_64)
...@@ -204,11 +199,10 @@ static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {...@@ -204,11 +199,10 @@ static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
204 return ZigLLVM_AVR_INTR;199 return ZigLLVM_AVR_INTR;
205 if (g->zig_target->arch == ZigLLVM_msp430)200 if (g->zig_target->arch == ZigLLVM_msp430)
206 return ZigLLVM_MSP430_INTR;201 return ZigLLVM_MSP430_INTR;
207 return ZigLLVM_C;202 zig_unreachable();
208 case CallingConventionSignal:203 case CallingConventionSignal:
209 if (g->zig_target->arch == ZigLLVM_avr)204 assert(g->zig_target->arch == ZigLLVM_avr);
210 return ZigLLVM_AVR_SIGNAL;205 return ZigLLVM_AVR_SIGNAL;
211 return ZigLLVM_C;
212 }206 }
213 zig_unreachable();207 zig_unreachable();
214}208}
test/compile_errors.zig+78
...@@ -57,6 +57,84 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {...@@ -57,6 +57,84 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
57 "tmp.zig:1:22: note: type u2 cannot fit values in range 0...4",57 "tmp.zig:1:22: note: type u2 cannot fit values in range 0...4",
58 });58 });
5959
60 cases.addCase(x: {
61 var tc = cases.create("callconv(.Interrupt) on unsupported platform",
62 \\export fn entry() callconv(.Interrupt) void {}
63 , &[_][]const u8{
64 "tmp.zig:1:28: error: callconv 'Interrupt' is only available on x86, x86_64, AVR, and MSP430, not aarch64",
65 });
66 tc.target = std.zig.CrossTarget{
67 .cpu_arch = .aarch64,
68 .os_tag = .linux,
69 .abi = .none,
70 };
71 break :x tc;
72 });
73
74 cases.addCase(x: {
75 var tc = cases.create("callconv(.Signal) on unsupported platform",
76 \\export fn entry() callconv(.Signal) void {}
77 , &[_][]const u8{
78 "tmp.zig:1:28: error: callconv 'Signal' is only available on AVR, not x86_64",
79 });
80 tc.target = std.zig.CrossTarget{
81 .cpu_arch = .x86_64,
82 .os_tag = .linux,
83 .abi = .none,
84 };
85 break :x tc;
86 });
87
88 cases.addCase(x: {
89 var tc = cases.create("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform",
90 \\export fn entry1() callconv(.Stdcall) void {}
91 \\export fn entry2() callconv(.Fastcall) void {}
92 \\export fn entry3() callconv(.Thiscall) void {}
93 , &[_][]const u8{
94 "tmp.zig:1:29: error: callconv 'Stdcall' is only available on x86, not x86_64",
95 "tmp.zig:2:29: error: callconv 'Fastcall' is only available on x86, not x86_64",
96 "tmp.zig:3:29: error: callconv 'Thiscall' is only available on x86, not x86_64",
97 });
98 tc.target = std.zig.CrossTarget{
99 .cpu_arch = .x86_64,
100 .os_tag = .linux,
101 .abi = .none,
102 };
103 break :x tc;
104 });
105
106 cases.addCase(x: {
107 var tc = cases.create("callconv(.Vectorcall) on unsupported platform",
108 \\export fn entry() callconv(.Vectorcall) void {}
109 , &[_][]const u8{
110 "tmp.zig:1:28: error: callconv 'Vectorcall' is only available on x86 and AArch64, not x86_64",
111 });
112 tc.target = std.zig.CrossTarget{
113 .cpu_arch = .x86_64,
114 .os_tag = .linux,
115 .abi = .none,
116 };
117 break :x tc;
118 });
119
120 cases.addCase(x: {
121 var tc = cases.create("callconv(.APCS, .AAPCS, .AAPCSVFP) on unsupported platform",
122 \\export fn entry1() callconv(.APCS) void {}
123 \\export fn entry2() callconv(.AAPCS) void {}
124 \\export fn entry3() callconv(.AAPCSVFP) void {}
125 , &[_][]const u8{
126 "tmp.zig:1:29: error: callconv 'APCS' is only available on ARM, not x86_64",
127 "tmp.zig:2:29: error: callconv 'AAPCS' is only available on ARM, not x86_64",
128 "tmp.zig:3:29: error: callconv 'AAPCSVFP' is only available on ARM, not x86_64",
129 });
130 tc.target = std.zig.CrossTarget{
131 .cpu_arch = .x86_64,
132 .os_tag = .linux,
133 .abi = .none,
134 };
135 break :x tc;
136 });
137
60 cases.add("unreachable executed at comptime",138 cases.add("unreachable executed at comptime",
61 \\fn foo(comptime x: i32) i32 {139 \\fn foo(comptime x: i32) i32 {
62 \\ comptime {140 \\ comptime {
test/stage1/behavior/fn.zig+2-2
...@@ -189,9 +189,9 @@ test "return inner function which references comptime variable of outer function...@@ -189,9 +189,9 @@ test "return inner function which references comptime variable of outer function
189189
190test "extern struct with stdcallcc fn pointer" {190test "extern struct with stdcallcc fn pointer" {
191 const S = extern struct {191 const S = extern struct {
192 ptr: fn () callconv(.Stdcall) i32,192 ptr: fn () callconv(if (std.builtin.arch == .i386) .Stdcall else .C) i32,
193193
194 fn foo() callconv(.Stdcall) i32 {194 fn foo() callconv(if (std.builtin.arch == .i386) .Stdcall else .C) i32 {
195 return 1234;195 return 1234;
196 }196 }
197 };197 };