2003-10-13 03:32:08 +00:00
|
|
|
//===-- Annotation.cpp - Implement the Annotation Classes -----------------===//
|
2005-04-21 22:55:34 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 22:55:34 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-08-23 17:07:56 +00:00
|
|
|
//
|
|
|
|
// This file implements the AnnotationManager class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/Annotation.h"
|
2006-10-04 22:13:11 +00:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2009-06-22 22:44:15 +00:00
|
|
|
#include "llvm/System/RWMutex.h"
|
2004-11-09 04:27:19 +00:00
|
|
|
#include <map>
|
2008-11-27 16:42:44 +00:00
|
|
|
#include <cstring>
|
2003-12-14 21:35:53 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2004-02-26 07:24:18 +00:00
|
|
|
Annotation::~Annotation() {} // Designed to be subclassed
|
|
|
|
|
|
|
|
Annotable::~Annotable() { // Virtual because it's designed to be subclassed...
|
|
|
|
Annotation *A = AnnotationList;
|
|
|
|
while (A) {
|
|
|
|
Annotation *Next = A->getNext();
|
|
|
|
delete A;
|
|
|
|
A = Next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-27 16:37:02 +00:00
|
|
|
namespace {
|
|
|
|
class StrCmp {
|
|
|
|
public:
|
2008-12-08 00:45:02 +00:00
|
|
|
bool operator()(const char *a, const char *b) const {
|
2008-11-27 16:37:02 +00:00
|
|
|
return strcmp(a, b) < 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef std::map<const char*, unsigned, StrCmp> IDMapType;
|
2009-06-30 05:33:46 +00:00
|
|
|
static volatile sys::cas_flag IDCounter = 0; // Unique ID counter
|
2001-08-23 17:07:56 +00:00
|
|
|
|
|
|
|
// Static member to ensure initialiation on demand.
|
2006-10-04 22:13:11 +00:00
|
|
|
static ManagedStatic<IDMapType> IDMap;
|
2009-06-22 22:44:15 +00:00
|
|
|
static ManagedStatic<sys::SmartRWMutex<true> > AnnotationsLock;
|
2001-08-23 17:07:56 +00:00
|
|
|
|
|
|
|
// On demand annotation creation support...
|
2001-09-07 16:44:01 +00:00
|
|
|
typedef Annotation *(*AnnFactory)(AnnotationID, const Annotable *, void *);
|
2003-05-22 21:59:35 +00:00
|
|
|
typedef std::map<unsigned, std::pair<AnnFactory,void*> > FactMapType;
|
2003-01-13 00:52:43 +00:00
|
|
|
|
2009-06-22 22:44:15 +00:00
|
|
|
static ManagedStatic<FactMapType> TheFactMap;
|
2003-01-13 00:52:43 +00:00
|
|
|
static FactMapType &getFactMap() {
|
|
|
|
return *TheFactMap;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void eraseFromFactMap(unsigned ID) {
|
2009-06-22 22:44:15 +00:00
|
|
|
sys::SmartScopedWriter<true> Writer(&*AnnotationsLock);
|
2003-01-13 00:52:43 +00:00
|
|
|
TheFactMap->erase(ID);
|
|
|
|
}
|
2001-08-23 17:07:56 +00:00
|
|
|
|
2008-11-26 00:00:44 +00:00
|
|
|
AnnotationID AnnotationManager::getID(const char *Name) { // Name -> ID
|
2009-06-22 22:44:15 +00:00
|
|
|
AnnotationsLock->reader_acquire();
|
2006-10-04 22:13:11 +00:00
|
|
|
IDMapType::iterator I = IDMap->find(Name);
|
2009-06-22 22:44:15 +00:00
|
|
|
IDMapType::iterator E = IDMap->end();
|
|
|
|
AnnotationsLock->reader_release();
|
|
|
|
|
|
|
|
if (I == E) {
|
|
|
|
sys::SmartScopedWriter<true> Writer(&*AnnotationsLock);
|
|
|
|
I = IDMap->find(Name);
|
2009-06-26 18:09:03 +00:00
|
|
|
if (I == IDMap->end()) {
|
|
|
|
unsigned newCount = sys::AtomicIncrement(&IDCounter);
|
|
|
|
(*IDMap)[Name] = newCount-1; // Add a new element
|
|
|
|
return AnnotationID(newCount-1);
|
|
|
|
} else
|
|
|
|
return AnnotationID(I->second);
|
2001-08-23 17:07:56 +00:00
|
|
|
}
|
2008-02-20 16:44:09 +00:00
|
|
|
return AnnotationID(I->second);
|
2001-08-23 17:07:56 +00:00
|
|
|
}
|
|
|
|
|
2001-09-09 21:02:38 +00:00
|
|
|
// getID - Name -> ID + registration of a factory function for demand driven
|
|
|
|
// annotation support.
|
2008-11-26 00:00:44 +00:00
|
|
|
AnnotationID AnnotationManager::getID(const char *Name, Factory Fact,
|
2004-11-09 04:27:19 +00:00
|
|
|
void *Data) {
|
2001-09-09 21:02:38 +00:00
|
|
|
AnnotationID Result(getID(Name));
|
|
|
|
registerAnnotationFactory(Result, Fact, Data);
|
2005-04-21 22:55:34 +00:00
|
|
|
return Result;
|
2001-09-09 21:02:38 +00:00
|
|
|
}
|
|
|
|
|
2001-08-23 17:07:56 +00:00
|
|
|
// getName - This function is especially slow, but that's okay because it should
|
|
|
|
// only be used for debugging.
|
|
|
|
//
|
2008-11-26 00:00:44 +00:00
|
|
|
const char *AnnotationManager::getName(AnnotationID ID) { // ID -> Name
|
2009-06-22 22:44:15 +00:00
|
|
|
sys::SmartScopedReader<true> Reader(&*AnnotationsLock);
|
2006-10-04 22:13:11 +00:00
|
|
|
IDMapType &TheMap = *IDMap;
|
2001-08-23 17:07:56 +00:00
|
|
|
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
|
2005-04-21 22:55:34 +00:00
|
|
|
// function used to create an annotation on demand if it is needed by the
|
2001-08-23 17:07:56 +00:00
|
|
|
// Annotable::findOrCreateAnnotation method.
|
|
|
|
//
|
2004-11-09 04:27:19 +00:00
|
|
|
void AnnotationManager::registerAnnotationFactory(AnnotationID ID, AnnFactory F,
|
|
|
|
void *ExtraData) {
|
2009-06-22 22:44:15 +00:00
|
|
|
if (F) {
|
|
|
|
sys::SmartScopedWriter<true> Writer(&*AnnotationsLock);
|
2003-05-22 21:59:35 +00:00
|
|
|
getFactMap()[ID.ID] = std::make_pair(F, ExtraData);
|
2009-06-22 22:44:15 +00:00
|
|
|
} else {
|
2003-01-13 00:52:43 +00:00
|
|
|
eraseFromFactMap(ID.ID);
|
2009-06-22 22:44:15 +00:00
|
|
|
}
|
2001-08-23 17:07:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// createAnnotation - Create an annotation of the specified ID for the
|
|
|
|
// specified object, using a register annotation creation function.
|
|
|
|
//
|
2005-04-21 22:55:34 +00:00
|
|
|
Annotation *AnnotationManager::createAnnotation(AnnotationID ID,
|
2004-11-09 04:27:19 +00:00
|
|
|
const Annotable *Obj) {
|
2009-06-22 22:44:15 +00:00
|
|
|
AnnotationsLock->reader_acquire();
|
2001-08-23 17:07:56 +00:00
|
|
|
FactMapType::iterator I = getFactMap().find(ID.ID);
|
2009-06-22 22:44:15 +00:00
|
|
|
if (I == getFactMap().end()) {
|
|
|
|
AnnotationsLock->reader_release();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
AnnotationsLock->reader_release();
|
2001-08-27 05:19:10 +00:00
|
|
|
return I->second.first(ID, Obj, I->second.second);
|
2001-08-23 17:07:56 +00:00
|
|
|
}
|