diff --git a/include/llvm/Support/Annotation.h b/include/llvm/Support/Annotation.h deleted file mode 100644 index ffc92965e60..00000000000 --- a/include/llvm/Support/Annotation.h +++ /dev/null @@ -1,216 +0,0 @@ -//===-- llvm/Support/Annotation.h - Annotation classes ----------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file contains the declarations for two classes: Annotation & Annotable. -// Using these two simple classes, anything that derives from Annotable can have -// Annotation subclasses attached to them, ready for easy retrieval. -// -// Annotations are designed to be easily attachable to various classes. -// -// The AnnotationManager class is essential for using these classes. It is -// responsible for turning Annotation name strings into tokens [unique id #'s] -// that may be used to search for and create annotations. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_SUPPORT_ANNOTATION_H -#define LLVM_SUPPORT_ANNOTATION_H - -#include - -namespace llvm { - -class AnnotationID; -class Annotation; -class Annotable; -struct AnnotationManager; - -//===----------------------------------------------------------------------===// -// -// AnnotationID - This class is a thin wrapper around an unsigned integer that -// is used to hopefully prevent errors using AnnotationID's. They may be copied -// freely around and passed byvalue with little or no overhead. -// -class AnnotationID { - friend struct AnnotationManager; - unsigned ID; - - AnnotationID(); // Default ctor is disabled - - // AnnotationID is only creatable from AnnMgr. - explicit inline AnnotationID(unsigned i) : ID(i) {} -public: - inline AnnotationID(const AnnotationID &A) : ID(A.ID) {} - - inline bool operator==(const AnnotationID &A) const { - return A.ID == ID; - } - inline bool operator<(const AnnotationID &A) const { - return ID < A.ID; - } -}; - - -//===----------------------------------------------------------------------===// -// -// Annotation Class - This class serves as a base class for any specific -// annotations that you might need. Simply subclass this to add extra -// information to the annotations. -// -class Annotation { - friend class Annotable; // Annotable manipulates Next list - AnnotationID ID; // ID number, as obtained from AnnotationManager - Annotation *Next; // The next annotation in the linked list -public: - explicit inline Annotation(AnnotationID id) : ID(id), Next(0) {} - virtual ~Annotation(); // Designed to be subclassed - - // getID - Return the unique ID# of this annotation - inline AnnotationID getID() const { return ID; } - - // getNext - Return the next annotation in the list... - inline Annotation *getNext() const { return Next; } -}; - - -//===----------------------------------------------------------------------===// -// -// Annotable - This class is used as a base class for all objects that would -// like to have annotation capability. -// -// Annotable objects keep their annotation list sorted as annotations are -// inserted and deleted. This is used to ensure that annotations with identical -// ID#'s are stored sequentially. -// -class Annotable { - mutable Annotation *AnnotationList; - - Annotable(const Annotable &); // Do not implement - void operator=(const Annotable &); // Do not implement -public: - Annotable() : AnnotationList(0) {} - ~Annotable(); - - // getAnnotation - Search the list for annotations of the specified ID. The - // pointer returned is either null (if no annotations of the specified ID - // exist), or it points to the first element of a potentially list of elements - // with identical ID #'s. - // - Annotation *getAnnotation(AnnotationID ID) const { - for (Annotation *A = AnnotationList; A; A = A->getNext()) - if (A->getID() == ID) return A; - return 0; - } - - // getOrCreateAnnotation - Search through the annotation list, if there is - // no annotation with the specified ID, then use the AnnotationManager to - // create one. - // - inline Annotation *getOrCreateAnnotation(AnnotationID ID) const; - - // addAnnotation - Insert the annotation into the list in a sorted location. - // - void addAnnotation(Annotation *A) const { - assert(A->Next == 0 && "Annotation already in list?!?"); - - Annotation **AL = &AnnotationList; - while (*AL && (*AL)->ID < A->getID()) // Find where to insert annotation - AL = &((*AL)->Next); - A->Next = *AL; // Link the annotation in - *AL = A; - } - - // unlinkAnnotation - Remove the first annotation of the specified ID... and - // then return the unlinked annotation. The annotation object is not deleted. - // - inline Annotation *unlinkAnnotation(AnnotationID ID) const { - for (Annotation **A = &AnnotationList; *A; A = &((*A)->Next)) - if ((*A)->getID() == ID) { - Annotation *Ret = *A; - *A = Ret->Next; - Ret->Next = 0; - return Ret; - } - return 0; - } - - // deleteAnnotation - Delete the first annotation of the specified ID in the - // list. Unlink unlinkAnnotation, this actually deletes the annotation object - // - bool deleteAnnotation(AnnotationID ID) const { - Annotation *A = unlinkAnnotation(ID); - delete A; - return A != 0; - } -}; - - -//===----------------------------------------------------------------------===// -// -// AnnotationManager - This class is primarily responsible for maintaining a -// one-to-one mapping between string Annotation names and Annotation ID numbers. -// -// Compared to the rest of the Annotation system, these mapping methods are -// relatively slow, so they should be avoided by locally caching Annotation -// ID #'s. These methods are safe to call at any time, even by static ctors, so -// they should be used by static ctors most of the time. -// -// This class also provides support for annotations that are created on demand -// by the Annotable::getOrCreateAnnotation method. To get this to work, simply -// register an annotation handler -// -struct AnnotationManager { - typedef Annotation *(*Factory)(AnnotationID, const Annotable *, void*); - - //===--------------------------------------------------------------------===// - // Basic ID <-> Name map functionality - - static AnnotationID getID(const char *Name); // Name -> ID - static const char *getName(AnnotationID ID); // ID -> Name - - // getID - Name -> ID + registration of a factory function for demand driven - // annotation support. - static AnnotationID getID(const char *Name, Factory Fact, void *Data = 0); - - //===--------------------------------------------------------------------===// - // Annotation creation on demand support... - - // registerAnnotationFactory - This method is used to register a callback - // function used to create an annotation on demand if it is needed by the - // Annotable::getOrCreateAnnotation method. - // - static void registerAnnotationFactory(AnnotationID ID, Factory Func, - void *ExtraData = 0); - - // createAnnotation - Create an annotation of the specified ID for the - // specified object, using a register annotation creation function. - // - static Annotation *createAnnotation(AnnotationID ID, const Annotable *Obj); -}; - - - -// getOrCreateAnnotation - Search through the annotation list, if there is -// no annotation with the specified ID, then use the AnnotationManager to -// create one. -// -inline Annotation *Annotable::getOrCreateAnnotation(AnnotationID ID) const { - Annotation *A = getAnnotation(ID); // Fast path, check for preexisting ann - if (A) return A; - - // No annotation found, ask the annotation manager to create an annotation... - A = AnnotationManager::createAnnotation(ID, this); - assert(A && "AnnotationManager could not create annotation!"); - addAnnotation(A); - return A; -} - -} // End namespace llvm - -#endif diff --git a/lib/Support/Annotation.cpp b/lib/Support/Annotation.cpp deleted file mode 100644 index 9f76256b295..00000000000 --- a/lib/Support/Annotation.cpp +++ /dev/null @@ -1,130 +0,0 @@ -//===-- Annotation.cpp - Implement the Annotation Classes -----------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements the AnnotationManager class. -// -//===----------------------------------------------------------------------===// - -#include "llvm/Support/Annotation.h" -#include "llvm/Support/ManagedStatic.h" -#include "llvm/System/RWMutex.h" -#include -#include -using namespace llvm; - -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; - } -} - -namespace { - class StrCmp { - public: - bool operator()(const char *a, const char *b) const { - return strcmp(a, b) < 0; - } - }; -} - -typedef std::map IDMapType; -static volatile sys::cas_flag IDCounter = 0; // Unique ID counter - -// Static member to ensure initialiation on demand. -static ManagedStatic IDMap; -static ManagedStatic > AnnotationsLock; - -// On demand annotation creation support... -typedef Annotation *(*AnnFactory)(AnnotationID, const Annotable *, void *); -typedef std::map > FactMapType; - -static ManagedStatic TheFactMap; -static FactMapType &getFactMap() { - return *TheFactMap; -} - -static void eraseFromFactMap(unsigned ID) { - sys::SmartScopedWriter Writer(*AnnotationsLock); - TheFactMap->erase(ID); -} - -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 Writer(*AnnotationsLock); - I = IDMap->find(Name); - 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); - } - return AnnotationID(I->second); -} - -// getID - Name -> ID + registration of a factory function for demand driven -// annotation support. -AnnotationID AnnotationManager::getID(const char *Name, Factory Fact, - void *Data) { - AnnotationID Result(getID(Name)); - registerAnnotationFactory(Result, Fact, Data); - return Result; -} - -// getName - This function is especially slow, but that's okay because it should -// only be used for debugging. -// -const char *AnnotationManager::getName(AnnotationID ID) { // ID -> Name - sys::SmartScopedReader 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 -// Annotable::findOrCreateAnnotation method. -// -void AnnotationManager::registerAnnotationFactory(AnnotationID ID, AnnFactory F, - void *ExtraData) { - if (F) { - sys::SmartScopedWriter Writer(*AnnotationsLock); - getFactMap()[ID.ID] = std::make_pair(F, ExtraData); - } 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) { - AnnotationsLock->reader_acquire(); - FactMapType::iterator I = getFactMap().find(ID.ID); - if (I == getFactMap().end()) { - AnnotationsLock->reader_release(); - return 0; - } - - AnnotationsLock->reader_release(); - return I->second.first(ID, Obj, I->second.second); -}