include/llvm/Support/Options.h

   1 //===- llvm/Support/Options.h - Debug options support -----------*- 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 /// \file
  10 /// This file declares helper objects for defining debug options that can be
  11 /// configured via the command line. The new API currently builds on the cl::opt
  12 /// API, but does not require the use of static globals.
  13 ///
  14 /// With this API options are registered during initialization. For passes, this
  15 /// happens during pass initialization. Passes with options will call a static
  16 /// registerOptions method during initialization that registers options with the
  17 /// OptionRegistry. An example implementation of registerOptions is:
  18 ///
  19 /// static void registerOptions() {
  20 ///   OptionRegistry::registerOption<bool, Scalarizer,
  21 ///                                &Scalarizer::ScalarizeLoadStore>(
  22 ///       "scalarize-load-store",
  23 ///       "Allow the scalarizer pass to scalarize loads and store", false);
  24 /// }
  25 ///
  26 /// When reading data for options the interface is via the LLVMContext. Option
  27 /// data for passes should be read from the context during doInitialization. An
  28 /// example of reading the above option would be:
  29 ///
  30 /// ScalarizeLoadStore =
  31 ///   M.getContext().getOption<bool,
  32 ///                            Scalarizer,
  33 ///                            &Scalarizer::ScalarizeLoadStore>();
  34 ///
  35 //===----------------------------------------------------------------------===//
  36
  37 #include "llvm/ADT/DenseMap.h"
  38 #include "llvm/Support/CommandLine.h"
  39
  40 namespace llvm {
  41
  42 namespace detail {
  43
  44 // Options are keyed of the unique address of a static character synthesized
  45 // based on template arguments.
  46 template <typename ValT, typename Base, ValT(Base::*Mem)> class OptionKey {
  47 public:
  48   static char ID;
  49 };
  50
  51 template <typename ValT, typename Base, ValT(Base::*Mem)>
  52 char OptionKey<ValT, Base, Mem>::ID = 0;
  53
  54 } // namespace detail
  55
  56 /// \brief Singleton class used to register debug options.
  57 ///
  58 /// The OptionRegistry is responsible for managing lifetimes of the options and
  59 /// provides interfaces for option registration and reading values from options.
  60 /// This object is a singleton, only one instance should ever exist so that all
  61 /// options are registered in teh same place.
  62 class OptionRegistry {
  63 private:
  64   DenseMap<void *, cl::Option *> Options;
  65
  66   /// \brief Adds a cl::Option to the registry.
  67   ///
  68   /// \param Key unique key for option
  69   /// \param O option to map to \p Key
  70   ///
  71   /// Allocated cl::Options are owened by the OptionRegistry and are deallocated
  72   /// on destruction or removal
  73   void addOption(void *Key, cl::Option *O);
  74
  75 public:
  76   ~OptionRegistry();
  77   OptionRegistry() {}
  78
  79   /// \brief Returns a reference to the singleton instance.
  80   static OptionRegistry &instance();
  81
  82   /// \brief Registers an option with the OptionRegistry singleton.
  83   ///
  84   /// \param ValT type of the option's data
  85   /// \param Base class used to key the option
  86   /// \param Mem member of \p Base used for keying the option
  87   ///
  88   /// Options are keyed off the template parameters to generate unique static
  89   /// characters. The template parameters are (1) the type of the data the
  90   /// option stores (\p ValT), the class that will read the option (\p Base),
  91   /// and the memeber that the class will store the data into (\p Mem).
  92   template <typename ValT, typename Base, ValT(Base::*Mem)>
  93   static void registerOption(const char *ArgStr, const char *Desc,
  94                              const ValT &InitValue) {
  95     cl::opt<ValT> *Option = new cl::opt<ValT>(ArgStr, cl::desc(Desc),
  96                                               cl::Hidden, cl::init(InitValue));
  97     instance().addOption(&detail::OptionKey<ValT, Base, Mem>::ID, Option);
  98   }
  99
 100   /// \brief Returns the value of the option.
 101   ///
 102   /// \param ValT type of the option's data
 103   /// \param Base class used to key the option
 104   /// \param Mem member of \p Base used for keying the option
 105   ///
 106   /// Reads option values based on the key generated by the template parameters.
 107   /// Keying for get() is the same as keying for registerOption.
 108   template <typename ValT, typename Base, ValT(Base::*Mem)> ValT get() const {
 109     auto It = Options.find(&detail::OptionKey<ValT, Base, Mem>::ID);
 110     assert(It != Options.end() && "Option not in OptionRegistry");
 111     return *(cl::opt<ValT> *)It->second;
 112   }
 113 };
 114
 115 } // namespace llvm