Implements include/exclude register lists for translation.

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 21 matching lines @@
 // (TargetLowering, TargetDataLowering, and TargetHeaderLowering) we use the
 // following named constructors. For reference, each target Foo needs to
 // implement the following named constructors and initializer:
 //
 // namespace Foo {
 //   unique_ptr<Ice::TargetLowering> createTargetLowering(Ice::Cfg *);
 //   unique_ptr<Ice::TargetDataLowering>
 //       createTargetDataLowering(Ice::GlobalContext*);
 //   unique_ptr<Ice::TargetHeaderLowering>
 //       createTargetHeaderLowering(Ice::GlobalContext *);
-//   void staticInit(const ::Ice::ClFlags &Flags);
+//   void staticInit(::Ice::GlobalContext *);
 // }
 #define SUBZERO_TARGET(X)                                                      \
   namespace X {                                                                \
   std::unique_ptr<::Ice::TargetLowering>                                       \
   createTargetLowering(::Ice::Cfg *Func);                                      \
   std::unique_ptr<::Ice::TargetDataLowering>                                   \
   createTargetDataLowering(::Ice::GlobalContext *Ctx);                         \
   std::unique_ptr<::Ice::TargetHeaderLowering>                                 \
   createTargetHeaderLowering(::Ice::GlobalContext *Ctx);                       \
-  void staticInit(const ::Ice::ClFlags &Flags);                                \
+  void staticInit(::Ice::GlobalContext *Ctx);                                  \
   } // end of namespace X
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
 
 namespace Ice {
 void LoweringContext::init(CfgNode *N) {
   Node = N;
   End = getNode()->getInsts().end();
   rewind();
   advanceForward(Next);
@@ skipping 46 matching lines @@
   LastSrc = llvm::cast<Variable>(Instr->getSrc(0));
 }
 
 Variable *LoweringContext::availabilityGet(Operand *Src) const {
   assert(Src);
   if (Src == LastDest)
     return LastSrc;
   return nullptr;
 }
 
+namespace {
+
+void printRegisterSet(Ostream &Str, const llvm::SmallBitVector &Bitset,
+                      std::function<IceString(int32_t)> getRegName,
+                      IceString LineIndentString) {

[Jim Stichnoth, 2016/01/15 17:39:13]

const IceString &

[Karl, 2016/01/15 19:08:27]

Done.

+  constexpr size_t RegistersPerLine = 16;
+  size_t Count = 0;
+  for (int i = Bitset.find_first(); i != -1; i = Bitset.find_next(i)) {
+    if (Count == 0) {
+      Str << LineIndentString;
+    } else {
+      Str << ",";
+    }
+    if (Count > 0 && Count % RegistersPerLine == 0)
+      Str << "\n" << LineIndentString;
+    ++Count;
+    Str << getRegName(i);
+  }
+  if (Count)
+    Str << "\n";
+}
+
+} // end of anonymous namespace
+
+void TargetLowering::filterTypeToRegisterSet(
+    GlobalContext *Ctx, int32_t NumRegs,
+    llvm::SmallBitVector TypeToRegisterSet[], size_t TypeToRegisterSetSize,
+    std::function<IceString(int32_t)> getRegName) {
+  llvm::SmallBitVector ExcludeBitSet(NumRegs);
+  std::vector<llvm::SmallBitVector> UseSet(TypeToRegisterSetSize,
+                                           ExcludeBitSet);
+  ExcludeBitSet.flip();
+
+  std::unordered_map<IceString, int32_t> RegNameToIndex;
+  for (int32_t RegIndex = 0; RegIndex < NumRegs; ++RegIndex)
+    RegNameToIndex[getRegName(RegIndex)] = RegIndex;
+
+  std::vector<IceString> BadRegNames;

[Jim Stichnoth, 2016/01/15 17:39:13]

Maybe use StringVector here too?

Note that StringVector is tied to the implementation of cl::list<>, so if LLVM
decided to change cl::list's base class, StringVector would have to change as
well.  That probably wouldn't affect correctness here because only generic STL
container methods are used, but it could potentially pull in bulky code? 
Whatever...

[Karl, 2016/01/15 19:08:27]

Changed to ClFlags::StringVector.

+  for (const IceString &RegName : Ctx->getFlags().getUseRestrictedRegisters()) {
+    if (!RegNameToIndex.count(RegName)) {
+      BadRegNames.push_back(RegName);
+      continue;
+    }
+    const int32_t RegIndex = RegNameToIndex[RegName];
+    for (SizeT TypeIndex = 0; TypeIndex < TypeToRegisterSetSize; ++TypeIndex)
+      UseSet[TypeIndex][RegIndex] = TypeToRegisterSet[TypeIndex][RegIndex];
+  }
+
+  std::vector<IceString> BadExcludes;
+  for (const IceString &RegName : Ctx->getFlags().getExcludedRegisters()) {
+    if (!RegNameToIndex.count(RegName)) {
+      BadRegNames.push_back(RegName);
+      continue;
+    }
+    ExcludeBitSet[RegNameToIndex[RegName]] = false;
+  }
+
+  if (!BadRegNames.empty()) {
+    std::string Buffer;
+    llvm::raw_string_ostream StrBuf(Buffer);
+    StrBuf << "Unrecognized use/exclude registers:";
+    for (const auto &RegName : BadRegNames)
+      StrBuf << " " << RegName;
+    llvm::report_fatal_error(StrBuf.str());
+  }
+
+  // Apply filters.
+  for (size_t TypeIndex = 0; TypeIndex < TypeToRegisterSetSize; ++TypeIndex) {
+    llvm::SmallBitVector *TypeBitSet = &TypeToRegisterSet[TypeIndex];
+    llvm::SmallBitVector *UseBitSet = &UseSet[TypeIndex];
+    if (UseBitSet->any())
+      *TypeBitSet = *UseBitSet;
+    *TypeBitSet &= ExcludeBitSet;
+  }
+
+  // Display filtered register sets, if requested.
+  if (BuildDefs::dump() && NumRegs &&
+      (Ctx->getFlags().getVerbose() & IceV_AvailableRegs)) {
+    Ostream &Str = Ctx->getStrDump();
+    const std::string Indent("  ");

[Jim Stichnoth, 2016/01/15 17:39:13]

const IceString Indent = "  ";

[Karl, 2016/01/15 19:08:27]

Done.

+    Str << "Registers available for register allocation:\n";
+    for (size_t TypeIndex = 0; TypeIndex < TypeToRegisterSetSize; ++TypeIndex) {
+      Str << Indent;
+      if (TypeIndex < IceType_NUM) {
+        Str << typeString(static_cast<Type>(TypeIndex));
+      } else {
+        Str << "other[" << TypeIndex << "]";
+      }
+      Str << ":\n";
+      printRegisterSet(Str, TypeToRegisterSet[TypeIndex], getRegName,
+                       Indent + Indent);

[Jim Stichnoth, 2016/01/15 17:39:13]

Optional: something like:
  const IceString IndentMultiLine = Indent + Indent;
hoisted out of the loop

[Karl, 2016/01/15 19:08:27]

Done.

+    }
+    Str << "\n";
+  }
+}
+
 std::unique_ptr<TargetLowering>
 TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
   switch (Target) {
   default:
     llvm::report_fatal_error("Unsupported target");
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X:                                                             \
     return ::X::createTargetLowering(Func);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
-void TargetLowering::staticInit(const ClFlags &Flags) {
-  const TargetArch Target = Flags.getTargetArch();
+void TargetLowering::staticInit(GlobalContext *Ctx) {
+  const TargetArch Target = Ctx->getFlags().getTargetArch();
   // Call the specified target's static initializer.
   switch (Target) {
   default:
     llvm::report_fatal_error("Unsupported target");
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X: {                                                           \
     static bool InitGuard##X = false;                                          \
     if (InitGuard##X) {                                                        \
       return;                                                                  \
     }                                                                          \
     InitGuard##X = true;                                                       \
-    ::X::staticInit(Flags);                                                    \
+    ::X::staticInit(Ctx);                                                      \
   } break;
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetLowering::TargetLowering(Cfg *Func)
     : Func(Func), Ctx(Func->getContext()), Context() {}
 
 void TargetLowering::genTargetHelperCalls() {
@@ skipping 526 matching lines @@
   case Target_##X:                                                             \
     return ::X::createTargetHeaderLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice