Move some flag-like props from GlobalContext and TargetLowering to 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"
+#include "IceTypes.h"
 
 namespace Ice {
 
 class ClFlags {
   ClFlags(const ClFlags &) = delete;
   ClFlags &operator=(const ClFlags &) = delete;
 
 public:
   ClFlags()
       : // bool fields.
         AllowErrorRecovery(false),
         AllowUninitializedGlobals(false), DataSections(false),
         DecorateAsm(false), DisableInternal(false), DisableIRGeneration(false),
         DisableTranslation(false), DumpStats(false), FunctionSections(false),
         GenerateUnitTestMessages(false), PhiEdgeSplit(false),
+        RandNopInsertion(false), RandRegAlloc(false),
         SubzeroTimingEnabled(false), TimeEachFunction(false),
         UseSandboxing(false),
-        // FileType field
-        OutFileType(FT_Iasm),
+        // Enum and integer fields
+        Opt(Opt_m1), OutFileType(FT_Iasm), RandMaxNopsPerInstruction(0),
+        RandNopProbabilityAsPercentage(0), TArch(TargetArch_NUM),
+        VMask(IceV_None),
         // IceString fields.
-        DefaultFunctionPrefix(""), DefaultGlobalPrefix(""), TimingFocusOn(""),
-        TranslateOnly(""), VerboseFocusOn(""),
-        // size_t fields.
-        NumTranslationThreads(0) {}
+        DefaultFunctionPrefix(""), DefaultGlobalPrefix(""), TestPrefix(""),
+        TimingFocusOn(""), TranslateOnly(""), VerboseFocusOn(""),
+        // size_t and 64-bit fields.
+        NumTranslationThreads(0), RandomSeed(0) {}
 
   // bool accessors.
 
   bool getAllowErrorRecovery() const { return AllowErrorRecovery; }
   void setAllowErrorRecovery(bool NewValue) { AllowErrorRecovery = NewValue; }
 
   bool getAllowUninitializedGlobals() const {
     return AllowUninitializedGlobals;
   }
   void setAllowUninitializedGlobals(bool NewValue) {
@@ skipping 28 matching lines @@
     // will not be readable. Hence, turn off.
     return !ALLOW_DUMP || GenerateUnitTestMessages;
   }
   void setGenerateUnitTestMessages(bool NewValue) {
     GenerateUnitTestMessages = NewValue;
   }
 
   bool getPhiEdgeSplit() const { return PhiEdgeSplit; }
   void setPhiEdgeSplit(bool NewValue) { PhiEdgeSplit = NewValue; }
 
+  bool shouldDoNopInsertion() const { return RandNopInsertion; }
+  void setShouldDoNopInsertion(bool NewValue) { RandNopInsertion = NewValue; }
+
+  bool shouldRandomizeRegAlloc() const { return RandRegAlloc; }
+  void setShouldRandomizeRegAlloc(bool NewValue) { RandRegAlloc = NewValue; }
+
   bool getSubzeroTimingEnabled() const { return SubzeroTimingEnabled; }
   void setSubzeroTimingEnabled(bool NewValue) {
     SubzeroTimingEnabled = NewValue;
   }
 
   bool getTimeEachFunction() const { return ALLOW_DUMP && TimeEachFunction; }
   void setTimeEachFunction(bool NewValue) { TimeEachFunction = NewValue; }
 
   bool getUseSandboxing() const { return UseSandboxing; }
   void setUseSandboxing(bool NewValue) { UseSandboxing = NewValue; }
 
-  // FileType accessor.
+  // Enum and integer accessors.
+  OptLevel getOptLevel() const { return Opt; }
+  void setOptLevel(OptLevel NewValue) { Opt = NewValue; }
+
   FileType getOutFileType() const { return OutFileType; }
   void setOutFileType(FileType NewValue) { OutFileType = NewValue; }
 
+  int getMaxNopsPerInstruction() const { return RandMaxNopsPerInstruction; }
+  void setMaxNopsPerInstruction(int NewValue) {
+    RandMaxNopsPerInstruction = NewValue;
+  }
+
+  int getNopProbabilityAsPercentage() const {
+    return RandNopProbabilityAsPercentage;
+  }
+  void setNopProbabilityAsPercentage(int NewValue) {
+    RandNopProbabilityAsPercentage = NewValue;
+  }
+
+  TargetArch getTargetArch() const { return TArch; }
+  void setTargetArch(TargetArch NewValue) { TArch = NewValue; }
+
+  TargetInstructionSet getTargetInstructionSet() const { return TInstrSet; }
+  void setTargetInstructionSet(TargetInstructionSet NewValue) {
+    TInstrSet = NewValue;
+  }
+
+  VerboseMask getVerbose() const { return ALLOW_DUMP ? VMask : IceV_None; }
+  void setVerbose(VerboseMask NewValue) { VMask = NewValue; }
+
   // IceString accessors.
 
   const IceString &getDefaultFunctionPrefix() const {
     return DefaultFunctionPrefix;
   }
   void setDefaultFunctionPrefix(const IceString &NewValue) {
     DefaultFunctionPrefix = NewValue;
   }
 
   const IceString &getDefaultGlobalPrefix() const {
     return DefaultGlobalPrefix;
   }
   void setDefaultGlobalPrefix(const IceString &NewValue) {
     DefaultGlobalPrefix = NewValue;
   }
 
+  const IceString &getTestPrefix() const { return TestPrefix; }
+  void setTestPrefix(const IceString &NewValue) { TestPrefix = NewValue; }
+
   const IceString &getTimingFocusOn() const { return TimingFocusOn; }
   void setTimingFocusOn(const IceString &NewValue) { TimingFocusOn = NewValue; }
 
   const IceString &getTranslateOnly() const { return TranslateOnly; }
   void setTranslateOnly(const IceString &NewValue) { TranslateOnly = NewValue; }
 
   const IceString &getVerboseFocusOn() const { return VerboseFocusOn; }
   void setVerboseFocusOn(const IceString &NewValue) {
     VerboseFocusOn = NewValue;
   }
 
-  // size_t accessors.
+  // size_t and 64-bit accessors.
 
   size_t getNumTranslationThreads() const { return NumTranslationThreads; }
   bool isSequential() const { return NumTranslationThreads == 0; }
   void setNumTranslationThreads(size_t NewValue) {
     NumTranslationThreads = NewValue;
   }
 
+  uint64_t getRandomSeed() const { return RandomSeed; }
+  void setRandomSeed(size_t NewValue) { RandomSeed = NewValue; }
+
 private:
   bool AllowErrorRecovery;
   bool AllowUninitializedGlobals;
   bool DataSections;
   bool DecorateAsm;
   bool DisableInternal;
   bool DisableIRGeneration;
   bool DisableTranslation;
   bool DumpStats;
   bool FunctionSections;
   bool GenerateUnitTestMessages;
   bool PhiEdgeSplit;
+  bool RandNopInsertion;
+  bool RandRegAlloc;
   bool SubzeroTimingEnabled;
   bool TimeEachFunction;
   bool UseSandboxing;
 
+  OptLevel Opt;
   FileType OutFileType;
+  int RandMaxNopsPerInstruction;
+  int RandNopProbabilityAsPercentage;
+  TargetArch TArch;
+  TargetInstructionSet TInstrSet;
+  VerboseMask VMask;
 
   IceString DefaultFunctionPrefix;
   IceString DefaultGlobalPrefix;
+  IceString TestPrefix;
   IceString TimingFocusOn;
   IceString TranslateOnly;
   IceString VerboseFocusOn;
 
   size_t NumTranslationThreads; // 0 means completely sequential
+  uint64_t RandomSeed;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICECLFLAGS_H