Commit 631be5c0 authored by Reid Kleckner's avatar Reid Kleckner
Browse files

Remove Support/Options.h, it is unused 

It was added in 2014 in 732e0aa9 with one use in Scalarizer.cpp.
That one use was then removed when porting to the new pass manager in
2018 in b6f76002.

While the RFC and the desire to get off of static initializers for
cl::opt all still stand, this code is now dead, and I think we should
delete this code until someone is ready to do the migration.

There were many clients of CommandLine.h that were it transitively
through LLVMContext.h, so I cleaned that up in 4c1a1d3c.

Reviewers: beanz

Differential Revision: https://reviews.llvm.org/D70280
parent caf3166d

clang/tools/clang-scan-deps/ClangScanDeps.cpp

+1 −1
Original line number Diff line number Diff line
@@ -12,8 +12,8 @@ 
#include "clang/Tooling/DependencyScanning/DependencyScanningTool.h"

#include "clang/Tooling/DependencyScanning/DependencyScanningWorker.h"

#include "clang/Tooling/JSONCompilationDatabase.h"

#include "llvm/Support/CommandLine.h"

#include "llvm/Support/InitLLVM.h"

#include "llvm/Support/Options.h"

#include "llvm/Support/Program.h"

#include "llvm/Support/Signals.h"

#include "llvm/Support/Threading.h"

llvm/include/llvm/IR/LLVMContext.h

+0 −9
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 
#include "llvm-c/Types.h"

#include "llvm/IR/DiagnosticHandler.h"

#include "llvm/Support/CBindingWrapping.h"

#include "llvm/Support/Options.h"

#include <cstdint>

#include <memory>

#include <string>
@@ -288,14 +287,6 @@ public: 
  void emitError(const Instruction *I, const Twine &ErrorStr);

  void emitError(const Twine &ErrorStr);



  /// Query for a debug option's value.

  ///

  /// This function returns typed data populated from command line parsing.

  template <typename ValT, typename Base, ValT(Base::*Mem)>

  ValT getOption() const {

    return OptionRegistry::instance().template get<ValT, Base, Mem>();

  }



  /// Access the object which can disable optional passes and individual

  /// optimizations at compile time.

  OptPassGate &getOptPassGate() const;

llvm/include/llvm/Support/Options.h

deleted100644 → 0
+0 −119
Original line number Diff line number Diff line 
//===- llvm/Support/Options.h - Debug options support -----------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

/// \file

/// This file declares helper objects for defining debug options that can be

/// configured via the command line. The new API currently builds on the cl::opt

/// API, but does not require the use of static globals.

///

/// With this API options are registered during initialization. For passes, this

/// happens during pass initialization. Passes with options will call a static

/// registerOptions method during initialization that registers options with the

/// OptionRegistry. An example implementation of registerOptions is:

///

/// static void registerOptions() {

///   OptionRegistry::registerOption<bool, Scalarizer,

///                                &Scalarizer::ScalarizeLoadStore>(

///       "scalarize-load-store",

///       "Allow the scalarizer pass to scalarize loads and store", false);

/// }

///

/// When reading data for options the interface is via the LLVMContext. Option

/// data for passes should be read from the context during doInitialization. An

/// example of reading the above option would be:

///

/// ScalarizeLoadStore =

///   M.getContext().getOption<bool,

///                            Scalarizer,

///                            &Scalarizer::ScalarizeLoadStore>();

///

//===----------------------------------------------------------------------===//



#ifndef LLVM_SUPPORT_OPTIONS_H

#define LLVM_SUPPORT_OPTIONS_H



#include "llvm/ADT/DenseMap.h"

#include "llvm/Support/CommandLine.h"



namespace llvm {



namespace detail {



// Options are keyed of the unique address of a static character synthesized

// based on template arguments.

template <typename ValT, typename Base, ValT(Base::*Mem)> class OptionKey {

public:

  static char ID;

};



template <typename ValT, typename Base, ValT(Base::*Mem)>

char OptionKey<ValT, Base, Mem>::ID = 0;



} // namespace detail



/// Singleton class used to register debug options.

///

/// The OptionRegistry is responsible for managing lifetimes of the options and

/// provides interfaces for option registration and reading values from options.

/// This object is a singleton, only one instance should ever exist so that all

/// options are registered in the same place.

class OptionRegistry {

private:

  DenseMap<void *, cl::Option *> Options;



  /// Adds a cl::Option to the registry.

  ///

  /// \param Key unique key for option

  /// \param O option to map to \p Key

  ///

  /// Allocated cl::Options are owned by the OptionRegistry and are deallocated

  /// on destruction or removal

  void addOption(void *Key, cl::Option *O);



public:

  ~OptionRegistry();

  OptionRegistry() {}



  /// Returns a reference to the singleton instance.

  static OptionRegistry &instance();



  /// Registers an option with the OptionRegistry singleton.

  ///

  /// \tparam ValT type of the option's data

  /// \tparam Base class used to key the option

  /// \tparam Mem member of \p Base used for keying the option

  ///

  /// Options are keyed off the template parameters to generate unique static

  /// characters. The template parameters are (1) the type of the data the

  /// option stores (\p ValT), the class that will read the option (\p Base),

  /// and the member that the class will store the data into (\p Mem).

  template <typename ValT, typename Base, ValT(Base::*Mem)>

  static void registerOption(StringRef ArgStr, StringRef Desc,

                             const ValT &InitValue) {

    cl::opt<ValT> *Option = new cl::opt<ValT>(ArgStr, cl::desc(Desc),

                                              cl::Hidden, cl::init(InitValue));

    instance().addOption(&detail::OptionKey<ValT, Base, Mem>::ID, Option);

  }



  /// Returns the value of the option.

  ///

  /// \tparam ValT type of the option's data

  /// \tparam Base class used to key the option

  /// \tparam Mem member of \p Base used for keying the option

  ///

  /// Reads option values based on the key generated by the template parameters.

  /// Keying for get() is the same as keying for registerOption.

  template <typename ValT, typename Base, ValT(Base::*Mem)> ValT get() const {

    auto It = Options.find(&detail::OptionKey<ValT, Base, Mem>::ID);

    assert(It != Options.end() && "Option not in OptionRegistry");

    return *(cl::opt<ValT> *)It->second;

  }

};



} // namespace llvm



#endif

llvm/lib/Support/CMakeLists.txt

+0 −1
Original line number Diff line number Diff line
@@ -116,7 +116,6 @@ add_llvm_library(LLVMSupport 
  MD5.cpp

  NativeFormatting.cpp

  Optional.cpp

  Options.cpp

  Parallel.cpp

  PluginLoader.cpp

  PrettyStackTrace.cpp

llvm/lib/Support/DebugCounter.cpp

+0 −1
Original line number Diff line number Diff line
@@ -2,7 +2,6 @@ 
#include "llvm/Support/CommandLine.h"

#include "llvm/Support/Format.h"

#include "llvm/Support/ManagedStatic.h"

#include "llvm/Support/Options.h"



using namespace llvm;