Implements include/exclude register lists for translation.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 10 matching lines @@
 namespace Ice {
 
 class ClFlagsExtra;
 
 /// Define variables which configure translation and related support functions.
 class ClFlags {
   ClFlags(const ClFlags &) = delete;
   ClFlags &operator=(const ClFlags &) = delete;
 
 public:
+  using StringVector = std::vector<IceString>;
+
   /// User defined constructor.
   ClFlags() { resetClFlags(*this); }
 
   /// \brief Parse commmand line options for Subzero.
   ///
   /// This is done use cl::ParseCommandLineOptions() and the static variables of
   /// type cl::opt defined in IceClFlags.cpp
   static void parseFlags(int argc, char *argv[]);
   /// Reset all configuration options to their nominal values.
   static void resetClFlags(ClFlags &OutFlags);
@@ skipping 67 matching lines @@
   /// Get the value of ClFlags::DumpStats
   bool getDumpStats() const { return BuildDefs::dump() && DumpStats; }
   /// Set ClFlags::DumpStats to a new value
   void setDumpStats(bool NewValue) { DumpStats = NewValue; }
 
   /// Get the value of ClFlags::EnableBlockProfile
   bool getEnableBlockProfile() const { return EnableBlockProfile; }
   /// Set ClFlags::EnableBlockProfile to a new value
   void setEnableBlockProfile(bool NewValue) { EnableBlockProfile = NewValue; }
 
+  /// Get the restricted list of registers to use, for corresponding register
+  /// classes, in register allocation.
+  const StringVector &getUseRestrictedRegisters() const {
+    return UseRestrictedRegisters;
+  }
+  void clearUseRestrictedRegisters() { UseRestrictedRegisters.clear(); }
+  void setUseRestrictedRegisters(const StringVector &Registers) {
+    UseRestrictedRegisters = Registers;
+  }
+
   /// Get the value of ClFlags::ForceMemIntrinOpt
   bool getForceMemIntrinOpt() const { return ForceMemIntrinOpt; }
   /// Set ClFlags::ForceMemIntrinOpt to a new value
   void setForceMemIntrinOpt(bool NewValue) { ForceMemIntrinOpt = NewValue; }
 
   /// Get the value of ClFlags::FunctionSections
   bool getFunctionSections() const { return FunctionSections; }
   /// Set ClFlags::FunctionSections to a new value
   void setFunctionSections(bool NewValue) { FunctionSections = NewValue; }
 
@@ skipping 51 matching lines @@
     return BuildDefs::dump() && TimeEachFunction;
   }
   /// Set ClFlags::TimeEachFunction to a new value
   void setTimeEachFunction(bool NewValue) { TimeEachFunction = NewValue; }
 
   /// Get the value of ClFlags::UseNonsfi
   bool getUseNonsfi() const { return UseNonsfi; }
   /// Set ClFlags::UseNonsfi to a new value
   void setUseNonsfi(bool NewValue) { UseNonsfi = NewValue; }
 
+  /// Get the list of registers exluded in register allocation.
+  const StringVector &getExcludedRegisters() const { return ExcludedRegisters; }
+  void clearExcludedRegisters() { ExcludedRegisters.clear(); }
+  void setExcludedRegisters(const StringVector &Registers) {
+    ExcludedRegisters = Registers;
+  }
+
   /// Get the value of ClFlags::UseSandboxing
   bool getUseSandboxing() const { return UseSandboxing; }
   /// Set ClFlags::UseSandboxing to a new value
   void setUseSandboxing(bool NewValue) { UseSandboxing = NewValue; }
 
   // Enum and integer accessors.
   /// Get the value of ClFlags::Opt
   OptLevel getOptLevel() const { return Opt; }
   /// Set ClFlags::Opt to a new value
   void setOptLevel(OptLevel NewValue) { Opt = NewValue; }
@@ skipping 184 matching lines @@
   /// see anonymous_namespace{IceClFlags.cpp}::DisableHybridAssembly
   bool DisableHybridAssembly;
   /// see anonymous_namespace{IceClFlags.cpp}::DisableInternal
   bool DisableInternal;
   /// see anonymous_namespace{IceClFlags.cpp}::DisableTranslation
   bool DisableTranslation;
   /// see anonymous_namespace{IceClFlags.cpp}::DumpStats
   bool DumpStats;
   /// see anonymous_namespace{IceClFlags.cpp}::EnableBlockProfile
   bool EnableBlockProfile;
+  /// see anonymous_namespace{IceClFlags.cpp}::ExcludedRegisters;
+  StringVector ExcludedRegisters;
   /// see anonymous_namespace{IceClFlags.cpp}::ForceMemIntrinOpt
   bool ForceMemIntrinOpt;
   /// see anonymous_namespace{IceClFlags.cpp}::FunctionSections
   bool FunctionSections;
   /// Initialized to false; not set by the command line.
   bool GenerateUnitTestMessages;
   /// see anonymous_namespace{IceClFlags.cpp}::MockBoundsCheck
   bool MockBoundsCheck;
   /// see anonymous_namespace{IceClFlags.cpp}::EnablePhiEdgeSplit
   bool PhiEdgeSplit;
@@ skipping 12 matching lines @@
   /// see anonymous_namespace{IceClFlags.cpp}::ReorderPooledConstants
   bool ReorderPooledConstants;
   /// see anonymous_namespace{IceClFlags.cpp}::SkipUnimplemented
   bool SkipUnimplemented;
   /// see anonymous_namespace{IceClFlags.cpp}::SubzeroTimingEnabled
   bool SubzeroTimingEnabled;
   /// see anonymous_namespace{IceClFlags.cpp}::TimeEachFunction
   bool TimeEachFunction;
   /// see anonymous_namespace{IceClFlags.cpp}::UseNonsfi
   bool UseNonsfi;
+  /// see anonymous_namespace{IceClFlags.cpp}::UseRegistrictedRegisters;
+  StringVector UseRestrictedRegisters;
   /// see anonymous_namespace{IceClFlags.cpp}::UseSandboxing
   bool UseSandboxing;
   /// see anonymous_namespace{IceClFlags.cpp}::OLevel
   OptLevel Opt;
   /// see anonymous_namespace{IceClFlags.cpp}::OutFileType
   FileType OutFileType;
   /// see anonymous_namespace{IceClFlags.cpp}::RandomizeAndPoolImmediatesOption
   RandomizeAndPoolImmediatesEnum RandomizeAndPoolImmediatesOption;
   /// see
   /// anonymous_namespace{IceClFlags.cpp}::RandomizeAndPoolImmediatesThreshold
@@ skipping 27 matching lines @@
   /// see anonymous_namespace{IceClFlags.cpp}::NumThreads
 
   size_t NumTranslationThreads; // 0 means completely sequential
   /// see anonymous_namespace{IceClFlags.cpp}::RandomSeed
   uint64_t RandomSeed;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICECLFLAGS_H