6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-02-10 20:33:15 +00:00
Code Issues Projects Releases Wiki Activity

Add locking around the accessors for AbstractTypeUsers.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@73586 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2009-06-17 00:12:30 +00:00
parent 6be926647d
commit 142fb2acdd
1 changed files with 24 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
lib/VMCore/Type.cpp
View File

@ -24,6 +24,7 @@
#include "llvm/Support/MathExtras.h" #include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Threading.h" #include "llvm/Support/Threading.h"
#include "llvm/System/Mutex.h"
#include "llvm/System/RWMutex.h" #include "llvm/System/RWMutex.h"
#include <algorithm> #include <algorithm>
#include <cstdarg> #include <cstdarg>
@ -45,6 +46,9 @@ AbstractTypeUser::~AbstractTypeUser() {}
// Reader/writer lock used for guarding access to the type maps. // Reader/writer lock used for guarding access to the type maps.
static ManagedStatic<sys::RWMutex> TypeMapLock; static ManagedStatic<sys::RWMutex> TypeMapLock;
// Lock used for guarding access to AbstractTypeUsers.
static ManagedStatic<sys::Mutex> AbstractTypeUsersLock;
// Concrete/Abstract TypeDescriptions - We lazily calculate type descriptions // Concrete/Abstract TypeDescriptions - We lazily calculate type descriptions
// for types as they are needed. Because resolution of types must invalidate // for types as they are needed. Because resolution of types must invalidate
// all of the abstract type descriptions, we keep them in a seperate map to make // all of the abstract type descriptions, we keep them in a seperate map to make
@ -1440,12 +1444,28 @@ bool PointerType::isValidElementType(const Type *ElemTy) {
// Derived Type Refinement Functions // Derived Type Refinement Functions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// addAbstractTypeUser - Notify an abstract type that there is a new user of
// it. This function is called primarily by the PATypeHandle class.
void Type::addAbstractTypeUser(AbstractTypeUser *U) const {
assert(isAbstract() && "addAbstractTypeUser: Current type not abstract!");
if (llvm_is_multithreaded()) {
AbstractTypeUsersLock->acquire();
AbstractTypeUsers.push_back(U);
AbstractTypeUsersLock->release();
} else {
AbstractTypeUsers.push_back(U);
}
}
// removeAbstractTypeUser - Notify an abstract type that a user of the class // removeAbstractTypeUser - Notify an abstract type that a user of the class
// no longer has a handle to the type. This function is called primarily by // no longer has a handle to the type. This function is called primarily by
// the PATypeHandle class. When there are no users of the abstract type, it // the PATypeHandle class. When there are no users of the abstract type, it
// is annihilated, because there is no way to get a reference to it ever again. // is annihilated, because there is no way to get a reference to it ever again.
// //
void Type::removeAbstractTypeUser(AbstractTypeUser *U) const { void Type::removeAbstractTypeUser(AbstractTypeUser *U) const {
if (llvm_is_multithreaded()) AbstractTypeUsersLock->acquire();
// Search from back to front because we will notify users from back to // Search from back to front because we will notify users from back to
// front. Also, it is likely that there will be a stack like behavior to // front. Also, it is likely that there will be a stack like behavior to
// users that register and unregister users. // users that register and unregister users.
@ -1469,8 +1489,11 @@ void Type::removeAbstractTypeUser(AbstractTypeUser *U) const {
DOUT << "DELETEing unused abstract type: <" << *this DOUT << "DELETEing unused abstract type: <" << *this
<< ">[" << (void*)this << "]" << "\n"; << ">[" << (void*)this << "]" << "\n";
#endif #endif
this->destroy(); this->destroy();
} }
if (llvm_is_multithreaded()) AbstractTypeUsersLock->release();
} }
// unlockedRefineAbstractTypeTo - This function is used when it is discovered // unlockedRefineAbstractTypeTo - This function is used when it is discovered