mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-02-01 05:01:59 +01:00
5202bf068f
This is the second part of recommit of r325224. The previous part was committed in r325426, which deals with C++ memory allocation. Solution for C memory allocation involved functions `llvm::malloc` and similar. This was a fragile solution because it caused ambiguity errors in some cases. In this commit the new functions have names like `llvm::safe_malloc`. The relevant part of original comment is below, updated for new function names. Analysis of fails in the case of out of memory errors can be tricky on Windows. Such error emerges at the point where memory allocation function fails, but manifests itself when null pointer is used. These two points may be distant from each other. Besides, next runs may not exhibit allocation error. In some cases memory is allocated by a call to some of C allocation functions, malloc, calloc and realloc. They are used for interoperability with C code, when allocated object has variable size and when it is necessary to avoid call of constructors. In many calls the result is not checked for null pointer. To simplify checks, new functions are defined in the namespace 'llvm': `safe_malloc`, `safe_calloc` and `safe_realloc`. They behave as corresponding standard functions but produce fatal error if allocation fails. This change replaces the standard functions like 'malloc' in the cases when the result of the allocation function is not checked for null pointer. Finally, there are plain C code, that uses malloc and similar functions. If the result is not checked, assert statement is added. Differential Revision: https://reviews.llvm.org/D43010 llvm-svn: 325551
130 lines
4.1 KiB
C++
130 lines
4.1 KiB
C++
//= llvm/Support/Win32/Mutex.inc - Win32 Reader/Writer Mutual Exclusion Lock =//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the Win32 specific (non-pthread) RWMutex class.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//=== WARNING: Implementation here must contain only generic Win32 code that
|
|
//=== is guaranteed to work on *all* Win32 variants.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "WindowsSupport.h"
|
|
|
|
namespace llvm {
|
|
|
|
// Windows has slim read-writer lock support on Vista and higher, so we
|
|
// will attempt to load the APIs. If they exist, we will use them, and
|
|
// if not, we will fall back on critical sections. When we drop support
|
|
// for XP, we can stop lazy-loading these APIs and just use them directly.
|
|
#if defined(__MINGW32__)
|
|
// Taken from WinNT.h
|
|
typedef struct _RTL_SRWLOCK {
|
|
PVOID Ptr;
|
|
} RTL_SRWLOCK, *PRTL_SRWLOCK;
|
|
|
|
// Taken from WinBase.h
|
|
typedef RTL_SRWLOCK SRWLOCK, *PSRWLOCK;
|
|
#endif
|
|
|
|
static VOID (WINAPI *fpInitializeSRWLock)(PSRWLOCK lock) = NULL;
|
|
static VOID (WINAPI *fpAcquireSRWLockExclusive)(PSRWLOCK lock) = NULL;
|
|
static VOID (WINAPI *fpAcquireSRWLockShared)(PSRWLOCK lock) = NULL;
|
|
static VOID (WINAPI *fpReleaseSRWLockExclusive)(PSRWLOCK lock) = NULL;
|
|
static VOID (WINAPI *fpReleaseSRWLockShared)(PSRWLOCK lock) = NULL;
|
|
|
|
static bool sHasSRW = false;
|
|
|
|
static bool loadSRW() {
|
|
static bool sChecked = false;
|
|
if (!sChecked) {
|
|
sChecked = true;
|
|
|
|
if (HMODULE hLib = ::GetModuleHandleW(L"Kernel32.dll")) {
|
|
fpInitializeSRWLock =
|
|
(VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
|
|
"InitializeSRWLock");
|
|
fpAcquireSRWLockExclusive =
|
|
(VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
|
|
"AcquireSRWLockExclusive");
|
|
fpAcquireSRWLockShared =
|
|
(VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
|
|
"AcquireSRWLockShared");
|
|
fpReleaseSRWLockExclusive =
|
|
(VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
|
|
"ReleaseSRWLockExclusive");
|
|
fpReleaseSRWLockShared =
|
|
(VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
|
|
"ReleaseSRWLockShared");
|
|
|
|
if (fpInitializeSRWLock != NULL) {
|
|
sHasSRW = true;
|
|
}
|
|
}
|
|
}
|
|
return sHasSRW;
|
|
}
|
|
|
|
sys::RWMutexImpl::RWMutexImpl() {
|
|
if (loadSRW()) {
|
|
data_ = safe_calloc(1, sizeof(SRWLOCK));
|
|
fpInitializeSRWLock(static_cast<PSRWLOCK>(data_));
|
|
} else {
|
|
data_ = safe_calloc(1, sizeof(CRITICAL_SECTION));
|
|
InitializeCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
|
|
}
|
|
}
|
|
|
|
sys::RWMutexImpl::~RWMutexImpl() {
|
|
if (!sHasSRW)
|
|
DeleteCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
|
|
// Nothing to do in the case of slim reader/writers except free the memory.
|
|
free(data_);
|
|
}
|
|
|
|
bool sys::RWMutexImpl::reader_acquire() {
|
|
if (sHasSRW) {
|
|
fpAcquireSRWLockShared(static_cast<PSRWLOCK>(data_));
|
|
} else {
|
|
EnterCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool sys::RWMutexImpl::reader_release() {
|
|
if (sHasSRW) {
|
|
fpReleaseSRWLockShared(static_cast<PSRWLOCK>(data_));
|
|
} else {
|
|
LeaveCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool sys::RWMutexImpl::writer_acquire() {
|
|
if (sHasSRW) {
|
|
fpAcquireSRWLockExclusive(static_cast<PSRWLOCK>(data_));
|
|
} else {
|
|
EnterCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool sys::RWMutexImpl::writer_release() {
|
|
if (sHasSRW) {
|
|
fpReleaseSRWLockExclusive(static_cast<PSRWLOCK>(data_));
|
|
} else {
|
|
LeaveCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
}
|