My previous Registry.h header, as well as Collectors.h, which is the

registry for dynamically-loaded garbage collection compiler plugins.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42415 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Gordon Henriksen 2007-09-27 19:34:27 +00:00
parent 326e24fff0
commit d9900c9442
3 changed files with 300 additions and 0 deletions

View File

@ -0,0 +1,36 @@
//===-- Collectors.h - Garbage collector registry -------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Gordon Henriksen and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the CollectorRegistry class, which is used to discover
// pluggable garbage collectors.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_COLLECTORS_H
#define LLVM_CODEGEN_COLLECTORS_H
#include "llvm/Support/Registry.h"
namespace llvm {
class Collector;
/// The collector registry uses all the defaults from Registry.
///
typedef Registry<Collector> CollectorRegistry;
/// Creates an ocaml-compatible garbage collector.
Collector *createOcamlCollector();
/// Creates a shadow stack garbage collector. This collector requires no code
/// generator support.
Collector *createShadowStackCollector();
}
#endif

View File

@ -0,0 +1,243 @@
//=== Registry.h - Linker-supported plugin registries -----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Gordon Henriksen and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Defines a registry template for discovering pluggable modules.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_REGISTRY_H
#define LLVM_SUPPORT_REGISTRY_H
#include "llvm/Support/CommandLine.h"
namespace llvm {
/// A simple registry entry which provides only a name, description, and
/// no-argument constructor.
template <typename T>
class SimpleRegistryEntry {
const char *Name, *Desc;
T *(*Ctor)();
public:
SimpleRegistryEntry(const char *N, const char *D, T *(*C)())
: Name(N), Desc(D), Ctor(C)
{}
const char *getName() const { return Name; }
const char *getDesc() const { return Desc; }
T *instantiate() const { return Ctor(); }
};
/// Traits for registry entries. If using other than SimpleRegistryEntry, it
/// is necessary to define an alternate traits class.
template <typename T>
class RegistryTraits {
RegistryTraits(); // Do not implement.
public:
typedef SimpleRegistryEntry<T> entry;
/// Accessors for .
///
static const char *nameof(const entry &Entry) { return Entry.getName(); }
static const char *descof(const entry &Entry) { return Entry.getDesc(); }
};
/// A global registry used in conjunction with static constructors to make
/// pluggable components (like targets or garbage collectors) "just work" when
/// linked with an executable.
template <typename T, typename U = RegistryTraits<T> >
class Registry {
public:
typedef U traits;
typedef typename U::entry entry;
class node;
class listener;
class iterator;
private:
Registry(); // Do not implement.
static void Announce(node *);
friend class node;
static node *Head, *Tail;
friend class listener;
static listener *ListenerHead, *ListenerTail;
public:
class iterator;
/// Node in linked list of entries.
///
class node {
friend class iterator;
node *Next;
const entry& Val;
public:
node(const entry& V) : Next(0), Val(V) {
if (Tail)
Tail->Next = this;
else
Head = this;
Tail = this;
Announce(V);
}
};
/// Iterators for registry entries.
///
class iterator {
const node *Cur;
public:
explicit iterator(const node *N) : Cur(N) {}
bool operator==(const iterator &That) const { return Cur == That.Cur; }
bool operator!=(const iterator &That) const { return Cur != That.Cur; }
iterator &operator++() { Cur = Cur->Next; return *this; }
const entry &operator*() const { return Cur->Val; }
const entry *operator->() const { return &Cur->Val; }
};
static iterator begin() { return iterator(Head); }
static iterator end() { return iterator(0); }
/// Abstract base class for registry listeners, which are informed when new
/// entries are added to the registry. Simply subclass and instantiate:
///
/// class CollectorPrinter : public Registry<Collector>::listener {
/// protected:
/// void registered(const Registry<Collector>::entry &e) {
/// cerr << "collector now available: " << e->getName() << "\n";
/// }
///
/// public:
/// CollectorPrinter() { init(); } // Print those already registered.
/// };
///
/// CollectorPrinter Printer;
///
class listener {
listener *Prev, *Next;
friend void Registry::Announce(const entry &E);
protected:
/// Called when an entry is added to the registry.
///
virtual void registered(const entry &) = 0;
/// Calls 'registered' for each pre-existing entry.
///
void init() {
for (iterator I = begin(), E = end(); I != E; ++I)
registered(*I);
}
public:
listener() : Prev(ListenerTail), Next(0) {
if (Prev)
Prev->Next = this;
else
ListenerHead = this;
ListenerTail = this;
}
virtual ~listener() {
if (Next)
Next->Prev = Prev;
else
ListenerTail = Prev;
if (Prev)
Prev->Next = Next;
else
ListenerHead = Next;
}
};
/// A static registration template. Use like such:
///
/// Registry<Collector>::Add<FancyGC>
/// X("fancy-gc", "Newfangled garbage collector.");
///
/// Use of this template requires that:
///
/// 1. The registered subclass has a default constructor.
//
/// 2. The registry entry type has a constructor compatible with this
/// signature:
///
/// entry(const char *Name, const char *ShortDesc, T *(*Ctor)());
///
/// If you have more elaborate requirements, then copy and modify.
///
template <typename V>
class Add {
entry Entry;
node Node;
static T *CtorFn() { return new V(); }
public:
Add(const char *Name, const char *Desc)
: Entry(Name, Desc, CtorFn), Node(Entry) {}
};
/// A command-line parser for a registry. Use like such:
///
/// static cl::opt<Registry<Collector>::entry, false,
/// Registry<Collector>::Parser>
/// GCOpt("gc", cl::desc("Garbage collector to use."),
/// cl::value_desc());
///
/// To make use of the value:
///
/// Collector *TheCollector = GCOpt->instantiate();
///
class Parser : public cl::parser<const typename U::entry*>, public listener{
typedef U traits;
typedef typename U::entry entry;
protected:
void registered(const entry &E) {
addLiteralOption(traits::nameof(E), &E, traits::descof(E));
}
public:
void initialize(cl::Option &O) {
listener::init();
cl::parser<const typename U::entry*>::initialize(O);
}
};
private:
static void Announce(const entry &E) {
for (listener *Cur = ListenerHead; Cur; Cur = Cur->Next)
Cur->registered(E);
}
};
}
#endif

View File

@ -0,0 +1,21 @@
//===-- Collectors.cpp - Garbage collector registry -----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Gordon Henriksen and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the static data members of the CollectorRegistry class.
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/Collectors.h"
using namespace llvm;
template<> CollectorRegistry::node *CollectorRegistry::Head = 0;
template<> CollectorRegistry::node *CollectorRegistry::Tail = 0;
template<> CollectorRegistry::listener *CollectorRegistry::ListenerHead = 0;
template<> CollectorRegistry::listener *CollectorRegistry::ListenerTail = 0;