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