Implements include/exclude register lists for translation.

src/IceClFlags.cpp

 //===- subzero/src/IceClFlags.cpp - Command line flags and parsing --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 269 matching lines @@
 /// Max number of nops to insert per instruction.
 cl::opt<int> MaxNopsPerInstruction(
     "max-nops-per-instruction",
     cl::desc("Max number of nops to insert per instruction"), cl::init(1));
 
 /// Nop insertion probability as percentage.
 cl::opt<int> NopProbabilityAsPercentage(
     "nop-insertion-percentage",
     cl::desc("Nop insertion probability as percentage"), cl::init(10));
 
+/// Restricts registers in corresponding register classes to specified list.
+cl::list<std::string> UseRestrictedRegisters(
+    "use-registers",

[Jim Stichnoth, 2016/01/10 16:51:25]

Can you add the cl::CommaSeparated option here, which should eliminate the need
for custom comma parsing?  See the --verbose option below for reference.

[Karl, 2016/01/12 23:44:04]

Done.

+    cl::desc(
+        "Only use specified registers for corresponding register classes"));
+
+/// List of excluded registers.
+cl::list<std::string>
+    ExcludedRegisters("exclude-registers",

[Jim Stichnoth, 2016/01/10 16:51:25]

I would give these two option names a common prefix, like -reg-include and
-reg-exclude, so that they show up together in the -help output.

[Karl, 2016/01/12 23:44:04]

Switched to '-reg-use' and '-reg-exclude'.

+                      cl::desc("Don't use specified registers"));
+
 /// Verbose options (can be comma-separated).
 cl::list<Ice::VerboseItem> VerboseList(
     "verbose", cl::CommaSeparated,
     cl::desc("Verbose options (can be comma-separated):"),
     cl::values(
         clEnumValN(Ice::IceV_Instructions, "inst", "Print basic instructions"),
         clEnumValN(Ice::IceV_Deleted, "del", "Include deleted instructions"),
         clEnumValN(Ice::IceV_InstNumbers, "instnum",
                    "Print instruction numbers"),
         clEnumValN(Ice::IceV_Preds, "pred", "Show predecessors"),
@@ skipping 114 matching lines @@
     ReorderPooledConstants("reorder-pooled-constants",
                            cl::desc("Randomize constant pool entry ordering"),
                            cl::init(false));
 
 /// Command line option for accepting textual bitcode.
 cl::opt<bool> BitcodeAsText(
     "bitcode-as-text",
     cl::desc(
         "Accept textual form of PNaCl bitcode records (i.e. not .ll assembly)"),
     cl::init(false));
+
+void splitOnChars(const std::string &Text, const char *Chars,
+                  std::vector<std::string> &Tokens) {
+  size_t Start = 0;
+  bool KeepSplitting = true;
+  while (KeepSplitting) {
+    size_t End = Text.find_first_of(Chars, Start);
+    if (End == std::string::npos) {
+      KeepSplitting = false;
+      End = Text.size();
+    }
+    std::string RegName = Text.substr(Start, End - Start);
+    Tokens.push_back(RegName);
+    Start = End + 1;
+  }
+}
+
+void extractCommaSeparated(cl::list<std::string> &NameList,
+                           std::vector<std::string> &Names) {
+  Names.clear();
+  for (const std::string &Name : NameList) {
+    splitOnChars(Name, ",", Names);
+  }
+}
+
 } // end of anonymous namespace
 
 namespace Ice {
 
 void ClFlags::parseFlags(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv);
   AppName = IceString(argv[0]);
 }
 
 void ClFlags::resetClFlags(ClFlags &OutFlags) {
@@ skipping 40 matching lines @@
   // IceString fields.
   OutFlags.DefaultFunctionPrefix = "";
   OutFlags.DefaultGlobalPrefix = "";
   OutFlags.TestPrefix = "";
   OutFlags.TimingFocusOn = "";
   OutFlags.TranslateOnly = "";
   OutFlags.VerboseFocusOn = "";
   // size_t and 64-bit fields.
   OutFlags.NumTranslationThreads = 0;
   OutFlags.RandomSeed = 0;
+  // Sets.
+  OutFlags.clearExcludedRegisters();
+  OutFlags.clearUseRestrictedRegisters();
 }
 
 void ClFlags::getParsedClFlags(ClFlags &OutFlags) {
   Ice::VerboseMask VMask = Ice::IceV_None;
   // Don't generate verbose messages if routines to dump messages are not
   // available.
   if (BuildDefs::dump()) {
     for (unsigned i = 0; i != VerboseList.size(); ++i)
       VMask |= VerboseList[i];
   }
 
   OutFlags.setAllowErrorRecovery(::AllowErrorRecovery);
   OutFlags.setAllowExternDefinedSymbols(::AllowExternDefinedSymbols ||
                                         ::DisableInternal);
   OutFlags.setAllowIacaMarks(::AllowIacaMarks);
   OutFlags.setAllowUninitializedGlobals(::AllowUninitializedGlobals);
   OutFlags.setDataSections(::DataSections);
   OutFlags.setDecorateAsm(::DecorateAsm);
   OutFlags.setDefaultFunctionPrefix(::DefaultFunctionPrefix);
   OutFlags.setDefaultGlobalPrefix(::DefaultGlobalPrefix);
   OutFlags.setDisableHybridAssembly(::DisableHybridAssembly ||
                                     (::OutFileType != Ice::FT_Iasm));
   OutFlags.setDisableInternal(::DisableInternal);
   OutFlags.setDisableTranslation(::DisableTranslation);
   OutFlags.setDumpStats(::DumpStats);
   OutFlags.setEnableBlockProfile(::EnableBlockProfile);
+  std::vector<std::string> RegNames;
+  extractCommaSeparated(::ExcludedRegisters, RegNames);
+  for (const auto &Name : RegNames)
+    OutFlags.insertExcludedRegister(Name);
   OutFlags.setForceMemIntrinOpt(::ForceMemIntrinOpt);
   OutFlags.setFunctionSections(::FunctionSections);
   OutFlags.setNumTranslationThreads(::NumThreads);
   OutFlags.setOptLevel(::OLevel);
   OutFlags.setMockBoundsCheck(::MockBoundsCheck);
   OutFlags.setPhiEdgeSplit(::EnablePhiEdgeSplit);
   OutFlags.setRandomSeed(::RandomSeed);
   OutFlags.setRandomizeAndPoolImmediatesOption(
       ::RandomizeAndPoolImmediatesOption);
   OutFlags.setRandomizeAndPoolImmediatesThreshold(
       ::RandomizeAndPoolImmediatesThreshold);
   OutFlags.setReorderFunctionsWindowSize(::ReorderFunctionsWindowSize);
   OutFlags.setShouldReorderBasicBlocks(::ReorderBasicBlocks);
   OutFlags.setShouldDoNopInsertion(::ShouldDoNopInsertion);
   OutFlags.setShouldRandomizeRegAlloc(::RandomizeRegisterAllocation);
   OutFlags.setShouldRepeatRegAlloc(::RepeatRegAlloc);
   OutFlags.setShouldReorderFunctions(::ReorderFunctions);
   OutFlags.setShouldReorderGlobalVariables(::ReorderGlobalVariables);
   OutFlags.setShouldReorderPooledConstants(::ReorderPooledConstants);
   OutFlags.setSkipUnimplemented(::SkipUnimplemented);
   OutFlags.setSubzeroTimingEnabled(::SubzeroTimingEnabled);
   OutFlags.setTargetArch(::TargetArch);
   OutFlags.setTargetInstructionSet(::TargetInstructionSet);
   OutFlags.setTestPrefix(::TestPrefix);
   OutFlags.setTestStackExtra(::TestStackExtra);
   OutFlags.setTimeEachFunction(::TimeEachFunction);
   OutFlags.setTimingFocusOn(::TimingFocusOn);
   OutFlags.setTranslateOnly(::TranslateOnly);
   OutFlags.setUseNonsfi(::UseNonsfi);
+  extractCommaSeparated(::UseRestrictedRegisters, RegNames);
+  for (const auto &Name : RegNames)
+    OutFlags.insertUseRestrictedRegister(Name);
   OutFlags.setUseSandboxing(::UseSandboxing);
   OutFlags.setVerboseFocusOn(::VerboseFocusOn);
   OutFlags.setOutFileType(::OutFileType);
   OutFlags.setMaxNopsPerInstruction(::MaxNopsPerInstruction);
   OutFlags.setNopProbabilityAsPercentage(::NopProbabilityAsPercentage);
   OutFlags.setVerbose(VMask);
 }
 
 void ClFlags::getParsedClFlagsExtra(ClFlagsExtra &OutFlagsExtra) {
   OutFlagsExtra.setAlwaysExitSuccess(AlwaysExitSuccess);
   OutFlagsExtra.setBitcodeAsText(BitcodeAsText);
   OutFlagsExtra.setBuildOnRead(BuildOnRead);
   OutFlagsExtra.setGenerateBuildAtts(GenerateBuildAtts);
   OutFlagsExtra.setLLVMVerboseErrors(LLVMVerboseErrors);
   OutFlagsExtra.setAppName(AppName);
   OutFlagsExtra.setInputFileFormat(InputFileFormat);
   OutFlagsExtra.setIRFilename(IRFilename);
   OutFlagsExtra.setLogFilename(LogFilename);
   OutFlagsExtra.setOutputFilename(OutputFilename);
 }
 
 } // end of namespace Ice