RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity

Remove Support/Options.h, it is unused

Browse Source 
It was added in 2014 in 732e0aa9fb84f1 with one use in Scalarizer.cpp.
That one use was then removed when porting to the new pass manager in
2018 in b6f76002d9158628e78.

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 4c1a1d3cf97e1ede466.

Reviewers: beanz

Differential Revision: https://reviews.llvm.org/D70280
This commit is contained in:
Reid Kleckner 2019-11-14 14:47:11 -08:00
parent ee2a5b569a
commit b83f1f8627
7 changed files with 3 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/llvm/IR/LLVMContext.h
View File

@ -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;

119
include/llvm/Support/Options.h
View File

@ -1,119 +0,0 @@
//===- 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

1
lib/Support/CMakeLists.txt
View File

@ -116,7 +116,6 @@ add_llvm_library(LLVMSupport
MD5.cpp
NativeFormatting.cpp
Optional.cpp
Options.cpp
Parallel.cpp
PluginLoader.cpp
PrettyStackTrace.cpp

1
lib/Support/DebugCounter.cpp
View File

@ -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;

32
lib/Support/Options.cpp
View File

@ -1,32 +0,0 @@
//===- llvm/Support/Options.cpp - 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
//
//===----------------------------------------------------------------------===//
//
// This file implements the helper objects for defining debug options using the
// new API built on cl::opt, but not requiring the use of static globals.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/Options.h"
#include "llvm/Support/ManagedStatic.h"
using namespace llvm;
OptionRegistry::~OptionRegistry() {
for (auto IT = Options.begin(); IT != Options.end(); ++IT)
delete IT->second;
}
void OptionRegistry::addOption(void *Key, cl::Option *O) {
assert(Options.find(Key) == Options.end() &&
"Argument with this key already registerd");
Options.insert(std::make_pair(Key, O));
}
static ManagedStatic<OptionRegistry> OR;
OptionRegistry &OptionRegistry::instance() { return *OR; }

4
lib/Support/Signals.cpp
View File

@ -15,19 +15,19 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/FileUtilities.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/FormatAdapters.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Mutex.h"
#include "llvm/Support/Program.h"
#include "llvm/Support/StringSaver.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Options.h"
#include <vector>
//===----------------------------------------------------------------------===//

2
lib/Transforms/Scalar/Scalarizer.cpp
View File

@ -38,8 +38,8 @@
#include "llvm/InitializePasses.h"
#include "llvm/Pass.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/Options.h"
#include "llvm/Transforms/Scalar.h"
#include <cassert>
#include <cstdint>