Adds accessor methods to class ClFlags.

src/IceClFlags.h

 //===- subzero/src/IceClFlags.h - Cl Flags for translation ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares command line flags controlling translation.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICECLFLAGS_H
 #define SUBZERO_SRC_ICECLFLAGS_H
 
 #include "IceTypes.def"
 
 namespace Ice {
 
 class ClFlags {

[Jim Stichnoth, 2015/02/05 22:30:09]

Since this is becoming a proper class, disable default copy ctor and assignment
operator.

[Karl, 2015/02/05 23:57:38]

Done.

 public:
   ClFlags()
       : DisableInternal(false), SubzeroTimingEnabled(false),
         DisableTranslation(false), FunctionSections(false), DataSections(false),
         UseELFWriter(false), UseIntegratedAssembler(false),
         UseSandboxing(false), PhiEdgeSplit(false), DecorateAsm(false),
         DumpStats(false), AllowUninitializedGlobals(false),
         TimeEachFunction(false), DisableIRGeneration(false),
         AllowErrorRecovery(false), StubConstantCalls(false),
         GenerateUnitTestMessages(false), NumTranslationThreads(0),
         DefaultGlobalPrefix(""), DefaultFunctionPrefix(""), TimingFocusOn(""),
         VerboseFocusOn(""), TranslateOnly("") {}
+
+  bool getDisableInternal() const { return DisableInternal; }
+  void setDisableInternal(bool NewValue) { DisableInternal = NewValue; }
+
+  bool getSubzeroTimingEnabled() const { return SubzeroTimingEnabled; }
+  void setSubzeroTimingEnabled(bool NewValue) {
+    SubzeroTimingEnabled = NewValue;
+  }
+
+  bool getDisableTranslation() const { return DisableTranslation; }
+  void setDisableTranslation(bool NewValue) { DisableTranslation = NewValue; }
+
+  bool getFunctionSections() const { return FunctionSections; }
+  void setFunctionSections(bool NewValue) { FunctionSections = NewValue; }
+
+  bool getDataSections() const { return DataSections; }
+  void setDataSections(bool NewValue) { DataSections = NewValue; }
+
+  bool getUseELFWriter() const { return UseELFWriter; }
+  void setUseELFWriter(bool NewValue) { UseELFWriter = NewValue; }
+
+  bool getUseIntegratedAssembler() const { return UseIntegratedAssembler; }
+  void setUseIntegratedAssembler(bool NewValue) {
+    UseIntegratedAssembler = NewValue;
+  }
+
+  bool getUseSandboxing() const { return UseSandboxing; }
+  void setUseSandboxing(bool NewValue) { UseSandboxing = NewValue; }
+
+  bool getPhiEdgeSplit() const { return PhiEdgeSplit; }
+  void setPhiEdgeSplit(bool NewValue) { PhiEdgeSplit = NewValue; }
+
+  bool getDecorateAsm() const { return DecorateAsm; }
+  void setDecorateAsm(bool NewValue) { DecorateAsm = NewValue; }
+
+  bool getDumpStats() const { return DumpStats; }
+  void setDumpStats(bool NewValue) { DumpStats = NewValue; }
+
+  bool getAllowUninitializedGlobals() const {
+    return AllowUninitializedGlobals;
+  }
+  void setAllowUninitializedGlobals(bool NewValue) {
+    AllowUninitializedGlobals = NewValue;
+  }
+
+  bool getTimeEachFunction() const { return TimeEachFunction; }
+  void setTimeEachFunction(bool NewValue) { TimeEachFunction = NewValue; }
+
+  bool getDisableIRGeneration() const { return DisableIRGeneration; }
+  void setDisableIRGeneration(bool NewValue) { DisableIRGeneration = NewValue; }
+
+  bool getAllowErrorRecovery() const { return AllowErrorRecovery; }
+  void setAllowErrorRecovery(bool NewValue) { AllowErrorRecovery = NewValue; }
+
+  bool getStubConstantCalls() const {
+    return IS_MINIMAL_BUILD ? false : StubConstantCalls;

[Jim Stichnoth, 2015/02/05 22:30:09]

Stylistically, I'd prefer:
  return !IS_MINIMAL_BUILD && StubConstantCalls;
which is a closer match to the uses of ALLOW_ in the rest of the code.

[Karl, 2015/02/05 23:57:38]

Done.

+  }
+  void setStubConstantCalls(bool NewValue) { StubConstantCalls = NewValue; }
+
+  bool getGenerateUnitTestMessages() const { return GenerateUnitTestMessages; }
+  void setGenerateUnitTestMessages(bool NewValue) {
+    GenerateUnitTestMessages = NewValue;
+  }
+
+  size_t getNumTranslationThreads() const { return NumTranslationThreads; }
+  void setNumTranslationThreads(size_t NewValue) {
+    NumTranslationThreads = NewValue;
+  }
+
+  const IceString &getDefaultGlobalPrefix() const {
+    return DefaultGlobalPrefix;
+  }
+  void setDefaultGlobalPrefix(const IceString &NewValue) {
+    DefaultGlobalPrefix = NewValue;
+  }
+
+  const IceString &getDefaultFunctionPrefix() const {
+    return DefaultFunctionPrefix;
+  }
+  void setDefaultFunctionPrefix(const IceString &NewValue) {
+    DefaultFunctionPrefix = NewValue;
+  }
+
+  const IceString &getTimingFocusOn() const { return TimingFocusOn; }
+  void setTimingFocusOn(const IceString &NewValue) { TimingFocusOn = NewValue; }
+
+  const IceString &getVerboseFocusOn() const { return VerboseFocusOn; }
+  void setVerboseFocusOn(const IceString &NewValue) {
+    VerboseFocusOn = NewValue;
+  }
+
+  const IceString &getTranslateOnly() const { return TranslateOnly; }
+  void setTranslateOnly(const IceString &NewValue) { TranslateOnly = NewValue; }
+
+private:
   bool DisableInternal;

[Jim Stichnoth, 2015/02/05 22:30:09]

While you're here, could you alphabetically sort the field names (and accessor
functions) within each type?

[Karl, 2015/02/05 23:57:38]

Done.

   bool SubzeroTimingEnabled;
   bool DisableTranslation;
   bool FunctionSections;
   bool DataSections;
   bool UseELFWriter;
   bool UseIntegratedAssembler;
   bool UseSandboxing;
   bool PhiEdgeSplit;
   bool DecorateAsm;
   bool DumpStats;
   bool AllowUninitializedGlobals;
   bool TimeEachFunction;
   bool DisableIRGeneration;
   bool AllowErrorRecovery;
   bool StubConstantCalls;
   bool GenerateUnitTestMessages;
   size_t NumTranslationThreads; // 0 means completely sequential
   IceString DefaultGlobalPrefix;
   IceString DefaultFunctionPrefix;
   IceString TimingFocusOn;
   IceString VerboseFocusOn;
   IceString TranslateOnly;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICECLFLAGS_H