Guard dynamic library loading.

[oota-llvm.git] / lib / Support / Annotation.cpp

diff --git a/lib/Support/Annotation.cpp b/lib/Support/Annotation.cpp
index c8cf8298b40b21b0cb069af29a10359c70468b88..9c3efa37d8672a77be7651614a3b675b2bf2a5f1 100644 (file)
--- a/lib/Support/Annotation.cpp
+++ b/lib/Support/Annotation.cpp
@@ -1,18 +1,21 @@
 //===-- Annotation.cpp - Implement the Annotation Classes -----------------===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
 //===----------------------------------------------------------------------===//
 //
 // This file implements the AnnotationManager class.
 //
 //===----------------------------------------------------------------------===//
 
-#include <map>
 #include "llvm/Support/Annotation.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/System/RWMutex.h"
+#include <map>
+#include <cstring>
 using namespace llvm;
 
 Annotation::~Annotation() {}  // Designed to be subclassed
@@ -26,83 +29,99 @@ Annotable::~Annotable() {   // Virtual because it's designed to be subclassed...
   }
 }
 
+namespace {
+  class StrCmp {
+  public:
+    bool operator()(const char *a, const char *b) const {
+      return strcmp(a, b) < 0;
+    }
+  };
+}
 
-typedef std::map<const std::string, unsigned> IDMapType;
+typedef std::map<const char*, unsigned, StrCmp> IDMapType;
 static unsigned IDCounter = 0;  // Unique ID counter
 
 // Static member to ensure initialiation on demand.
-static IDMapType &getIDMap() { static IDMapType TheMap; return TheMap; }
+static ManagedStatic<IDMapType> IDMap;
+static ManagedStatic<sys::SmartRWMutex<true> > AnnotationsLock;
 
 // On demand annotation creation support...
 typedef Annotation *(*AnnFactory)(AnnotationID, const Annotable *, void *);
 typedef std::map<unsigned, std::pair<AnnFactory,void*> > FactMapType;
 
-static FactMapType *TheFactMap = 0;
+static ManagedStatic<FactMapType> TheFactMap;
 static FactMapType &getFactMap() {
-  if (TheFactMap == 0)
-    TheFactMap = new FactMapType();
   return *TheFactMap;
 }
 
 static void eraseFromFactMap(unsigned ID) {
-  assert(TheFactMap && "No entries found!");
+  sys::SmartScopedWriter<true> Writer(&*AnnotationsLock);
   TheFactMap->erase(ID);
-  if (TheFactMap->empty()) {   // Delete when empty
-    delete TheFactMap;
-    TheFactMap = 0;
-  }
 }
 
-AnnotationID AnnotationManager::getID(const std::string &Name) {  // Name -> ID
-  IDMapType::iterator I = getIDMap().find(Name);
-  if (I == getIDMap().end()) {
-    getIDMap()[Name] = IDCounter++;   // Add a new element
-    return IDCounter-1;
+AnnotationID AnnotationManager::getID(const char *Name) {  // Name -> ID
+  AnnotationsLock->reader_acquire();
+  IDMapType::iterator I = IDMap->find(Name);
+  IDMapType::iterator E = IDMap->end();
+  AnnotationsLock->reader_release();
+  
+  if (I == E) {
+    sys::SmartScopedWriter<true> Writer(&*AnnotationsLock);
+    I = IDMap->find(Name);
+    if (I == IDMap->end())
+      (*IDMap)[Name] = IDCounter++;   // Add a new element
+    return AnnotationID(IDCounter-1);
   }
-  return I->second;
+  return AnnotationID(I->second);
 }
 
 // getID - Name -> ID + registration of a factory function for demand driven
 // annotation support.
-AnnotationID AnnotationManager::getID(const std::string &Name, Factory Fact,
-                                     void *Data) {
+AnnotationID AnnotationManager::getID(const char *Name, Factory Fact,
+                                      void *Data) {
   AnnotationID Result(getID(Name));
   registerAnnotationFactory(Result, Fact, Data);
-  return Result;                     
+  return Result;
 }
 
-
 // getName - This function is especially slow, but that's okay because it should
 // only be used for debugging.
 //
-const std::string &AnnotationManager::getName(AnnotationID ID) {  // ID -> Name
-  IDMapType &TheMap = getIDMap();
+const char *AnnotationManager::getName(AnnotationID ID) {  // ID -> Name
+  sys::SmartScopedReader<true> Reader(&*AnnotationsLock);
+  IDMapType &TheMap = *IDMap;
   for (IDMapType::iterator I = TheMap.begin(); ; ++I) {
     assert(I != TheMap.end() && "Annotation ID is unknown!");
     if (I->second == ID.ID) return I->first;
   }
 }
 
-
 // registerAnnotationFactory - This method is used to register a callback
-// function used to create an annotation on demand if it is needed by the 
+// function used to create an annotation on demand if it is needed by the
 // Annotable::findOrCreateAnnotation method.
 //
-void AnnotationManager::registerAnnotationFactory(AnnotationID ID, 
-                                                 AnnFactory F,
-                                                 void *ExtraData) {
-  if (F)
+void AnnotationManager::registerAnnotationFactory(AnnotationID ID, AnnFactory F,
+                                                  void *ExtraData) {
+  if (F) {
+    sys::SmartScopedWriter<true> Writer(&*AnnotationsLock);
     getFactMap()[ID.ID] = std::make_pair(F, ExtraData);
-  else
+  } else {
     eraseFromFactMap(ID.ID);
+  }
 }
 
 // createAnnotation - Create an annotation of the specified ID for the
 // specified object, using a register annotation creation function.
 //
-Annotation *AnnotationManager::createAnnotation(AnnotationID ID, 
-                                               const Annotable *Obj) {
+Annotation *AnnotationManager::createAnnotation(AnnotationID ID,
+                                                const Annotable *Obj) {
+  AnnotationsLock->reader_acquire();
   FactMapType::iterator I = getFactMap().find(ID.ID);
-  if (I == getFactMap().end()) return 0;
+  if (I == getFactMap().end()) {
+    AnnotationsLock->reader_release();
+    return 0;
+  }
+  
+  AnnotationsLock->reader_release();
   return I->second.first(ID, Obj, I->second.second);
 }