include/llvm/CodeGen/MachinePassRegistry.h

   1 //===-- llvm/CodeGen/MachinePassRegistry.h ----------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_CODEGEN_MACHINEPASSREGISTRY_H
  11 #define LLVM_CODEGEN_MACHINEPASSREGISTRY_H
  12
  13 #include "llvm/CodeGen/Passes.h"
  14 #include "llvm/CodeGen/ScheduleDAG.h"
  15 #include "llvm/Support/CommandLine.h"
  16
  17 #include <iostream>
  18
  19 namespace llvm {
  20
  21
  22 //===----------------------------------------------------------------------===//
  23 ///
  24 /// MachinePassRegistryListener - Listener to adds and removals of nodes in
  25 /// registration list.
  26 ///
  27 //===----------------------------------------------------------------------===//
  28 class MachinePassRegistryListener {
  29 public:
  30   MachinePassRegistryListener() {}
  31   virtual ~MachinePassRegistryListener() {}
  32   virtual void NotifyAdd(const char *N, const char *D) = 0;
  33   virtual void NotifyRemove(const char *N, const char *D) = 0;
  34 };
  35
  36
  37 //===----------------------------------------------------------------------===//
  38 ///
  39 /// MachinePassRegistryNode - Machine pass node stored in registration list.
  40 ///
  41 //===----------------------------------------------------------------------===//
  42 template<typename FunctionPassCtor>
  43 class MachinePassRegistryNode {
  44
  45 private:
  46
  47   MachinePassRegistryNode<FunctionPassCtor> *Next;// Next function pass in list.
  48   const char *Name;                     // Name of function pass.
  49   const char *Description;              // Description string.
  50   FunctionPassCtor Ctor;                // Function pass creator.
  51
  52 public:
  53
  54   MachinePassRegistryNode(const char *N, const char *D, FunctionPassCtor C)
  55   : Next(NULL)
  56   , Name(N)
  57   , Description(D)
  58   , Ctor(C)
  59   {}
  60
  61   // Accessors
  62   MachinePassRegistryNode<FunctionPassCtor> *getNext()
  63                                           const { return Next; }
  64   MachinePassRegistryNode<FunctionPassCtor> **getNextAddress()
  65                                                 { return &Next; }
  66   const char *getName()                   const { return Name; }
  67   const char *getDescription()            const { return Description; }
  68   FunctionPassCtor getCtor()              const { return Ctor; }
  69   void setNext(MachinePassRegistryNode<FunctionPassCtor> *N) { Next = N; }
  70
  71 };
  72
  73
  74 //===----------------------------------------------------------------------===//
  75 ///
  76 /// MachinePassRegistry - Track the registration of machine passes.
  77 ///
  78 //===----------------------------------------------------------------------===//
  79 template<typename FunctionPassCtor>
  80 class MachinePassRegistry {
  81
  82 private:
  83
  84   MachinePassRegistryNode<FunctionPassCtor> *List;
  85                                         // List of registry nodes.
  86   FunctionPassCtor Cache;               // Cached function pass creator.
  87   MachinePassRegistryListener* Listener;// Listener for list adds are removes.
  88
  89 public:
  90
  91   // NO CONSTRUCTOR - we don't want static constructor ordering to mess
  92   // with the registry.
  93
  94   // Accessors.
  95   //
  96   MachinePassRegistryNode<FunctionPassCtor> *getList()  { return List; }
  97   FunctionPassCtor getCache()                           { return Cache; }
  98   void setCache(FunctionPassCtor C)                     { Cache = C; }
  99   void setListener(MachinePassRegistryListener *L)      { Listener = L; }
 100
 101   /// Add - Adds a function pass to the registration list.
 102   ///
 103  void Add(MachinePassRegistryNode<FunctionPassCtor> *Node) {
 104     Node->setNext(List);
 105     List = Node;
 106     if (Listener) Listener->NotifyAdd(Node->getName(), Node->getDescription());
 107   }
 108
 109
 110   /// Remove - Removes a function pass from the registration list.
 111   ///
 112   void Remove(MachinePassRegistryNode<FunctionPassCtor> *Node) {
 113     for (MachinePassRegistryNode<FunctionPassCtor> **I = &List;
 114          *I; I = (*I)->getNextAddress()) {
 115       if (*I == Node) {
 116 #if 0 // FIXME: Command opt needs to call a termination routine.
 117         if (Listener) Listener->NotifyRemove(Node->getName(),
 118                                              Node->getDescription());
 119 #endif
 120         *I = (*I)->getNext();
 121         break;
 122       }
 123     }
 124   }
 125
 126
 127   /// FInd - Finds and returns a function pass in registration list, otherwise
 128   /// returns NULL.
 129   MachinePassRegistryNode<FunctionPassCtor> *Find(const char *Name) {
 130     for (MachinePassRegistryNode<FunctionPassCtor> *I = List;
 131          I; I = I->getNext()) {
 132       if (std::string(Name) == std::string(I->getName())) return I;
 133     }
 134     return NULL;
 135   }
 136
 137
 138 };
 139
 140
 141 //===----------------------------------------------------------------------===//
 142 ///
 143 /// RegisterRegAlloc class - Track the registration of register allocators.
 144 ///
 145 //===----------------------------------------------------------------------===//
 146 class RegisterRegAlloc : public MachinePassRegistryNode<FunctionPass *(*)()> {
 147
 148 public:
 149
 150   typedef FunctionPass *(*FunctionPassCtor)();
 151
 152   static MachinePassRegistry<FunctionPassCtor> Registry;
 153
 154   RegisterRegAlloc(const char *N, const char *D, FunctionPassCtor C)
 155   : MachinePassRegistryNode<FunctionPassCtor>(N, D, C)
 156   { Registry.Add(this); }
 157   ~RegisterRegAlloc() { Registry.Remove(this); }
 158
 159
 160   // Accessors.
 161   //
 162   RegisterRegAlloc *getNext() const {
 163     return (RegisterRegAlloc *)
 164            MachinePassRegistryNode<FunctionPassCtor>::getNext();
 165   }
 166   static RegisterRegAlloc *getList() {
 167     return (RegisterRegAlloc *)Registry.getList();
 168   }
 169   static FunctionPassCtor getCache() {
 170     return Registry.getCache();
 171   }
 172   static void setCache(FunctionPassCtor C) {
 173     Registry.setCache(C);
 174   }
 175   static void setListener(MachinePassRegistryListener *L) {
 176     Registry.setListener(L);
 177   }
 178
 179
 180   /// FirstCtor - Finds the first register allocator in registration
 181   /// list and returns its creator function, otherwise return NULL.
 182   static FunctionPassCtor FirstCtor() {
 183     MachinePassRegistryNode<FunctionPassCtor> *Node = Registry.getList();
 184     return Node ? Node->getCtor() : NULL;
 185   }
 186
 187   /// FindCtor - Finds a register allocator in registration list and returns
 188   /// its creator function, otherwise return NULL.
 189   static FunctionPassCtor FindCtor(const char *N) {
 190     MachinePassRegistryNode<FunctionPassCtor> *Node = Registry.Find(N);
 191     return Node ? Node->getCtor() : NULL;
 192   }
 193
 194 };
 195
 196
 197 //===----------------------------------------------------------------------===//
 198 ///
 199 /// RegisterScheduler class - Track the registration of instruction schedulers.
 200 ///
 201 //===----------------------------------------------------------------------===//
 202
 203 class ScheduleDAG;
 204 class SelectionDAG;
 205 class MachineBasicBlock;
 206
 207 class RegisterScheduler : public
 208   MachinePassRegistryNode<ScheduleDAG *(*)(SelectionDAG*, MachineBasicBlock*)> {
 209
 210 public:
 211
 212   typedef ScheduleDAG *(*FunctionPassCtor)(SelectionDAG*, MachineBasicBlock*);
 213
 214   static MachinePassRegistry<FunctionPassCtor> Registry;
 215
 216   RegisterScheduler(const char *N, const char *D, FunctionPassCtor C)
 217   : MachinePassRegistryNode<FunctionPassCtor>(N, D, C)
 218   { Registry.Add(this); }
 219   ~RegisterScheduler() { Registry.Remove(this); }
 220
 221
 222   // Accessors.
 223   //
 224   RegisterScheduler *getNext() const {
 225     return (RegisterScheduler *)
 226            MachinePassRegistryNode<FunctionPassCtor>::getNext();
 227   }
 228   static RegisterScheduler *getList() {
 229     return (RegisterScheduler *)Registry.getList();
 230   }
 231   static FunctionPassCtor getCache() {
 232     return Registry.getCache();
 233   }
 234   static void setCache(FunctionPassCtor C) {
 235     Registry.setCache(C);
 236   }
 237   static void setListener(MachinePassRegistryListener *L) {
 238     Registry.setListener(L);
 239   }
 240
 241
 242   /// FirstCtor - Finds the first instruction scheduler in registration
 243   /// list and returns its creator function, otherwise return NULL.
 244   static FunctionPassCtor FirstCtor() {
 245     MachinePassRegistryNode<FunctionPassCtor> *Node = Registry.getList();
 246     return Node ? Node->getCtor() : NULL;
 247   }
 248
 249
 250   /// FindCtor - Finds a instruction scheduler in registration list and returns
 251   /// its creator function, otherwise return NULL.
 252   static FunctionPassCtor FindCtor(const char *N) {
 253     MachinePassRegistryNode<FunctionPassCtor> *Node = Registry.Find(N);
 254     return Node ? Node->getCtor() : NULL;
 255   }
 256
 257 };
 258
 259
 260 //===----------------------------------------------------------------------===//
 261 ///
 262 /// RegisterPassParser class - Handle the addition of new machine passes.
 263 ///
 264 //===----------------------------------------------------------------------===//
 265 template<class RegistryClass>
 266 class RegisterPassParser : public MachinePassRegistryListener,
 267                            public cl::parser<const char *> {
 268 public:
 269   RegisterPassParser() {}
 270
 271   void initialize(cl::Option &O) {
 272     cl::parser<const char *>::initialize(O);
 273
 274     // Add existing passes to option.
 275     for (RegistryClass *Node = RegistryClass::getList();
 276          Node; Node = Node->getNext()) {
 277       addLiteralOption(Node->getName(), Node->getName(),
 278                        Node->getDescription());
 279     }
 280
 281     // Make sure we listen for list changes.
 282     RegistryClass::setListener(this);
 283   }
 284
 285   // Implement the MachinePassRegistryListener callbacks.
 286   //
 287   virtual void NotifyAdd(const char *N, const char *D) {
 288     addLiteralOption(N, N, D);
 289   }
 290   virtual void NotifyRemove(const char *N, const char *D) {
 291     removeLiteralOption(N);
 292   }
 293
 294   // ValLessThan - Provide a sorting comparator for Values elements...
 295   typedef std::pair<const char*, std::pair<const char*, const char*> > ValType;
 296   static bool ValLessThan(const ValType &VT1, const ValType &VT2) {
 297     return std::string(VT1.first) < std::string(VT2.first);
 298   }
 299
 300   // printOptionInfo - Print out information about this option.  Override the
 301   // default implementation to sort the table before we print...
 302   virtual void printOptionInfo(const cl::Option &O, unsigned GlobalWidth) const{
 303     RegisterPassParser *PNP = const_cast<RegisterPassParser*>(this);
 304     std::sort(PNP->Values.begin(), PNP->Values.end(), ValLessThan);
 305     cl::parser<const char *>::printOptionInfo(O, GlobalWidth);
 306   }
 307 };
 308
 309
 310 } // end namespace llvm
 311
 312 #endif