We need an OptionStore abstraction for storing debug option data.

[beanz]

Summary

The plan was to have the LLVMContext store option data with the new API and not have this abstraction. Unfortunately as I've begin playing with this that isn't possible.

Not having this abstraction actually means we can't parse command line options directly into their storage because LLVMParseCommandLine will never be able to take an LLVMContext as a parameter-- and it shouldn't.

Having the command line parsing code parse into an LLVMContext would mean libLLVMSupport depending on libLLVMCore, which would be a nasty circular dependency. To prevent that we need an abstraction that can be passed into LLVMParseCommandLine, and can be used by libLLVMSupport without requiring libLLVMCore.

[chandlerc]

Based on IRC conversations, my impression is this isn't quite the direction being pursued... But can revisit if needed.

include/llvm/IR/LLVMContext.h

 class Twine;
 class Instruction;
 class Module;
 class SMDiagnostic;
 class DiagnosticInfo;
 template <typename T> class SmallVectorImpl;
 class Function;
 class DebugLoc;
+class OptionStore;
 
 /// This is an important class for using LLVM in a threaded context.  It
 /// (opaquely) owns and manages the core "global" data of LLVM's core
 /// infrastructure, including the type and constant uniquing tables.
 /// LLVMContext itself provides no locking guarantees, so you should be careful
 /// to have one context per thread.
 class LLVMContext {
 public:
public:
   /// with optional location information.  This function returns, so code should
   /// be prepared to drop the erroneous construct on the floor and "not crash".
   /// The generated code need not be correct.  The error message will be
   /// implicitly prefixed with "error: " and should not end with a ".".
   void emitError(unsigned LocCookie, const Twine &ErrorStr);
   void emitError(const Instruction *I, const Twine &ErrorStr);
   void emitError(const Twine &ErrorStr);
 
-  /// \brief 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>();
-  }
+  /// \brief Query for a debug option storage object.
+  OptionStore& getOptionStore();
 
 private:
   LLVMContext(LLVMContext&) LLVM_DELETED_FUNCTION;
   void operator=(LLVMContext&) LLVM_DELETED_FUNCTION;
 
   /// addModule - Register a module as being instantiated in this context.  If
   /// the context is deleted, the module will be deleted as well.
   void addModule(Module*);

include/llvm/Support/OptionStore.h

+//===- llvm/Support/OptionStore.h - Debug options support -------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// This file declares the OptionStore class used for storing parsed option data
+/// for debug options registered with the new debug option API. For more
+/// information on the new API see llvm/Support/Options.h
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPTION_OPTIONSTORE_H
+#define LLVM_OPTION_OPTIONSTORE_H
+
+#include "llvm/Support/Options.h"
+
+namespace llvm {
+
+
+/// \brief This is a stub class for accessing debug options
+///
+/// The OptionStore is populated by parsing command line options and reading
+/// the default values of non-specified options. This abstraction is required
+/// because libSupport can't store data directly into LLVMContext objects. The
+/// current implementation in this file is just a stub to prototype the client
+/// visible API.
+class OptionStore {
+
+public:
+  /// \brief 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>();
+  }
+};
+
+} // namespace llvm
+
+#endif

lib/IR/LLVMContext.cpp

 /// getHandlerNames - Populate client supplied smallvector using custome
 /// metadata name and ID.
 void LLVMContext::getMDKindNames(SmallVectorImpl<StringRef> &Names) const {
   Names.resize(pImpl->CustomMDKindNames.size());
   for (StringMap<unsigned>::const_iterator I = pImpl->CustomMDKindNames.begin(),
        E = pImpl->CustomMDKindNames.end(); I != E; ++I)
     Names[I->second] = I->first();
 }
+
+OptionStore& LLVMContext::getOptionStore() {
+  return pImpl->OptionData;
+}

lib/IR/LLVMContextImpl.h

 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/ValueHandle.h"
+#include "llvm/Support/OptionStore.h"
 #include <vector>
 
 namespace llvm {
 
 class ConstantInt;
 class ConstantFP;
 class DiagnosticInfoOptimizationRemark;
 class DiagnosticInfoOptimizationRemarkMissed;
public:
   typedef DenseMap<const Function*, unsigned> IntrinsicIDCacheTy;
   IntrinsicIDCacheTy IntrinsicIDCache;
 
   /// \brief Mapping from a function to its prefix data, which is stored as the
   /// operand of an unparented ReturnInst so that the prefix data has a Use.
   typedef DenseMap<const Function *, ReturnInst *> PrefixDataMapTy;
   PrefixDataMapTy PrefixDataMap;
 
+  /// \brief OptionStore object that maintains a local copy of typed debug
+  /// option values.
+  OptionStore OptionData;
+
   int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
   int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
   
   LLVMContextImpl(LLVMContext &C);
   ~LLVMContextImpl();
 };
 
 }
 
 #endif

lib/Transforms/Scalar/Scalarizer.cpp

 // may also be useful for revectorizing code to different vector widths.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/Pass.h"
-#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/OptionStore.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "scalarizer"
 
 namespace {
Value *Scatterer::operator[](unsigned I) {
   }
   return CV[I];
 }
 
 bool Scalarizer::doInitialization(Module &M) {
   ParallelLoopAccessMDKind =
       M.getContext().getMDKindID("llvm.mem.parallel_loop_access");
   ScalarizeLoadStore =
-      M.getContext().getOption<bool, Scalarizer, &Scalarizer::ScalarizeLoadStore>();
+      M.getContext()
+          .getOptionStore()
+          .getOption<bool, Scalarizer, &Scalarizer::ScalarizeLoadStore>();
   return false;
 }
 
 bool Scalarizer::runOnFunction(Function &F) {
   DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
   DL = DLP ? &DLP->getDataLayout() : nullptr;
   for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI) {
     BasicBlock *BB = BBI;