#define LLVM_TYPE_SYMBOL_TABLE_H
#include "llvm/Type.h"
+#include "llvm/ADT/StringRef.h"
#include <map>
namespace llvm {
/// Lookup the type associated with name.
/// @returns end() if the name is not found, or an iterator at the entry for
/// Type.
- iterator find(const StringRef &name);
+ iterator find(const StringRef &Name) {
+ return tmap.find(Name);
+ }
/// Lookup the type associated with name.
/// @returns end() if the name is not found, or an iterator at the entry for
/// Type.
- const_iterator find(const StringRef &name) const;
+ const_iterator find(const StringRef &Name) const {
+ return tmap.find(Name);
+ }
/// @returns true iff the symbol table is empty.
/// @brief Determine if the symbol table is empty
}
}
+ // Store to undef and store to null are undefined and used to signal that
+ // they should be changed to unreachable by passes that can't modify the
+ // CFG.
if (StoreInst *SI = dyn_cast<StoreInst>(BBI)) {
Value *Ptr = SI->getOperand(1);
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
-#include "llvm/System/Mutex.h"
-#include "llvm/System/RWMutex.h"
-#include "llvm/System/Threading.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include <algorithm>
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
-#include "llvm/System/Mutex.h"
-#include "llvm/System/RWMutex.h"
#include <map>
namespace llvm {
///
AbstractTypeMapTy AbstractTypeMap;
- /// ConstantUniqueMapLock - Mutex for this map.
- sys::SmartMutex<true> ConstantUniqueMapLock;
-
public:
- // NOTE: This function is not locked. It is the caller's responsibility
- // to enforce proper synchronization.
typename MapTy::iterator map_begin() { return Map.begin(); }
typename MapTy::iterator map_end() { return Map.end(); }
/// entry and Exists=true. If not, the iterator points to the newly
/// inserted entry and returns Exists=false. Newly inserted entries have
/// I->second == 0, and should be filled in.
- /// NOTE: This function is not locked. It is the caller's responsibility
- // to enforce proper synchronization.
typename MapTy::iterator InsertOrGetItem(std::pair<MapKey, ConstantClass *>
&InsertVal,
bool &Exists) {
/// getOrCreate - Return the specified constant from the map, creating it if
/// necessary.
ConstantClass *getOrCreate(const TypeClass *Ty, const ValType &V) {
- sys::SmartScopedLock<true> Lock(ConstantUniqueMapLock);
MapKey Lookup(Ty, V);
ConstantClass* Result = 0;
}
void remove(ConstantClass *CP) {
- sys::SmartScopedLock<true> Lock(ConstantUniqueMapLock);
typename MapTy::iterator I = FindExistingElement(CP);
assert(I != Map.end() && "Constant not found in constant table!");
assert(I->second == CP && "Didn't find correct element?");
/// MoveConstantToNewSlot - If we are about to change C to be the element
/// specified by I, update our internal data structures to reflect this
/// fact.
- /// NOTE: This function is not locked. It is the responsibility of the
- /// caller to enforce proper synchronization if using this method.
void MoveConstantToNewSlot(ConstantClass *C, typename MapTy::iterator I) {
// First, remove the old location of the specified constant in the map.
typename MapTy::iterator OldI = FindExistingElement(C);
}
void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
- sys::SmartScopedLock<true> Lock(ConstantUniqueMapLock);
typename AbstractTypeMapTy::iterator I = AbstractTypeMap.find(OldTy);
assert(I != AbstractTypeMap.end() &&
#include "llvm/Metadata.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
-#include "llvm/System/Mutex.h"
-#include "llvm/System/RWMutex.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
ConstantInt *TheTrueVal;
ConstantInt *TheFalseVal;
- // Lock used for guarding access to the leak detector
- sys::SmartMutex<true> LLVMObjectsLock;
LeakDetectorImpl<Value> LLVMObjects;
- // Lock used for guarding access to the type maps.
- sys::SmartMutex<true> TypeMapLock;
-
- // Recursive lock used for guarding access to AbstractTypeUsers.
- // NOTE: The true template parameter means this will no-op when we're not in
- // multithreaded mode.
- sys::SmartMutex<true> AbstractTypeUsersLock;
-
// Basic type instances.
const Type VoidTy;
const Type LabelTy;
void LeakDetector::addGarbageObjectImpl(const Value *Object) {
LLVMContextImpl *pImpl = Object->getContext().pImpl;
- sys::SmartScopedLock<true> Lock(pImpl->LLVMObjectsLock);
pImpl->LLVMObjects.addGarbage(Object);
}
void LeakDetector::removeGarbageObjectImpl(const Value *Object) {
LLVMContextImpl *pImpl = Object->getContext().pImpl;
- sys::SmartScopedLock<true> Lock(pImpl->LLVMObjectsLock);
pImpl->LLVMObjects.removeGarbage(Object);
}
const std::string &Message) {
LLVMContextImpl *pImpl = Context.pImpl;
sys::SmartScopedLock<true> Lock(*ObjectsLock);
- sys::SmartScopedLock<true> CLock(pImpl->LLVMObjectsLock);
Objects->setName("GENERIC");
pImpl->LLVMObjects.setName("LLVM");
#include "llvm/Value.h"
#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/Support/raw_ostream.h"
using namespace llvm;
template <class T>
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
-#include "llvm/System/Mutex.h"
-#include "llvm/System/RWMutex.h"
#include "llvm/System/Threading.h"
#include <algorithm>
#include <cstdarg>
// First, see if the type is already in the table, for which
// a reader lock suffices.
- sys::SmartScopedLock<true> L(pImpl->TypeMapLock);
ITy = pImpl->IntegerTypes.get(IVT);
if (!ITy) {
LLVMContextImpl *pImpl = ReturnType->getContext().pImpl;
- sys::SmartScopedLock<true> L(pImpl->TypeMapLock);
FT = pImpl->FunctionTypes.get(VT);
if (!FT) {
LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
- sys::SmartScopedLock<true> L(pImpl->TypeMapLock);
AT = pImpl->ArrayTypes.get(AVT);
if (!AT) {
LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
- sys::SmartScopedLock<true> L(pImpl->TypeMapLock);
PT = pImpl->VectorTypes.get(PVT);
if (!PT) {
LLVMContextImpl *pImpl = Context.pImpl;
- sys::SmartScopedLock<true> L(pImpl->TypeMapLock);
ST = pImpl->StructTypes.get(STV);
if (!ST) {
LLVMContextImpl *pImpl = ValueType->getContext().pImpl;
- sys::SmartScopedLock<true> L(pImpl->TypeMapLock);
PT = pImpl->PointerTypes.get(PVT);
if (!PT) {
// it. This function is called primarily by the PATypeHandle class.
void Type::addAbstractTypeUser(AbstractTypeUser *U) const {
assert(isAbstract() && "addAbstractTypeUser: Current type not abstract!");
- LLVMContextImpl *pImpl = getContext().pImpl;
- pImpl->AbstractTypeUsersLock.acquire();
AbstractTypeUsers.push_back(U);
- pImpl->AbstractTypeUsersLock.release();
}
// is annihilated, because there is no way to get a reference to it ever again.
//
void Type::removeAbstractTypeUser(AbstractTypeUser *U) const {
- LLVMContextImpl *pImpl = getContext().pImpl;
- pImpl->AbstractTypeUsersLock.acquire();
// 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
this->destroy();
}
- pImpl->AbstractTypeUsersLock.release();
}
// unlockedRefineAbstractTypeTo - This function is used when it is discovered
// will not cause users to drop off of the use list. If we resolve to ourself
// we succeed!
//
- pImpl->AbstractTypeUsersLock.acquire();
while (!AbstractTypeUsers.empty() && NewTy != this) {
AbstractTypeUser *User = AbstractTypeUsers.back();
assert(AbstractTypeUsers.size() != OldSize &&
"AbsTyUser did not remove self from user list!");
}
- pImpl->AbstractTypeUsersLock.release();
// If we were successful removing all users from the type, 'this' will be
// deleted when the last PATypeHolder is destroyed or updated from this type.
void DerivedType::refineAbstractTypeTo(const Type *NewType) {
// All recursive calls will go through unlockedRefineAbstractTypeTo,
// to avoid deadlock problems.
- sys::SmartScopedLock<true> L(NewType->getContext().pImpl->TypeMapLock);
unlockedRefineAbstractTypeTo(NewType);
}
DEBUG(errs() << "typeIsREFINED type: " << (void*)this << " " << *this <<"\n");
#endif
- LLVMContextImpl *pImpl = getContext().pImpl;
-
- pImpl->AbstractTypeUsersLock.acquire();
unsigned OldSize = AbstractTypeUsers.size(); OldSize=OldSize;
while (!AbstractTypeUsers.empty()) {
AbstractTypeUser *ATU = AbstractTypeUsers.back();
assert(AbstractTypeUsers.size() < OldSize-- &&
"AbstractTypeUser did not remove itself from the use list!");
}
- pImpl->AbstractTypeUsersLock.release();
}
// refineAbstractType - Called when a contained type is found to be more
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/raw_ostream.h"
-#include "llvm/System/RWMutex.h"
-#include "llvm/System/Threading.h"
#include <algorithm>
using namespace llvm;
#define DEBUG_SYMBOL_TABLE 0
#define DEBUG_ABSTYPE 0
-static ManagedStatic<sys::SmartRWMutex<true> > TypeSymbolTableLock;
-
TypeSymbolTable::~TypeSymbolTable() {
// Drop all abstract type references in the type plane...
for (iterator TI = tmap.begin(), TE = tmap.end(); TI != TE; ++TI) {
std::string TypeSymbolTable::getUniqueName(const StringRef &BaseName) const {
std::string TryName = BaseName;
- sys::SmartScopedReader<true> Reader(*TypeSymbolTableLock);
-
const_iterator End = tmap.end();
// See if the name exists
// lookup a type by name - returns null on failure
Type* TypeSymbolTable::lookup(const StringRef &Name) const {
- sys::SmartScopedReader<true> Reader(*TypeSymbolTableLock);
-
const_iterator TI = tmap.find(Name);
Type* result = 0;
if (TI != tmap.end())
return result;
}
-TypeSymbolTable::iterator TypeSymbolTable::find(const StringRef &Name) {
- sys::SmartScopedReader<true> Reader(*TypeSymbolTableLock);
- return tmap.find(Name);
-}
-
-TypeSymbolTable::const_iterator
-TypeSymbolTable::find(const StringRef &Name) const {
- sys::SmartScopedReader<true> Reader(*TypeSymbolTableLock);
- return tmap.find(Name);
-}
// remove - Remove a type from the symbol table...
Type* TypeSymbolTable::remove(iterator Entry) {
- TypeSymbolTableLock->writer_acquire();
-
assert(Entry != tmap.end() && "Invalid entry to remove!");
const Type* Result = Entry->second;
tmap.erase(Entry);
- TypeSymbolTableLock->writer_release();
-
// If we are removing an abstract type, remove the symbol table from it's use
// list...
if (Result->isAbstract()) {
void TypeSymbolTable::insert(const StringRef &Name, const Type* T) {
assert(T && "Can't insert null type into symbol table!");
- TypeSymbolTableLock->writer_acquire();
-
if (tmap.insert(std::make_pair(Name, T)).second) {
// Type inserted fine with no conflict.
tmap.insert(make_pair(UniqueName, T));
}
- TypeSymbolTableLock->writer_release();
-
// If we are adding an abstract type, add the symbol table to it's use list.
if (T->isAbstract()) {
cast<DerivedType>(T)->addAbstractTypeUser(this);
// This function is called when one of the types in the type plane are refined
void TypeSymbolTable::refineAbstractType(const DerivedType *OldType,
const Type *NewType) {
- sys::SmartScopedReader<true> Reader(*TypeSymbolTableLock);
-
// Loop over all of the types in the symbol table, replacing any references
// to OldType with references to NewType. Note that there may be multiple
// occurrences, and although we only need to remove one at a time, it's
// Loop over all of the types in the symbol table, dropping any abstract
// type user entries for AbsTy which occur because there are names for the
// type.
- sys::SmartScopedReader<true> Reader(*TypeSymbolTableLock);
for (iterator TI = begin(), TE = end(); TI != TE; ++TI)
if (TI->second == const_cast<Type*>(static_cast<const Type*>(AbsTy)))
AbsTy->removeAbstractTypeUser(this);
void TypeSymbolTable::dump() const {
errs() << "TypeSymbolPlane: ";
- sys::SmartScopedReader<true> Reader(*TypeSymbolTableLock);
for_each(tmap.begin(), tmap.end(), DumpTypes);
}
-// vim: sw=2 ai
#include "llvm/Support/LeakDetector.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/ValueHandle.h"
-#include "llvm/System/RWMutex.h"
-#include "llvm/System/Threading.h"
#include "llvm/ADT/DenseMap.h"
#include <algorithm>
using namespace llvm;
projects / oota-llvm.git / commitdiff