mirror of
https://github.com/RPCS3/llvm.git
synced 2025-04-13 11:30:21 +00:00
8290382d1f
D19271. Previous attempt was broken by NetBSD, so in this version I've made the fallback path generic rather than Windows specific and sent both Windows and NetBSD to it. I've also re-formatted the code some, and used an exact clone of the code in PassSupport.h for doing manual call-once using our atomics rather than rolling a new one. If this sticks, we can replace the fallback path for Windows with a Windows-specific implementation that is more reliable. Original commit message: This patch adds an llvm_call_once which is a wrapper around std::call_once on platforms where it is available and devoid of bugs. The patch also migrates the ManagedStatic mutex to be allocated using llvm_call_once. These changes are philosophically equivalent to the changes added in r219638, which were reverted due to a hang on Win32 which was the result of a bug in the Windows implementation of std::call_once. Differential Revision: http://reviews.llvm.org/D5922 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@271558 91177308-0d34-0410-b5e6-96231b3b80d8
98 lines
2.8 KiB
C++
98 lines
2.8 KiB
C++
//===-- ManagedStatic.cpp - Static Global wrapper -------------------------===//
|
|
//
|
|
// 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 ManagedStatic class and llvm_shutdown().
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include "llvm/Config/config.h"
|
|
#include "llvm/Support/Atomic.h"
|
|
#include "llvm/Support/Mutex.h"
|
|
#include "llvm/Support/MutexGuard.h"
|
|
#include "llvm/Support/Threading.h"
|
|
#include <cassert>
|
|
using namespace llvm;
|
|
|
|
static const ManagedStaticBase *StaticList = nullptr;
|
|
static sys::Mutex *ManagedStaticMutex = nullptr;
|
|
LLVM_DEFINE_ONCE_FLAG(mutex_init_flag);
|
|
|
|
static void initializeMutex() {
|
|
ManagedStaticMutex = new sys::Mutex();
|
|
}
|
|
|
|
static sys::Mutex* getManagedStaticMutex() {
|
|
// We need to use a function local static here, since this can get called
|
|
// during a static constructor and we need to guarantee that it's initialized
|
|
// correctly.
|
|
call_once(mutex_init_flag, initializeMutex);
|
|
return ManagedStaticMutex;
|
|
}
|
|
|
|
void ManagedStaticBase::RegisterManagedStatic(void *(*Creator)(),
|
|
void (*Deleter)(void*)) const {
|
|
assert(Creator);
|
|
if (llvm_is_multithreaded()) {
|
|
MutexGuard Lock(*getManagedStaticMutex());
|
|
|
|
if (!Ptr) {
|
|
void* tmp = Creator();
|
|
|
|
TsanHappensBefore(this);
|
|
sys::MemoryFence();
|
|
|
|
// This write is racy against the first read in the ManagedStatic
|
|
// accessors. The race is benign because it does a second read after a
|
|
// memory fence, at which point it isn't possible to get a partial value.
|
|
TsanIgnoreWritesBegin();
|
|
Ptr = tmp;
|
|
TsanIgnoreWritesEnd();
|
|
DeleterFn = Deleter;
|
|
|
|
// Add to list of managed statics.
|
|
Next = StaticList;
|
|
StaticList = this;
|
|
}
|
|
} else {
|
|
assert(!Ptr && !DeleterFn && !Next &&
|
|
"Partially initialized ManagedStatic!?");
|
|
Ptr = Creator();
|
|
DeleterFn = Deleter;
|
|
|
|
// Add to list of managed statics.
|
|
Next = StaticList;
|
|
StaticList = this;
|
|
}
|
|
}
|
|
|
|
void ManagedStaticBase::destroy() const {
|
|
assert(DeleterFn && "ManagedStatic not initialized correctly!");
|
|
assert(StaticList == this &&
|
|
"Not destroyed in reverse order of construction?");
|
|
// Unlink from list.
|
|
StaticList = Next;
|
|
Next = nullptr;
|
|
|
|
// Destroy memory.
|
|
DeleterFn(Ptr);
|
|
|
|
// Cleanup.
|
|
Ptr = nullptr;
|
|
DeleterFn = nullptr;
|
|
}
|
|
|
|
/// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
|
|
void llvm::llvm_shutdown() {
|
|
MutexGuard Lock(*getManagedStaticMutex());
|
|
|
|
while (StaticList)
|
|
StaticList->destroy();
|
|
}
|