#endif // !defined(__i386__)
-#define CALLBACK __stdcall
+#define CALLBACK __cdecl
#if !defined(_declspec)
#define _declspec(e) __declspec(e)
#endif
-#define PALAPI __stdcall
+#define PALAPI __cdecl
#define PALAPIV __cdecl
////////////////////////////////////////////////////////////////////////
#endif // DEBUG
-#define NTAPI __stdcall
-#define WINAPI __stdcall
-#define CALLBACK __stdcall
+#define NTAPI __cdecl
+#define WINAPI __cdecl
+#define CALLBACK __cdecl
#define NTSYSAPI
#define _WINNT_
struct _LIST_ENTRY *Blink;
} LIST_ENTRY, *PLIST_ENTRY;
-typedef VOID (__stdcall *WAITORTIMERCALLBACK)(PVOID, BOOLEAN);
+typedef VOID (NTAPI *WAITORTIMERCALLBACK)(PVOID, BOOLEAN);
// PORTABILITY_ASSERT and PORTABILITY_WARNING macros are meant to be used to
// mark places in the code that needs attention for portability. The usual
CRST_DEBUG_ONLY_CHECK_FORBID_SUSPEND_THREAD = 0x200
} CrstFlags;
-typedef VOID ( __stdcall *PTLS_CALLBACK_FUNCTION )(
+typedef VOID ( WINAPI *PTLS_CALLBACK_FUNCTION )(
PVOID __MIDL____MIDL_itf_clrinternal_0000_00000000);
// Restore
pop ebx
pop eax
- ret 4
+ ret
LEAF_END CONTEXT_CaptureContext, _TEXT
LEAF_ENTRY RtlCaptureContext, _TEXT
{
#endif // __cplusplus
-typedef BOOL (__stdcall *PDLLMAIN)(HINSTANCE, DWORD, LPVOID); /* entry point of module */
+typedef BOOL (PALAPI *PDLLMAIN)(HINSTANCE, DWORD, LPVOID); /* entry point of module */
typedef HINSTANCE (PALAPI *PREGISTER_MODULE)(LPCSTR); /* used to create the HINSTANCE for above DLLMain entry point */
typedef VOID (PALAPI *PUNREGISTER_MODULE)(HINSTANCE); /* used to cleanup the HINSTANCE for above DLLMain entry point */
__declspec(dllexport)
#endif
-int __stdcall DllTest()
+int PALAPI DllTest()
{
return 1;
}
#ifdef WIN32
-int __stdcall _DllMainCRTStartup(void *hinstDLL, int reason, void * lpvReserved)
+int PALAPI _DllMainCRTStartup(void *hinstDLL, int reason, void * lpvReserved)
{
return 1;
}
__declspec(dllexport)
#endif
-int _stdcall DllTest()
+int PALAPI DllTest()
{
return 1;
}
#if WIN32
-int __stdcall _DllMainCRTStartup(void *hinstDLL, int reason, void * lpvReserved)
+int PALAPI _DllMainCRTStartup(void *hinstDLL, int reason, void * lpvReserved)
{
return 1;
}
**===========================================================================*/
#include <palsuite.h>
-typedef int (__stdcall *SIMPLEFUNCTION)(int);
+typedef int (PALAPI *SIMPLEFUNCTION)(int);
/* SHLEXT is defined only for Unix variants */
#if defined(SHLEXT)
/**
* Simple function that returns i+1
*/
-int __stdcall SimpleFunction(int i)
+int PALAPI SimpleFunction(int i)
{
return i+1;
}
#if WIN32
-int __stdcall _DllMainCRTStartup(void *hinstDLL, int reason, void *lpvReserved)
+int PALAPI _DllMainCRTStartup(void *hinstDLL, int reason, void *lpvReserved)
{
return 1;
}
/**
* Simple function that returns i+1
*/
-int __stdcall SimpleFunction(int i)
+int PALAPI SimpleFunction(int i)
{
return i+1;
}
#if WIN32
-int __stdcall _DllMainCRTStartup(void *hinstDLL, int reason, void *lpvReserved)
+int PALAPI _DllMainCRTStartup(void *hinstDLL, int reason, void *lpvReserved)
{
return 1;
}
static int g_attachCount = 0;
/* standard DllMain() */
-BOOL __stdcall DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID lpvReserved)
+BOOL PALAPI DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID lpvReserved)
{
switch( reason )
{
}
#if _WIN32
-BOOL __stdcall _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD reason, LPVOID lpvReserved)
+BOOL PALAPI _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD reason, LPVOID lpvReserved)
{
return DllMain(hinstDLL, reason, lpvReserved);
}
static int g_attachCount = 0;
/* standard DllMain() */
-BOOL __stdcall DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID lpvReserved)
+BOOL PALAPI DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID lpvReserved)
{
switch( reason )
{
}
#if _WIN32
-BOOL __stdcall _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD reason, LPVOID lpvReserved)
+BOOL PALAPI _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD reason, LPVOID lpvReserved)
{
return DllMain(hinstDLL, reason, lpvReserved);
}
return (DWORD) PAL_startup_main(args->argc, args->argv);
}
+static void terminate(void)
+{
+ PAL_Terminate();
+}
+
int __cdecl main(int argc, char **argv) {
struct _mainargs mainargs;
return FAIL;;
}
- // PAL_Terminate is a stdcall function, but it takes no parameters
- // so the difference doesn't matter.
- atexit((void (__cdecl *)(void)) PAL_Terminate);
+ atexit(terminate);
mainargs.argc = argc;
mainargs.argv = argv;
#define GETCALLCOUNT "_GetCallCount@0"
#endif
-DWORD __stdcall ThreadFunc(LPVOID lpParam);
+DWORD PALAPI ThreadFunc(LPVOID lpParam);
int RunTest(int DisableThreadCalls);
int __cdecl main(int argc, char **argv)
/*
* Thread entry point. Doesn't do anything.
*/
-DWORD __stdcall ThreadFunc(LPVOID lpParam)
+DWORD PALAPI ThreadFunc(LPVOID lpParam)
{
return 0;
}
static int Count;
-BOOL __stdcall DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL PALAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
if (fdwReason == DLL_PROCESS_ATTACH)
}
#ifdef WIN32
-BOOL __stdcall _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL PALAPI _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
return DllMain(hinstDLL, fdwReason, lpvReserved);
}
#ifdef WIN32
__declspec(dllexport)
#endif
-int __stdcall GetCallCount()
+int PALAPI GetCallCount()
{
return Count;
}
#ifdef WIN32
-BOOL __stdcall _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL PALAPI _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
return DllMain(hinstDLL, fdwReason, lpvReserved);
}
#ifdef WIN32
-BOOL __stdcall _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL PALAPI _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
return DllMain(hinstDLL, fdwReason, lpvReserved);
}
}
#ifdef WIN32
-BOOL __stdcall _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL PALAPI _DllMainCRTStartup(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
return DllMain(hinstDLL, fdwReason, lpvReserved);
}
}
// When an exposed thread is started by Win32, this is where it starts.
-ULONG __stdcall ThreadNative::KickOffThread(void* pass)
+ULONG WINAPI ThreadNative::KickOffThread(void* pass)
{
CONTRACTL
};
static void KickOffThread_Worker(LPVOID /* KickOffThread_Args* */);
- static ULONG __stdcall KickOffThread(void *pass);
+ static ULONG WINAPI KickOffThread(void *pass);
static BOOL DoJoin(THREADBASEREF DyingThread, INT32 timeout);
};
}
}
-
-
+inline CorPinvokeMap GetDefaultCallConv(BOOL bIsVarArg)
+{
+#ifdef PLATFORM_UNIX
+ return pmCallConvCdecl;
+#else // PLATFORM_UNIX
+ return bIsVarArg ? pmCallConvCdecl : pmCallConvStdcall;
+#endif // !PLATFORM_UNIX
+}
void PInvokeStaticSigInfo::InitCallConv(CorPinvokeMap callConv, BOOL bIsVarArg)
{
// Convert WinAPI methods to either StdCall or CDecl based on if they are varargs or not.
if (callConv == pmCallConvWinapi)
- callConv = bIsVarArg ? pmCallConvCdecl : pmCallConvStdcall;
+ callConv = GetDefaultCallConv(bIsVarArg);
CorPinvokeMap sigCallConv = (CorPinvokeMap)0;
BOOL fSuccess = MetaSig::GetUnmanagedCallingConvention(m_pModule, m_sig.GetRawSig(), m_sig.GetRawSigLen(), &sigCallConv);
// to do this before we check to make sure the PInvoke map calling convention and the
// signature calling convention match for compatibility reasons.
if (sigCallConv == pmCallConvWinapi)
- sigCallConv = bIsVarArg ? pmCallConvCdecl : pmCallConvStdcall;
+ sigCallConv = GetDefaultCallConv(bIsVarArg);
if (callConv != 0 && sigCallConv != 0 && callConv != sigCallConv)
SetError(IDS_EE_NDIRECT_BADNATL_CALLCONV);
if (callConv == 0 && sigCallConv == 0)
- m_callConv = bIsVarArg ? pmCallConvCdecl : pmCallConvStdcall;
+ m_callConv = GetDefaultCallConv(bIsVarArg);
else if (callConv != 0)
m_callConv = callConv;
else
}
-DWORD __stdcall FinalizerThread::FinalizerThreadStart(void *args)
+DWORD WINAPI FinalizerThread::FinalizerThreadStart(void *args)
{
ClrFlsSetThreadType (ThreadType_Finalizer);
static VOID FinalizerThreadWorker(void *args);
static void FinalizeObjectsOnShutdown(LPVOID args);
- static DWORD __stdcall FinalizerThreadStart(void *args);
+ static DWORD WINAPI FinalizerThreadStart(void *args);
static void FinalizerThreadCreate();
static BOOL FinalizerThreadWatchDog();
};
// GC thread stub to convert GC thread function to an OS specific thread function
-static DWORD __stdcall GCThreadStub(void* param)
+static DWORD WINAPI GCThreadStub(void* param)
{
WRAPPER_NO_CONTRACT;
// }
+#ifdef PLATFORM_UNIX
+#define QCALLTYPE __cdecl
+#else // PLATFORM_UNIX
#define QCALLTYPE __stdcall
+#endif // !PLATFORM_UNIX
#define BEGIN_QCALL \
INSTALL_MANAGED_EXCEPTION_DISPATCHER \
//---------------------------------------------------------------------------
// Creates new Thread for reverse p-invoke calls.
//---------------------------------------------------------------------------
-Thread* __stdcall CreateThreadBlockThrow()
+Thread* WINAPI CreateThreadBlockThrow()
{
WRAPPER_NO_CONTRACT;
// This is to avoid the 64KB/1MB aliasing problem present on Pentium 4 processors,
// which can significantly impact performance with HyperThreading enabled
-DWORD __stdcall Thread::intermediateThreadProc(PVOID arg)
+DWORD WINAPI Thread::intermediateThreadProc(PVOID arg)
{
WRAPPER_NO_CONTRACT;
// This is the callback from the OS, when we queue an APC to interrupt a waiting thread.
// The callback occurs on the thread we wish to interrupt. It is a STATIC method.
-void __stdcall Thread::UserInterruptAPC(ULONG_PTR data)
+void WINAPI Thread::UserInterruptAPC(ULONG_PTR data)
{
CONTRACTL {
NOTHROW;
DWORD GetRuntimeId();
-EXTERN_C Thread* __stdcall CreateThreadBlockThrow();
+EXTERN_C Thread* WINAPI CreateThreadBlockThrow();
//---------------------------------------------------------------------------
// One-time initialization. Called during Dll initialization.
#ifdef FEATURE_HIJACK
-EXTERN_C void __stdcall OnHijackTripThread();
+EXTERN_C void WINAPI OnHijackTripThread();
#ifdef _TARGET_X86_
-EXTERN_C void __stdcall OnHijackFPTripThread(); // hijacked JIT code is returning an FP value
+EXTERN_C void WINAPI OnHijackFPTripThread(); // hijacked JIT code is returning an FP value
#endif // _TARGET_X86_
#endif // FEATURE_HIJACK
void HandleThreadInterrupt(BOOL fWaitForADUnload);
public:
- static void __stdcall UserInterruptAPC(ULONG_PTR ignore);
+ static void WINAPI UserInterruptAPC(ULONG_PTR ignore);
#if defined(_DEBUG) && defined(TRACK_SYNC)
private:
// used to pad stack on thread creation to avoid aliasing penalty in P4 HyperThread scenarios
- static DWORD __stdcall intermediateThreadProc(PVOID arg);
+ static DWORD WINAPI intermediateThreadProc(PVOID arg);
static int m_offset_counter;
static const int offset_multiplier = 128;
// This is to avoid the 64KB/1MB aliasing problem present on Pentium 4 processors,
// which can significantly impact performance with HyperThreading enabled
-DWORD __stdcall ThreadpoolMgr::intermediateThreadProc(PVOID arg)
+DWORD WINAPI ThreadpoolMgr::intermediateThreadProc(PVOID arg)
{
WRAPPER_NO_CONTRACT;
STATIC_CONTRACT_SO_INTOLERANT;
}
-DWORD __stdcall ThreadpoolMgr::WorkerThreadStart(LPVOID lpArgs)
+DWORD WINAPI ThreadpoolMgr::WorkerThreadStart(LPVOID lpArgs)
{
ClrFlsSetThreadType (ThreadType_Threadpool_Worker);
#pragma warning(disable:22008) // "Prefast integer overflow check on (0 + lval) is bogus. Tried local disable without luck, doing whole method."
#endif
-DWORD __stdcall ThreadpoolMgr::WaitThreadStart(LPVOID lpArgs)
+DWORD WINAPI ThreadpoolMgr::WaitThreadStart(LPVOID lpArgs)
{
CONTRACTL
{
}
-DWORD __stdcall ThreadpoolMgr::AsyncCallbackCompletion(PVOID pArgs)
+DWORD WINAPI ThreadpoolMgr::AsyncCallbackCompletion(PVOID pArgs)
{
CONTRACTL
{
return FALSE;
}
-DWORD __stdcall ThreadpoolMgr::CompletionPortThreadStart(LPVOID lpArgs)
+DWORD WINAPI ThreadpoolMgr::CompletionPortThreadStart(LPVOID lpArgs)
{
ClrFlsSetThreadType (ThreadType_Threadpool_IOCompletion);
};
-DWORD __stdcall ThreadpoolMgr::GateThreadStart(LPVOID lpArgs)
+DWORD WINAPI ThreadpoolMgr::GateThreadStart(LPVOID lpArgs)
{
ClrFlsSetThreadType (ThreadType_Gate);
#pragma warning (disable : 4715)
#endif
#endif
-DWORD __stdcall ThreadpoolMgr::TimerThreadStart(LPVOID p)
+DWORD WINAPI ThreadpoolMgr::TimerThreadStart(LPVOID p)
{
ClrFlsSetThreadType (ThreadType_Timer);
return nextFiringInterval;
}
-DWORD __stdcall ThreadpoolMgr::AsyncTimerCallbackCompletion(PVOID pArgs)
+DWORD WINAPI ThreadpoolMgr::AsyncTimerCallbackCompletion(PVOID pArgs)
{
CONTRACTL
{
timerInfo->state = timerInfo->state & ~TIMER_ACTIVE;
}
-DWORD __stdcall ThreadpoolMgr::AsyncDeleteTimer(PVOID pArgs)
+DWORD WINAPI ThreadpoolMgr::AsyncDeleteTimer(PVOID pArgs)
{
CONTRACTL
{
// Private methods
- static DWORD __stdcall intermediateThreadProc(PVOID arg);
+ static DWORD WINAPI intermediateThreadProc(PVOID arg);
typedef struct {
LPTHREAD_START_ROUTINE lpThreadFunction;
static DWORD SafeWait(CLREvent * ev, DWORD sleepTime, BOOL alertable);
- static DWORD __stdcall WorkerThreadStart(LPVOID lpArgs);
+ static DWORD WINAPI WorkerThreadStart(LPVOID lpArgs);
static BOOL AddWaitRequest(HANDLE waitHandle, WaitInfo* waitInfo);
static BOOL CreateWaitThread();
- static void __stdcall InsertNewWaitForSelf(WaitInfo* pArg);
+ static void WINAPI InsertNewWaitForSelf(WaitInfo* pArg);
static int FindWaitIndex(const ThreadCB* threadCB, const HANDLE waitHandle);
unsigned index, // array index
BOOL waitTimedOut);
- static DWORD __stdcall WaitThreadStart(LPVOID lpArgs);
+ static DWORD WINAPI WaitThreadStart(LPVOID lpArgs);
- static DWORD __stdcall AsyncCallbackCompletion(PVOID pArgs);
+ static DWORD WINAPI AsyncCallbackCompletion(PVOID pArgs);
static void QueueTimerInfoForRelease(TimerInfo *pTimerInfo);
count * sizeof(LIST_ENTRY));
}
- static void __stdcall DeregisterWait(WaitInfo* pArgs);
+ static void WINAPI DeregisterWait(WaitInfo* pArgs);
#ifndef FEATURE_PAL
// holds the aggregate of system cpu usage of all processors
static int GetCPUBusyTime_NT(PROCESS_CPU_INFORMATION* pOldInfo);
static BOOL CreateCompletionPortThread(LPVOID lpArgs);
- static DWORD __stdcall CompletionPortThreadStart(LPVOID lpArgs);
+ static DWORD WINAPI CompletionPortThreadStart(LPVOID lpArgs);
public:
inline static bool HaveNativeWork()
{
static BOOL CreateGateThread();
static void EnsureGateThreadRunning();
static bool ShouldGateThreadKeepRunning();
- static DWORD __stdcall GateThreadStart(LPVOID lpArgs);
+ static DWORD WINAPI GateThreadStart(LPVOID lpArgs);
static BOOL SufficientDelaySinceLastSample(unsigned int LastThreadCreationTime,
unsigned NumThreads, // total number of threads of that type (worker or CP)
double throttleRate=0.0 // the delay is increased by this percentage for each extra thread
static LPVOID GetRecycledMemory(enum MemType memType);
- static DWORD __stdcall TimerThreadStart(LPVOID args);
+ static DWORD WINAPI TimerThreadStart(LPVOID args);
static void TimerThreadFire(); // helper method used by TimerThreadStart
- static void __stdcall InsertNewTimer(TimerInfo* pArg);
+ static void WINAPI InsertNewTimer(TimerInfo* pArg);
static DWORD FireTimers();
- static DWORD __stdcall AsyncTimerCallbackCompletion(PVOID pArgs);
+ static DWORD WINAPI AsyncTimerCallbackCompletion(PVOID pArgs);
static void DeactivateTimer(TimerInfo* timerInfo);
- static DWORD __stdcall AsyncDeleteTimer(PVOID pArgs);
+ static DWORD WINAPI AsyncDeleteTimer(PVOID pArgs);
static void DeleteTimer(TimerInfo* timerInfo);
- static void __stdcall UpdateTimer(TimerUpdateInfo* pArgs);
+ static void WINAPI UpdateTimer(TimerUpdateInfo* pArgs);
- static void __stdcall DeregisterTimer(TimerInfo* pArgs);
+ static void WINAPI DeregisterTimer(TimerInfo* pArgs);
inline static DWORD QueueDeregisterWait(HANDLE waitThread, WaitInfo* waitInfo)
{
projects / platform / upstream / dotnet / runtime.git / commitdiff