Subzero: Remove IceString.

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 38 matching lines @@
 // }
 #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(::Ice::GlobalContext *Ctx);                                  \
+  bool shouldBePooled(const ::Ice::Constant *C);                               \
   } // end of namespace X
 #include "SZTargets.def"
 #undef SUBZERO_TARGET
 
 namespace Ice {
 void LoweringContext::init(CfgNode *N) {
   Node = N;
   End = getNode()->getInsts().end();
   rewind();
   advanceForward(Next);
@@ skipping 49 matching lines @@
 Variable *LoweringContext::availabilityGet(Operand *Src) const {
   assert(Src);
   if (Src == LastDest)
     return LastSrc;
   return nullptr;
 }
 
 namespace {
 
 void printRegisterSet(Ostream &Str, const SmallBitVector &Bitset,
-                      std::function<IceString(RegNumT)> getRegName,
-                      const IceString &LineIndentString) {
+                      std::function<std::string(RegNumT)> getRegName,
+                      const std::string &LineIndentString) {
   constexpr size_t RegistersPerLine = 16;
   size_t Count = 0;
   for (RegNumT RegNum : RegNumBVIter(Bitset)) {
     if (Count == 0) {
       Str << LineIndentString;
     } else {
       Str << ",";
     }
     if (Count > 0 && Count % RegistersPerLine == 0)
       Str << "\n" << LineIndentString;
     ++Count;
     Str << getRegName(RegNum);
   }
   if (Count)
     Str << "\n";
 }
 
 // Splits "<class>:<reg>" into "<class>" plus "<reg>".  If there is no <class>
 // component, the result is "" plus "<reg>".
-void splitToClassAndName(const IceString &RegName, IceString *SplitRegClass,
-                         IceString *SplitRegName) {
+void splitToClassAndName(const std::string &RegName, std::string *SplitRegClass,
+                         std::string *SplitRegName) {
   constexpr const char Separator[] = ":";
   constexpr size_t SeparatorWidth = llvm::array_lengthof(Separator) - 1;
   size_t Pos = RegName.find(Separator);
   if (Pos == std::string::npos) {
     *SplitRegClass = "";
     *SplitRegName = RegName;
   } else {
     *SplitRegClass = RegName.substr(0, Pos);
     *SplitRegName = RegName.substr(Pos + SeparatorWidth);
   }
 }
 
 LLVM_ATTRIBUTE_NORETURN void badTargetFatalError(TargetArch Target) {
   llvm::report_fatal_error("Unsupported target: " +
                            std::string(targetArchString(Target)));
 }
 
 } // end of anonymous namespace
 
 void TargetLowering::filterTypeToRegisterSet(
     GlobalContext *Ctx, int32_t NumRegs, SmallBitVector TypeToRegisterSet[],
-    size_t TypeToRegisterSetSize, std::function<IceString(RegNumT)> getRegName,
-    std::function<IceString(RegClass)> getRegClassName) {
+    size_t TypeToRegisterSetSize,
+    std::function<std::string(RegNumT)> getRegName,
+    std::function<const char *(RegClass)> getRegClassName) {
   std::vector<SmallBitVector> UseSet(TypeToRegisterSetSize,
                                      SmallBitVector(NumRegs));
   std::vector<SmallBitVector> ExcludeSet(TypeToRegisterSetSize,
                                          SmallBitVector(NumRegs));
 
-  std::unordered_map<IceString, RegNumT> RegNameToIndex;
+  std::unordered_map<std::string, RegNumT> RegNameToIndex;
   for (int32_t RegIndex = 0; RegIndex < NumRegs; ++RegIndex) {
     const auto RegNum = RegNumT::fromInt(RegIndex);
     RegNameToIndex[getRegName(RegNum)] = RegNum;
   }
 
   std::vector<std::string> BadRegNames;
 
   // The processRegList function iterates across the RegNames vector.  Each
   // entry in the vector is a string of the form "<reg>" or "<class>:<reg>".
   // The register class and register number are computed, and the corresponding
   // bit is set in RegSet[][].  If "<class>:" is missing, then the bit is set
   // for all classes.
   auto processRegList = [&](const std::vector<std::string> &RegNames,
                             std::vector<SmallBitVector> &RegSet) {
-    for (const IceString &RegClassAndName : RegNames) {
-      IceString RClass;
-      IceString RName;
+    for (const std::string &RegClassAndName : RegNames) {
+      std::string RClass;
+      std::string RName;
       splitToClassAndName(RegClassAndName, &RClass, &RName);
       if (!RegNameToIndex.count(RName)) {
         BadRegNames.push_back(RName);
         continue;
       }
       const int32_t RegIndex = RegNameToIndex.at(RName);
       for (SizeT TypeIndex = 0; TypeIndex < TypeToRegisterSetSize;
            ++TypeIndex) {
         if (RClass.empty() ||
             RClass == getRegClassName(static_cast<RegClass>(TypeIndex))) {
@@ skipping 22 matching lines @@
     SmallBitVector *ExcludeBitSet = &ExcludeSet[TypeIndex];
     if (UseBitSet->any())
       *TypeBitSet = *UseBitSet;
     (*TypeBitSet).reset(*ExcludeBitSet);
   }
 
   // Display filtered register sets, if requested.
   if (BuildDefs::dump() && NumRegs &&
       (Ctx->getFlags().getVerbose() & IceV_AvailableRegs)) {
     Ostream &Str = Ctx->getStrDump();
-    const IceString Indent = "  ";
-    const IceString IndentTwice = Indent + Indent;
+    const std::string Indent = "  ";
+    const std::string IndentTwice = Indent + Indent;
     Str << "Registers available for register allocation:\n";
     for (size_t TypeIndex = 0; TypeIndex < TypeToRegisterSetSize; ++TypeIndex) {
       Str << Indent << getRegClassName(static_cast<RegClass>(TypeIndex))
           << ":\n";
       printRegisterSet(Str, TypeToRegisterSet[TypeIndex], getRegName,
                        IndentTwice);
     }
     Str << "\n";
   }
 }
@@ skipping 24 matching lines @@
       return;                                                                  \
     }                                                                          \
     InitGuard##X = true;                                                       \
     ::X::staticInit(Ctx);                                                      \
   } break;
 #include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
+bool TargetLowering::shouldBePooled(const Constant *C) {
+  const TargetArch Target = GlobalContext::getFlags().getTargetArch();
+  switch (Target) {
+  default:
+    return false;
+#define SUBZERO_TARGET(X)                                                      \
+  case TARGET_LOWERING_CLASS_FOR(X):                                           \
+    return ::X::shouldBePooled(C);
+#include "SZTargets.def"
+#undef SUBZERO_TARGET
+  }
+}
+
 TargetLowering::SandboxType
 TargetLowering::determineSandboxTypeFromFlags(const ClFlags &Flags) {
   assert(!Flags.getUseSandboxing() || !Flags.getUseNonsfi());
   if (Flags.getUseNonsfi()) {
     return TargetLowering::ST_Nonsfi;
   }
   if (Flags.getUseSandboxing()) {
     return TargetLowering::ST_NaCl;
   }
   return TargetLowering::ST_None;
@@ skipping 426 matching lines @@
       Dest, [this, Kind](Variable *Dest, Operand *Src0, Operand *Src1) {
         return Context.insert<InstArithmetic>(Kind, Dest, Src0, Src1);
       }, Src0, Src1);
 }
 
 void TargetLowering::emitWithoutPrefix(const ConstantRelocatable *C,
                                        const char *Suffix) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
-  const IceString &EmitStr = C->getEmitString();
+  const std::string &EmitStr = C->getEmitString();
   if (!EmitStr.empty()) {
     // C has a custom emit string, so we use it instead of the canonical
     // Name + Offset form.
     Str << EmitStr;
     return;
   }
   Str << C->getName() << Suffix;
   RelocOffsetT Offset = C->getOffset();
   if (Offset) {
     if (Offset > 0)
@@ skipping 16 matching lines @@
   }
 }
 
 TargetDataLowering::~TargetDataLowering() = default;
 
 namespace {
 
 // dataSectionSuffix decides whether to use SectionSuffix or VarName as data
 // section suffix. Essentially, when using separate data sections for globals
 // SectionSuffix is not necessary.
-IceString dataSectionSuffix(const IceString &SectionSuffix,
-                            const IceString &VarName, const bool DataSections) {
+std::string dataSectionSuffix(const std::string &SectionSuffix,
+                              const std::string &VarName,
+                              const bool DataSections) {
   if (SectionSuffix.empty() && !DataSections) {
     return "";
   }
 
   if (DataSections) {
     // With data sections we don't need to use the SectionSuffix.
     return "." + VarName;
   }
 
   assert(!SectionSuffix.empty());
   return "." + SectionSuffix;
 }
 
 } // end of anonymous namespace
 
 void TargetDataLowering::emitGlobal(const VariableDeclaration &Var,
-                                    const IceString &SectionSuffix) {
+                                    const std::string &SectionSuffix) {
   if (!BuildDefs::dump())
     return;
 
   // If external and not initialized, this must be a cross test. Don't generate
   // a declaration for such cases.
   const bool IsExternal =
       Var.isExternal() || Ctx->getFlags().getDisableInternal();
   if (IsExternal && !Var.hasInitializer())
     return;
 
   Ostream &Str = Ctx->getStrEmit();
   const bool HasNonzeroInitializer = Var.hasNonzeroInitializer();
   const bool IsConstant = Var.getIsConstant();
   const SizeT Size = Var.getNumBytes();
-  const IceString &Name = Var.getName();
+  const std::string Name = Var.getName().toString();
 
   Str << "\t.type\t" << Name << ",%object\n";
 
   const bool UseDataSections = Ctx->getFlags().getDataSections();
   const bool UseNonsfi = Ctx->getFlags().getUseNonsfi();
-  const IceString Suffix =
+  const std::string Suffix =
       dataSectionSuffix(SectionSuffix, Name, UseDataSections);
   if (IsConstant && UseNonsfi)
     Str << "\t.section\t.data.rel.ro" << Suffix << ",\"aw\",%progbits\n";
   else if (IsConstant)
     Str << "\t.section\t.rodata" << Suffix << ",\"a\",%progbits\n";
   else if (HasNonzeroInitializer)
     Str << "\t.section\t.data" << Suffix << ",\"aw\",%progbits\n";
   else
     Str << "\t.section\t.bss" << Suffix << ",\"aw\",%nobits\n";
 
@@ skipping 66 matching lines @@
   case TARGET_LOWERING_CLASS_FOR(X):                                           \
     return ::X::createTargetHeaderLowering(Ctx);
 #include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice