Subzero: Remove IceString.

src/IceTimerTree.cpp

 //===- subzero/src/IceTimerTree.cpp - Pass timer defs ---------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 12 matching lines @@
 #endif // __clang__
 
 #include "llvm/Support/Timer.h"
 
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif // __clang__
 
 namespace Ice {
 
-TimerStack::TimerStack(const IceString &Name)
+TimerStack::TimerStack(const std::string &Name)
     : Name(Name), FirstTimestamp(timestamp()), LastTimestamp(FirstTimestamp) {
   if (!BuildDefs::timers())
     return;
   Nodes.resize(1); // Reserve Nodes[0] for the root node (sentinel).
   IDs.resize(TT__num);
   LeafTimes.resize(TT__num);
   LeafCounts.resize(TT__num);
 #define STR(s) #s
 #define X(tag)                                                                 \
   IDs[TT_##tag] = STR(tag);                                                    \
   IDsIndex[STR(tag)] = TT_##tag;
   TIMERTREE_TABLE;
 #undef X
 #undef STR
 }
 
 // Returns the unique timer ID for the given Name, creating a new ID if needed.
-TimerIdT TimerStack::getTimerID(const IceString &Name) {
+TimerIdT TimerStack::getTimerID(const std::string &Name) {
   if (!BuildDefs::timers())
     return 0;
   if (IDsIndex.find(Name) == IDsIndex.end()) {
     IDsIndex[Name] = IDs.size();
     IDs.push_back(Name);
     LeafTimes.push_back(decltype(LeafTimes)::value_type());
     LeafCounts.push_back(decltype(LeafCounts)::value_type());
   }
   return IDsIndex[Name];
 }
@@ skipping 155 matching lines @@
   LeafTimes.assign(LeafTimes.size(), 0);
   LeafCounts.assign(LeafCounts.size(), 0);
   for (TimerTreeNode &Node : Nodes) {
     Node.Time = 0;
     Node.UpdateCount = 0;
   }
 }
 
 namespace {
 
-using DumpMapType = std::multimap<double, IceString>;
+using DumpMapType = std::multimap<double, std::string>;
 
 // Dump the Map items in reverse order of their time contribution.
 void dumpHelper(Ostream &Str, const DumpMapType &Map, double TotalTime) {
   if (!BuildDefs::timers())
     return;
   for (auto &I : reverse_range(Map)) {
     char buf[80];
     snprintf(buf, llvm::array_lengthof(buf), "  %10.6f (%4.1f%%): ", I.first,
              I.first * 100 / TotalTime);
     Str << buf << I.second << "\n";
@@ skipping 30 matching lines @@
     Str << Name << " - Cumulative times:\n";
     size_t MaxInternalCount = 0;
     for (TimerTreeNode &Node : Nodes)
       MaxInternalCount = std::max(MaxInternalCount, Node.UpdateCount);
     makePrintfFormatString(FmtString, llvm::array_lengthof(FmtString),
                            MaxInternalCount);
 
     DumpMapType CumulativeMap;
     for (TTindex i = 1; i < Nodes.size(); ++i) {
       TTindex Prefix = i;
-      IceString Suffix = "";
+      std::string Suffix = "";
       while (Prefix) {
         if (Suffix.empty())
           Suffix = IDs[Nodes[Prefix].Interior];
         else
           Suffix = IDs[Nodes[Prefix].Interior] + "." + Suffix;
         assert(Nodes[Prefix].Parent < Prefix);
         Prefix = Nodes[Prefix].Parent;
       }
       snprintf(PrefixStr, llvm::array_lengthof(PrefixStr), FmtString,
                Nodes[i].UpdateCount);
@@ skipping 18 matching lines @@
   dumpHelper(Str, FlatMap, TotalTime);
   Str << "Number of timer updates: " << StateChangeCount << "\n";
 }
 
 double TimerStack::timestamp() {
   // TODO: Implement in terms of std::chrono for C++11.
   return llvm::TimeRecord::getCurrentTime(false).getWallTime();
 }
 
 } // end of namespace Ice