From 021d664a3838b89620b3fb9d995083f1da77d451 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Wed, 19 Aug 2009 00:52:13 +0000 Subject: [PATCH] Revert my last patch temporarily. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79388 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Support/LeakDetector.h | 6 +- lib/VMCore/LLVMContextImpl.h | 5 -- lib/VMCore/LeakDetector.cpp | 114 ++++++++++++++++++++++++++++-------- 3 files changed, 93 insertions(+), 32 deletions(-) diff --git a/include/llvm/Support/LeakDetector.h b/include/llvm/Support/LeakDetector.h index 7dbfdbf3d52..8d74ac663b1 100644 --- a/include/llvm/Support/LeakDetector.h +++ b/include/llvm/Support/LeakDetector.h @@ -56,9 +56,9 @@ struct LeakDetector { /// The specified message will be printed indicating when the check was /// performed. /// - static void checkForGarbage(LLVMContext &C, const std::string &Message) { + static void checkForGarbage(const std::string &Message) { #ifndef NDEBUG - checkForGarbageImpl(C, Message); + checkForGarbageImpl(Message); #endif } @@ -83,7 +83,7 @@ private: static void removeGarbageObjectImpl(const Value *Object); static void addGarbageObjectImpl(void *Object); static void removeGarbageObjectImpl(void *Object); - static void checkForGarbageImpl(LLVMContext &C, const std::string &Message); + static void checkForGarbageImpl(const std::string &Message); }; } // End llvm namespace diff --git a/lib/VMCore/LLVMContextImpl.h b/lib/VMCore/LLVMContextImpl.h index 20d410eaf87..aaa48ca0d4f 100644 --- a/lib/VMCore/LLVMContextImpl.h +++ b/lib/VMCore/LLVMContextImpl.h @@ -16,7 +16,6 @@ #define LLVM_LLVMCONTEXT_IMPL_H #include "ConstantsContext.h" -#include "LeaksContext.h" #include "TypesContext.h" #include "llvm/LLVMContext.h" #include "llvm/Constants.h" @@ -135,10 +134,6 @@ public: ConstantInt *TheTrueVal; ConstantInt *TheFalseVal; - // Lock used for guarding access to the leak detector - sys::SmartMutex LLVMObjectsLock; - LeakDetectorImpl LLVMObjects; - // Lock used for guarding access to the type maps. sys::SmartMutex TypeMapLock; diff --git a/lib/VMCore/LeakDetector.cpp b/lib/VMCore/LeakDetector.cpp index 31857421746..a6be1afed49 100644 --- a/lib/VMCore/LeakDetector.cpp +++ b/lib/VMCore/LeakDetector.cpp @@ -11,63 +11,129 @@ // //===----------------------------------------------------------------------===// -#include "LLVMContextImpl.h" #include "llvm/Support/LeakDetector.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/Streams.h" -#include "llvm/System/Mutex.h" +#include "llvm/System/RWMutex.h" #include "llvm/System/Threading.h" #include "llvm/Value.h" using namespace llvm; -static ManagedStatic > ObjectsLock; -static ManagedStatic > Objects; +namespace { + template + struct VISIBILITY_HIDDEN PrinterTrait { + static void print(const T* P) { cerr << P; } + }; -static void clearGarbage(LLVMContext &Context) { - Objects->clear(); - Context.pImpl->LLVMObjects.clear(); + template<> + struct VISIBILITY_HIDDEN PrinterTrait { + static void print(const Value* P) { cerr << *P; } + }; + + ManagedStatic > LeakDetectorLock; + + template + struct VISIBILITY_HIDDEN LeakDetectorImpl { + explicit LeakDetectorImpl(const char* const name = "") : + Cache(0), Name(name) { } + + void clear() { + Cache = 0; + Ts.clear(); + } + + void setName(const char* n) { + Name = n; + } + + // Because the most common usage pattern, by far, is to add a + // garbage object, then remove it immediately, we optimize this + // case. When an object is added, it is not added to the set + // immediately, it is added to the CachedValue Value. If it is + // immediately removed, no set search need be performed. + void addGarbage(const T* o) { + sys::SmartScopedWriter Writer(*LeakDetectorLock); + if (Cache) { + assert(Ts.count(Cache) == 0 && "Object already in set!"); + Ts.insert(Cache); + } + Cache = o; + } + + void removeGarbage(const T* o) { + sys::SmartScopedWriter Writer(*LeakDetectorLock); + if (o == Cache) + Cache = 0; // Cache hit + else + Ts.erase(o); + } + + bool hasGarbage(const std::string& Message) { + addGarbage(0); // Flush the Cache + + sys::SmartScopedReader Reader(*LeakDetectorLock); + assert(Cache == 0 && "No value should be cached anymore!"); + + if (!Ts.empty()) { + cerr << "Leaked " << Name << " objects found: " << Message << ":\n"; + for (typename SmallPtrSet::iterator I = Ts.begin(), + E = Ts.end(); I != E; ++I) { + cerr << "\t"; + PrinterTrait::print(*I); + cerr << "\n"; + } + cerr << '\n'; + + return true; + } + + return false; + } + + private: + SmallPtrSet Ts; + const T* Cache; + const char* Name; + }; + + static ManagedStatic > Objects; + static ManagedStatic > LLVMObjects; + + static void clearGarbage() { + Objects->clear(); + LLVMObjects->clear(); + } } void LeakDetector::addGarbageObjectImpl(void *Object) { - sys::SmartScopedLock Lock(*ObjectsLock); Objects->addGarbage(Object); } void LeakDetector::addGarbageObjectImpl(const Value *Object) { - LLVMContextImpl *pImpl = Object->getContext().pImpl; - sys::SmartScopedLock Lock(pImpl->LLVMObjectsLock); - pImpl->LLVMObjects.addGarbage(Object); + LLVMObjects->addGarbage(Object); } void LeakDetector::removeGarbageObjectImpl(void *Object) { - sys::SmartScopedLock Lock(*ObjectsLock); Objects->removeGarbage(Object); } void LeakDetector::removeGarbageObjectImpl(const Value *Object) { - LLVMContextImpl *pImpl = Object->getContext().pImpl; - sys::SmartScopedLock Lock(pImpl->LLVMObjectsLock); - pImpl->LLVMObjects.removeGarbage(Object); + LLVMObjects->removeGarbage(Object); } -void LeakDetector::checkForGarbageImpl(LLVMContext &Context, - const std::string &Message) { - LLVMContextImpl *pImpl = Context.pImpl; - sys::SmartScopedLock Lock(*ObjectsLock); - sys::SmartScopedLock CLock(pImpl->LLVMObjectsLock); - +void LeakDetector::checkForGarbageImpl(const std::string &Message) { Objects->setName("GENERIC"); - pImpl->LLVMObjects.setName("LLVM"); + LLVMObjects->setName("LLVM"); // use non-short-circuit version so that both checks are performed if (Objects->hasGarbage(Message) | - pImpl->LLVMObjects.hasGarbage(Message)) + LLVMObjects->hasGarbage(Message)) cerr << "\nThis is probably because you removed an object, but didn't " << "delete it. Please check your code for memory leaks.\n"; // Clear out results so we don't get duplicate warnings on // next call... - clearGarbage(Context); + clearGarbage(); } -- 2.11.0