1//=== Registry.h - Linker-supported plugin registries -----------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// Defines a registry template for discovering pluggable modules.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_SUPPORT_REGISTRY_H
15#define LLVM_SUPPORT_REGISTRY_H
16
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/ADT/iterator_range.h"
20#include "llvm/Support/Compiler.h"
21#include "llvm/Support/DynamicLibrary.h"
22#include <memory>
23
24namespace llvm {
25  /// A simple registry entry which provides only a name, description, and
26  /// no-argument constructor.
27  template <typename T>
28  class SimpleRegistryEntry {
29    StringRef Name, Desc;
30    std::unique_ptr<T> (*Ctor)();
31
32  public:
33    SimpleRegistryEntry(StringRef N, StringRef D, std::unique_ptr<T> (*C)())
34        : Name(N), Desc(D), Ctor(C) {}
35
36    StringRef getName() const { return Name; }
37    StringRef getDesc() const { return Desc; }
38    std::unique_ptr<T> instantiate() const { return Ctor(); }
39  };
40
41  /// A global registry used in conjunction with static constructors to make
42  /// pluggable components (like targets or garbage collectors) "just work" when
43  /// linked with an executable.
44  template <typename T>
45  class Registry {
46  public:
47    typedef T type;
48    typedef SimpleRegistryEntry<T> entry;
49
50    class node;
51    class iterator;
52
53  private:
54    Registry() = delete;
55
56    friend class node;
57    static node *Head, *Tail;
58
59  public:
60    /// Node in linked list of entries.
61    ///
62    class node {
63      friend class iterator;
64      friend Registry<T>;
65
66      node *Next;
67      const entry& Val;
68
69    public:
70      node(const entry &V) : Next(nullptr), Val(V) {}
71    };
72
73    /// Add a node to the Registry: this is the interface between the plugin and
74    /// the executable.
75    ///
76    /// This function is exported by the executable and called by the plugin to
77    /// add a node to the executable's registry. Therefore it's not defined here
78    /// to avoid it being instantiated in the plugin and is instead defined in
79    /// the executable (see LLVM_INSTANTIATE_REGISTRY below).
80    static void add_node(node *N);
81
82    /// Iterators for registry entries.
83    ///
84    class iterator {
85      const node *Cur;
86
87    public:
88      explicit iterator(const node *N) : Cur(N) {}
89
90      bool operator==(const iterator &That) const { return Cur == That.Cur; }
91      bool operator!=(const iterator &That) const { return Cur != That.Cur; }
92      iterator &operator++() { Cur = Cur->Next; return *this; }
93      const entry &operator*() const { return Cur->Val; }
94      const entry *operator->() const { return &Cur->Val; }
95    };
96
97    // begin is not defined here in order to avoid usage of an undefined static
98    // data member, instead it's instantiated by LLVM_INSTANTIATE_REGISTRY.
99    static iterator begin();
100    static iterator end()   { return iterator(nullptr); }
101
102    static iterator_range<iterator> entries() {
103      return make_range(begin(), end());
104    }
105
106    /// A static registration template. Use like such:
107    ///
108    ///   Registry<Collector>::Add<FancyGC>
109    ///   X("fancy-gc", "Newfangled garbage collector.");
110    ///
111    /// Use of this template requires that:
112    ///
113    ///  1. The registered subclass has a default constructor.
114    template <typename V>
115    class Add {
116      entry Entry;
117      node Node;
118
119      static std::unique_ptr<T> CtorFn() { return make_unique<V>(); }
120
121    public:
122      Add(StringRef Name, StringRef Desc)
123          : Entry(Name, Desc, CtorFn), Node(Entry) {
124        add_node(&Node);
125      }
126    };
127  };
128} // end namespace llvm
129
130/// Instantiate a registry class.
131///
132/// This provides template definitions of add_node, begin, and the Head and Tail
133/// pointers, then explicitly instantiates them. We could explicitly specialize
134/// them, instead of the two-step process of define then instantiate, but
135/// strictly speaking that's not allowed by the C++ standard (we would need to
136/// have explicit specialization declarations in all translation units where the
137/// specialization is used) so we don't.
138#define LLVM_INSTANTIATE_REGISTRY(REGISTRY_CLASS) \
139  namespace llvm { \
140  template<typename T> typename Registry<T>::node *Registry<T>::Head = nullptr;\
141  template<typename T> typename Registry<T>::node *Registry<T>::Tail = nullptr;\
142  template<typename T> \
143  void Registry<T>::add_node(typename Registry<T>::node *N) { \
144    if (Tail) \
145      Tail->Next = N; \
146    else \
147      Head = N; \
148    Tail = N; \
149  } \
150  template<typename T> typename Registry<T>::iterator Registry<T>::begin() { \
151    return iterator(Head); \
152  } \
153  template REGISTRY_CLASS::node *Registry<REGISTRY_CLASS::type>::Head; \
154  template REGISTRY_CLASS::node *Registry<REGISTRY_CLASS::type>::Tail; \
155  template \
156  void Registry<REGISTRY_CLASS::type>::add_node(REGISTRY_CLASS::node*); \
157  template REGISTRY_CLASS::iterator Registry<REGISTRY_CLASS::type>::begin(); \
158  }
159
160#endif // LLVM_SUPPORT_REGISTRY_H
161