Subzero: Remove IceString.

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Implements the Operand class and its target-independent subclasses,
 /// primarily for the methods of the Variable class.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceOperand.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceInst.h"
 #include "IceInstVarIter.h"
 #include "IceMemory.h"
 #include "IceTargetLowering.h" // dumping stack/frame pointer register
 
 namespace Ice {
 
+void Constant::initShouldBePooled() {
+  ShouldBePooled = TargetLowering::shouldBePooled(this);
+}
+
 bool operator==(const RelocatableTuple &A, const RelocatableTuple &B) {
   // A and B are the same if:
   //   (1) they have the same name; and
   //   (2) they have the same offset.
   //
   // (1) is trivial to check, but (2) requires some care.
   //
   // For (2):
   //  if A and B have known offsets (i.e., no symbolic references), then
   //     A == B -> A.Offset == B.Offset.
@@ skipping 143 matching lines @@
       return true;
   }
   return false;
 }
 
 void LiveRange::trim(InstNumberT Lower) {
   while (TrimmedBegin != Range.end() && TrimmedBegin->second <= Lower)
     ++TrimmedBegin;
 }
 
-IceString Variable::getName(const Cfg *Func) const {
-  if (Func && NameIndex >= 0)
-    return Func->getIdentifierName(NameIndex);
-  return "__" + std::to_string(getIndex());
+std::string Variable::getName(const Cfg *Func) const {
+  if (Func == nullptr)
+    return "__" + std::to_string(getIndex());
+  return Name.toString();
 }
 
-const Variable *Variable::asType(Type Ty, RegNumT NewRegNum) const {
+const Variable *Variable::asType(const Cfg *Func, Type Ty,
+                                 RegNumT NewRegNum) const {
   // Note: This returns a Variable, even if the "this" object is a subclass of
   // Variable.
   if (!BuildDefs::dump() || getType() == Ty)
     return this;
   static constexpr SizeT One = 1;
   Variable *V = new (CfgLocalAllocator<Variable>().allocate(One))
-      Variable(kVariable, Ty, Number);
-  V->NameIndex = NameIndex;
+      Variable(Func, kVariable, Ty, Number);
+  V->Name = Name;
   V->RegNum = NewRegNum.hasValue() ? NewRegNum : RegNum;
   V->StackOffset = StackOffset;
   return V;
 }
 
 RegWeight Variable::getWeight(const Cfg *Func) const {
   VariablesMetadata *VMetadata = Func->getVMetadata();
   return mustHaveReg() ? RegWeight(RegWeight::Inf)
                        : mustNotHaveReg() ? RegWeight(RegWeight::Zero)
                                           : VMetadata->getUseWeight(this);
@@ skipping 383 matching lines @@
   if (W.getWeight() == RegWeight::Inf)
     Str << "Inf";
   else
     Str << W.getWeight();
   return Str;
 }
 
 // =========== Immediate Randomization and Pooling routines ==============
 // Specialization of the template member function for ConstantInteger32
 // TODO(stichnot): try to move this specialization into a target-specific file.
-template <>
-bool ConstantInteger32::shouldBeRandomizedOrPooled(const GlobalContext *Ctx) {
-  uint32_t Threshold = Ctx->getFlags().getRandomizeAndPoolImmediatesThreshold();
-  if (Ctx->getFlags().getRandomizeAndPoolImmediatesOption() == RPI_None)
+template <> bool ConstantInteger32::shouldBeRandomizedOrPooled() const {
+  uint32_t Threshold =
+      GlobalContext::getFlags().getRandomizeAndPoolImmediatesThreshold();
+  if (GlobalContext::getFlags().getRandomizeAndPoolImmediatesOption() ==
+      RPI_None)
     return false;
   if (getType() != IceType_i32 && getType() != IceType_i16 &&
       getType() != IceType_i8)
     return false;
   // The Following checks if the signed representation of Value is between
   // -Threshold/2 and +Threshold/2
   bool largerThanThreshold = Threshold / 2 + Value >= Threshold;
   return largerThanThreshold;
 }
 
 } // end of namespace Ice