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(
+    "reg-use", cl::CommaSeparated,
+    cl::desc(
+        "Only use specified registers for corresponding register classes"));
+
+/// List of excluded registers.
+cl::list<std::string>
+    ExcludedRegisters("reg-exclude", cl::CommaSeparated,
+                      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"),
         clEnumValN(Ice::IceV_Succs, "succ", "Show successors"),
         clEnumValN(Ice::IceV_Liveness, "live", "Liveness information"),
         clEnumValN(Ice::IceV_RegOrigins, "orig", "Physical register origins"),
         clEnumValN(Ice::IceV_LinearScan, "regalloc", "Linear scan details"),
         clEnumValN(Ice::IceV_Frame, "frame", "Stack frame layout details"),
         clEnumValN(Ice::IceV_AddrOpt, "addropt", "Address mode optimization"),
         clEnumValN(Ice::IceV_Random, "random", "Randomization details"),
         clEnumValN(Ice::IceV_Folding, "fold", "Instruction folding details"),
         clEnumValN(Ice::IceV_RMW, "rmw", "ReadModifyWrite optimization"),
         clEnumValN(Ice::IceV_Loop, "loop", "Loop nest depth analysis"),
         clEnumValN(Ice::IceV_Status, "status",
                    "Print the name of the function being translated"),
+        clEnumValN(Ice::IceV_AvailableRegs, "registers",
+                   "Show available registers for register allocation"),
         clEnumValN(Ice::IceV_All, "all", "Use all verbose options"),
         clEnumValN(Ice::IceV_Most, "most",
                    "Use all verbose options except 'regalloc'"),
         clEnumValN(Ice::IceV_None, "none", "No verbosity"), clEnumValEnd));
 
 // Options not captured in Ice::ClFlags and propagated.
 
 /// Exit with success status, even if errors found.
 cl::opt<bool> AlwaysExitSuccess(
     "exit-success", cl::desc("Exit with success status, even if errors found"),
@@ skipping 152 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.

[Jim Stichnoth, 2016/01/13 16:24:54]

Maybe "unordered_set fields"?

[Karl, 2016/01/14 18:27:19]

Done.

+  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);
+  for (const std::string &Name : ::ExcludedRegisters)

[Jim Stichnoth, 2016/01/13 16:24:54]

I think it would be more natural and regular if you call
setExcludeRegisters(::ExcludedRegisters) and let setExcludedRegisters iterate
over the collection.

[Karl, 2016/01/14 18:27:19]

The main reason for not doing this is that we would be exposing cl::list<> to
the API (i.e. users) of this module. Leaving as is.

[John, 2016/01/14 21:12:48]

I agree with Jim here. Exposing cl::list<> to the users is not necessarily bad
because the single caller to this routine has access to that type's definition.

If you are **really** bothered by the cl::list<> type, then you could do
something like:

  template <class T>
  void setUseRestrictedRegisters(const T &Value) {
    clearUseRestrictedRegisters();
    UseRestrictedRegisters.insert(Value.begin(), Value.end());
  }

[Karl, 2016/01/14 22:00:52]

I agree that it will work, and the current code would not expose the
command-line processing code, outside of the corresponding cpp file.

However, it is in the header file (as public API). Hence, if someone uses it
down the road, we are exposing the command line processing code. I will leave
this decision to Jim.

[Jim Stichnoth, 2016/01/14 22:04:19]

I ended up retracting my comment after discussion with Karl, because in a
SUPER-MINIMAL build we wouldn't even use llvm::cl (remove all but a few key
command-line arguments such as -O, -o, -threads; and use a simple non-bloated
arg parser), and so I wouldn't like that to leak outside this file.

That said, it turns out that cl::list<std::string> is a subclass of
std::vector<std::string>, so I resurrect my original comment with that in mind.

[Karl, 2016/01/14 23:54:51]

Changed type of register sets to: std::vector<IceString>.

+    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);
+  for (const std::string &Name : ::UseRestrictedRegisters)

[Jim Stichnoth, 2016/01/13 16:24:54]

same comment as above

[Karl, 2016/01/14 18:27:19]

Same response.

[John, 2016/01/14 21:12:48]

same suggestion.

+    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