make SmallString::str() return std::string

[yaron.keren]

Summary

Note! this compiles but breaks tests, it's not ready. I must have made an error somewhere.
I'm keeping it in Phabricator hoping to continue fixing it time permitting.
If anyone else is interested in taking over, feel free.

This is an attempt in making SmallString::str() return std::string.
The first phase required making SmallString an equal-rights citizen in LLVM.

There were four use-cases for SmallString::str():

1 Input to a twine or StringRef accepting function.
2 << streaming to raw_stream.
3 Select an overloaded function accepting Twine and StringRef.
4 Really convert to std::string.

To solve 1 and 2, I extended Twine and raw_stream to accept SmallVectorImpl<char>.
This made most hundreds of existing .str() calls redundant which is very nice.

3 was solved by either adding a SmallVectorImpl<char>-accepting function or
specifying StringRef(SmallString).

For 4, where std::string was really required, I added std::string SmallString::to_str().
.str() can not be reused immediatly as all the existing .str() code would compile OK but
with performance regressions due to the creation of std::string instead of a StringRef.

All .str() users must be reviewed to be removed most of the time or modified into
to_str() before we can reuse .str().

[dblaikie]

(posting this with full context would help make it easier to see/review in Phab)

include/llvm/ADT/SmallString.h

100

This doesn't look correct at all - that's comparing RHS to a default-constructed StringRef (the empty string). (similarly for the other functions here)

include/llvm/ADT/Twine.h

142

Might make more sense to represent many of these as a const StringRef value (then we wouldn't need so many variants - just build a StringRef from a std::string or a SmallVectorImpl<char>, etc... ) rather than pointers to the actual objects - just pointing straight into the buffer (& storing the length) would be simpler.

[yaron.keren]

Thanks, I meant to call the StringRef conversion but ended up with empty StringRef.
I will first split the twine and raw_stream changes into their own patch so they will be easier to review.

[yaron.keren]

Hi David,

I have looked into using a single StringRef for std::string, StringRef and SmallString. This is easily done but three problems emerge:

1 We lose efficient in .str(). It does not know to return a pointer to std::string even if the twine actually stores a single StringRef to the std::string data. A Twine-accepting funciton called with std::string input and then calls Twine::str() on its input will result in deep copy of the std::string.

2. The prinout routine printOneChildRepr() output would be less informative than today, we no longer have the information about the original data type for std::string and SmallString nor their actual address, just their data and size.

3 The Twine could be twice as large.

I'm not sure it's worthwhile going this way compared with adding another pointer to SmallString member union, what do you think?

include/llvm/ADT/SmallString.h

   /// Check for string equality.  This is more efficient than compare() when
   /// the relative ordering of inequal strings isn't needed.
   bool equals(StringRef RHS) const {
-    return str().equals(RHS);
+    return StringRef().equals(RHS);
   }
 
   /// Check for string equality, ignoring case.
   bool equals_lower(StringRef RHS) const {
-    return str().equals_lower(RHS);
+    return StringRef().equals_lower(RHS);
   }
 
   /// Compare two strings; the result is -1, 0, or 1 if this string is
   /// lexicographically less than, equal to, or greater than the \p RHS.
   int compare(StringRef RHS) const {
-    return str().compare(RHS);
+    return StringRef().compare(RHS);
   }
 
   /// compare_lower - Compare two strings, ignoring case.
   int compare_lower(StringRef RHS) const {
-    return str().compare_lower(RHS);
+    return StringRef().compare_lower(RHS);
   }
 
   /// compare_numeric - Compare two strings, treating sequences of digits as
   /// numbers.
   int compare_numeric(StringRef RHS) const {
-    return str().compare_numeric(RHS);
+    return StringRef().compare_numeric(RHS);
   }
 
   /// @}

 
   /// startswith - Check if this string starts with the given \p Prefix.
   bool startswith(StringRef Prefix) const {
-    return str().startswith(Prefix);
+    return StringRef().startswith(Prefix);
   }
 
   /// endswith - Check if this string ends with the given \p Suffix.
   bool endswith(StringRef Suffix) const {
-    return str().endswith(Suffix);
+    return StringRef().endswith(Suffix);
   }
 
   /// @}

   /// \return - The index of the first occurrence of \p C, or npos if not
   /// found.
   size_t find(char C, size_t From = 0) const {
-    return str().find(C, From);
+    return StringRef().find(C, From);
   }
 
   /// Search for the first string \p Str in the string.

   /// \returns The index of the first occurrence of \p Str, or npos if not
   /// found.
   size_t find(StringRef Str, size_t From = 0) const {
-    return str().find(Str, From);
+    return StringRef().find(Str, From);
   }
 
   /// Search for the last character \p C in the string.

   /// \returns The index of the last occurrence of \p C, or npos if not
   /// found.
   size_t rfind(char C, size_t From = StringRef::npos) const {
-    return str().rfind(C, From);
+    return StringRef().rfind(C, From);
   }
 
   /// Search for the last string \p Str in the string.

   /// \returns The index of the last occurrence of \p Str, or npos if not
   /// found.
   size_t rfind(StringRef Str) const {
-    return str().rfind(Str);
+    return StringRef().rfind(Str);
   }
 
   /// Find the first character in the string that is \p C, or npos if not
   /// found. Same as find.
   size_t find_first_of(char C, size_t From = 0) const {
-    return str().find_first_of(C, From);
+    return StringRef().find_first_of(C, From);
   }
 
   /// Find the first character in the string that is in \p Chars, or npos if

   ///
   /// Complexity: O(size() + Chars.size())
   size_t find_first_of(StringRef Chars, size_t From = 0) const {
-    return str().find_first_of(Chars, From);
+    return StringRef().find_first_of(Chars, From);
   }
 
   /// Find the first character in the string that is not \p C or npos if not
   /// found.
   size_t find_first_not_of(char C, size_t From = 0) const {
-    return str().find_first_not_of(C, From);
+    return StringRef().find_first_not_of(C, From);
   }
 
   /// Find the first character in the string that is not in the string

   ///
   /// Complexity: O(size() + Chars.size())
   size_t find_first_not_of(StringRef Chars, size_t From = 0) const {
-    return str().find_first_not_of(Chars, From);
+    return StringRef().find_first_not_of(Chars, From);
   }
 
   /// Find the last character in the string that is \p C, or npos if not
   /// found.
   size_t find_last_of(char C, size_t From = StringRef::npos) const {
-    return str().find_last_of(C, From);
+    return StringRef().find_last_of(C, From);
   }
 
   /// Find the last character in the string that is in \p C, or npos if not

   /// Complexity: O(size() + Chars.size())
   size_t find_last_of(
       StringRef Chars, size_t From = StringRef::npos) const {
-    return str().find_last_of(Chars, From);
+    return StringRef().find_last_of(Chars, From);
   }
 
   /// @}

 
   /// Return the number of occurrences of \p C in the string.
   size_t count(char C) const {
-    return str().count(C);
+    return StringRef().count(C);
   }
 
   /// Return the number of non-overlapped occurrences of \p Str in the
   /// string.
   size_t count(StringRef Str) const {
-    return str().count(Str);
+    return StringRef().count(Str);
   }
 
   /// @}
+  /// @name String Operations
+  /// @{
+
+  // Convert the given ASCII string to lowercase.
+  std::string lower() const { return StringRef().lower(); }
+
+  /// Convert the given ASCII string to uppercase.
+  std::string upper() const { return StringRef().upper(); }
+
+  /// @}
   /// @name Substring Operations
   /// @{
 

   /// exceeds the number of characters remaining in the string, the string
   /// suffix (starting with \p Start) will be returned.
   StringRef substr(size_t Start, size_t N = StringRef::npos) const {
-    return str().substr(Start, N);
+    return StringRef().substr(Start, N);
   }
 
   /// Return a reference to the substring from [Start, End).

   /// number of characters remaining in the string, the string suffix
   /// (starting with \p Start) will be returned.
   StringRef slice(size_t Start, size_t End) const {
-    return str().slice(Start, End);
+    return StringRef().slice(Start, End);
   }
 
   // Extra methods.
 
-  /// Explicit conversion to StringRef.
-  StringRef str() const { return StringRef(this->begin(), this->size()); }
+  /// Explicit conversion to std::string.
+  std::string to_str() const { return std::string(begin(), size()); }
 
   // TODO: Make this const, if it's safe...
   const char* c_str() {

   }
 
   /// Implicit conversion to StringRef.
-  operator StringRef() const { return str(); }
+  operator StringRef() const { return StringRef(begin(), size()); }
 
   // Extra operators.
   const SmallString &operator=(StringRef RHS) {

include/llvm/ADT/Twine.h

 #ifndef LLVM_ADT_TWINE_H
 #define LLVM_ADT_TWINE_H
 
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"

       /// A pointer to a StringRef instance.
       StringRefKind,
 
+      /// A pointer to a SmallString instance.
+      SmallStringKind,
+
       /// A char value reinterpreted as a pointer, to render as a character.
       CharKind,
 

       const char *cString;
       const std::string *stdString;
       const StringRef *stringRef;
+      const SmallVectorImpl<char> *smallString;
       char character;
       unsigned int decUI;
       int decI;

       assert(isValid() && "Invalid twine!");
     }
 
+    /// Construct from a SmallString.
+    /*implicit*/ Twine(const SmallVectorImpl<char> &Str)
+      : LHSKind(SmallStringKind), RHSKind(EmptyKind) {
+      LHS.smallString = &Str;
+      assert(isValid() && "Invalid twine!");
+    }
+
     /// Construct from a char.
     explicit Twine(char Val)
       : LHSKind(CharKind), RHSKind(EmptyKind) {

       case CStringKind:
       case StdStringKind:
       case StringRefKind:
+      case SmallStringKind:
         return true;
       default:
         return false;

       case CStringKind:    return StringRef(LHS.cString);
       case StdStringKind:  return StringRef(*LHS.stdString);
       case StringRefKind:  return *LHS.stringRef;
+      case SmallStringKind:return StringRef(LHS.smallString->data(),LHS.smallString->size());
       }
     }
 

include/llvm/MC/MCContext.h

     /// reference and return it.
     ///
     /// @param Name - The symbol name, which must be unique across all symbols.
+    MCSymbol *GetOrCreateSymbol(const SmallVectorImpl<char> &Name) {
+      return GetOrCreateSymbol(StringRef(Name.data(), Name.size()));
+    }
     MCSymbol *GetOrCreateSymbol(StringRef Name);
     MCSymbol *GetOrCreateSymbol(const Twine &Name);
 

include/llvm/Option/ArgList.h

   const char *MakeArgString(std::string Str) const {
     return MakeArgString(StringRef(Str));
   }
+  const char *MakeArgString(const SmallVectorImpl<char> &Str) const {
+    return MakeArgString(StringRef(Str.data(), Str.size()));
+  }
   const char *MakeArgString(const Twine &Str) const;
 
   /// \brief Create an arg string for (\p LHS + \p RHS), reusing the

include/llvm/Support/FileUtilities.h

     ~FileRemover() {
       if (DeleteIt) {
         // Ignore problems deleting the file.
-        sys::fs::remove(Filename.str());
+        sys::fs::remove(Filename);
       }
     }
 

     void setFile(const Twine& filename, bool deleteIt = true) {
       if (DeleteIt) {
         // Ignore problems deleting the file.
-        sys::fs::remove(Filename.str());
+        sys::fs::remove(Filename);
       }
 
       Filename.clear();

include/llvm/Support/raw_ostream.h

 #ifndef LLVM_SUPPORT_RAW_OSTREAM_H
 #define LLVM_SUPPORT_RAW_OSTREAM_H
 
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"

     return write(Str.data(), Str.length());
   }
 
+  raw_ostream &operator<<(const llvm::SmallVectorImpl<char> &Str) {
+    return write(Str.data(), Str.size());
+  }
+
   raw_ostream &operator<<(unsigned long N);
   raw_ostream &operator<<(long N);
   raw_ostream &operator<<(unsigned long long N);

include/llvm/TableGen/StringToOffsetTable.h

     // Escape the string.
     SmallString<256> Str;
     raw_svector_ostream(Str).write_escaped(AggregateString);
-    AggregateString = Str.str();
+    AggregateString = Str.to_str();
 
     O << "    \"";
     unsigned CharsPrinted = 0;

lib/Bitcode/Reader/BitcodeReader.cpp

             assert(Record[i] == 0 && "Value string not null terminated");
           }
 
-          B.addAttribute(KindStr.str(), ValStr.str());
+          B.addAttribute(KindStr, ValStr);
         }
       }
 

       unsigned Kind = Record[0];
       SmallString<8> Name(Record.begin()+1, Record.end());
 
-      unsigned NewKind = TheModule->getMDKindID(Name.str());
+      unsigned NewKind = TheModule->getMDKindID(Name);
       if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
         return Error(BitcodeError::ConflictingMETADATA_KINDRecords);
       break;

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 MCSymbol *AsmPrinter::GetExternalSymbolSymbol(StringRef Sym) const {
   SmallString<60> NameStr;
   Mang->getNameWithPrefix(NameStr, Sym);
-  return OutContext.GetOrCreateSymbol(NameStr.str());
+  return OutContext.GetOrCreateSymbol(StringRef(NameStr));
 }
 
 

lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp

   SmallString<128> TmpStr;
   AP.Mang->getNameWithPrefix(TmpStr, SymName);
 
-  MCSymbol *Sym = AP.OutContext.GetOrCreateSymbol(TmpStr);
+  MCSymbol *Sym = AP.OutContext.GetOrCreateSymbol(StringRef(TmpStr));
 
   AP.OutStreamer.EmitSymbolAttribute(Sym, MCSA_Global);
   AP.OutStreamer.EmitLabel(Sym);

lib/CodeGen/MachineFunction.cpp

   SmallString<60> Name;
   raw_svector_ostream(Name)
     << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
-  return Ctx.GetOrCreateSymbol(Name.str());
+  return Ctx.GetOrCreateSymbol(Name);
 }
 
 /// getPICBaseSymbol - Return a function-local symbol to represent the PIC

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

                                                        const MCSymbol *Sym) const {
   SmallString<64> NameData("DW.ref.");
   NameData += Sym->getName();
-  MCSymbol *Label = getContext().GetOrCreateSymbol(NameData);
+  MCSymbol *Label = getContext().GetOrCreateSymbol(StringRef(NameData));
   Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
   Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
   StringRef Prefix = ".data.";

       Flags |= ELF::SHF_GROUP;
     }
 
-    return getContext().getELFSection(Name.str(),
-                                      getELFSectionType(Name.str(), Kind),
+    return getContext().getELFSection(Name,
+                                      getELFSectionType(Name, Kind),
                                       Flags, Kind, 0, Group);
   }
 

lib/DebugInfo/DWARFDebugLine.cpp

 
   // sys::path::append skips empty strings.
   sys::path::append(FilePath, IncludeDir, FileName);
-  Result = FilePath.str();
+  Result = FilePath.to_str();
   return true;
 }
 

lib/IR/AsmWriter.cpp

              (StrVal[1] >= '0' && StrVal[1] <= '9'))) {
           // Reparse stringized version!
           if (APFloat(APFloat::IEEEdouble, StrVal).convertToDouble() == Val) {
-            Out << StrVal.str();
+            Out << StrVal;
             return;
           }
         }

lib/IR/GCOV.cpp

 
   if (S < I)
     Result.append(S, I);
-  return Result.str();
+  return Result.to_str();
 }
 
 std::string FileInfo::getCoveragePath(StringRef Filename,

lib/LineEditor/LineEditor.cpp

   SmallString<32> Path;
   if (sys::path::home_directory(Path)) {
     sys::path::append(Path, "." + ProgName + "-history");
-    return Path.str();
+    return Path.to_str();
   }
   return std::string();
 }

lib/Linker/LinkModules.cpp

     if (!DstSTy->hasName() || DstSTy->getName().size() > SrcName.size()) {
       TmpName.insert(TmpName.end(), SrcName.begin(), SrcName.end());
       SrcSTy->setName("");
-      DstSTy->setName(TmpName.str());
+      DstSTy->setName(TmpName.to_str());
       TmpName.clear();
     }
   }

lib/MC/MCAsmStreamer.cpp

   }
 
   CommentStream.flush();
-  StringRef Comments = CommentToEmit.str();
+  StringRef Comments = CommentToEmit;
 
   assert(Comments.back() == '\n' &&
          "Comment array not newline terminated");

lib/MC/MCAssembler.cpp

 
   case MCFragment::FT_LEB: {
     const MCLEBFragment &LF = cast<MCLEBFragment>(F);
-    OW->WriteBytes(LF.getContents().str());
+    OW->WriteBytes(LF.getContents());
     break;
   }
 

 
   case MCFragment::FT_Dwarf: {
     const MCDwarfLineAddrFragment &OF = cast<MCDwarfLineAddrFragment>(F);
-    OW->WriteBytes(OF.getContents().str());
+    OW->WriteBytes(OF.getContents());
     break;
   }
   case MCFragment::FT_DwarfFrame: {
     const MCDwarfCallFrameFragment &CF = cast<MCDwarfCallFrameFragment>(F);
-    OW->WriteBytes(CF.getContents().str());
+    OW->WriteBytes(CF.getContents());
     break;
   }
   }

lib/MC/MCContext.cpp

 MCSymbol *MCContext::LookupSymbol(const Twine &Name) const {
   SmallString<128> NameSV;
   Name.toVector(NameSV);
-  return LookupSymbol(NameSV.str());
+  return LookupSymbol(StringRef(NameSV));
 }
 
 //===----------------------------------------------------------------------===//

   Name += Section;
 
   // Do the lookup, if we have a hit, return it.
-  const MCSectionMachO *&Entry = MachOUniquingMap[Name.str()];
+  const MCSectionMachO *&Entry = MachOUniquingMap[Name];
   if (Entry) return Entry;
 
   // Otherwise, return a new section.

lib/MC/MCDisassembler/Disassembler.cpp

                          formatted_raw_ostream &FormattedOS) {
   // Flush the stream before taking its content.
   DC->CommentStream.flush();
-  StringRef Comments = DC->CommentsToEmit.str();
+  StringRef Comments = DC->CommentsToEmit;
   // Get the default information for printing a comment.
   const MCAsmInfo *MAI = DC->getAsmInfo();
   const char *CommentBegin = MAI->getCommentString();

lib/MC/MCDwarf.cpp

     Augmentation += "R";
     if (IsSignalFrame)
       Augmentation += "S";
-    streamer.EmitBytes(Augmentation.str());
+    streamer.EmitBytes(Augmentation);
   }
   streamer.EmitIntValue(0, 1);
 

lib/Object/MachOObjectFile.cpp

   if (Stack.size() != Other.Stack.size())
     return false;
   // Not equal if different cumulative strings.
-  if (!CumulativeString.str().equals(Other.CumulativeString.str()))
+  if (!CumulativeString.equals(Other.CumulativeString))
     return false;
   // Equal if all nodes in both stacks match.
   for (unsigned i=0; i < Stack.size(); ++i) {

 }
 
 StringRef ExportEntry::name() const {
-  return CumulativeString.str();
+  return CumulativeString;
 }
 
 uint64_t ExportEntry::flags() const {

lib/Support/APInt.cpp

 std::string APInt::toString(unsigned Radix = 10, bool Signed = true) const {
   SmallString<40> S;
   toString(S, Radix, Signed, /* formatAsCLiteral = */false);
-  return S.str();
+  return S.to_str();
 }
 
 

   this->toStringUnsigned(U);
   this->toStringSigned(S);
   dbgs() << "APInt(" << BitWidth << "b, "
-         << U.str() << "u " << S.str() << "s)";
+         << U << "u " << S << "s)";
 }
 
 void APInt::print(raw_ostream &OS, bool isSigned) const {
   SmallString<40> S;
   this->toString(S, 10, isSigned, /* formatAsCLiteral = */false);
-  OS << S.str();
+  OS << S.to_str();
 }
 
 // This implements a variety of operations on a representation of

lib/Support/GraphWriter.cpp

   }
 
   errs() << "Writing '" << Filename << "'... ";
-  return Filename.str();
+  return Filename.to_str();
 }
 
 // Execute the graph viewer. Return true if there were errors.

lib/Support/LockFileManager.cpp

   UniqueLockFileName += "-%%%%%%%%";
   int UniqueLockFileID;
   if (std::error_code EC = sys::fs::createUniqueFile(
-          UniqueLockFileName.str(), UniqueLockFileID, UniqueLockFileName)) {
+          UniqueLockFileName, UniqueLockFileID, UniqueLockFileName)) {
     Error = EC;
     return;
   }

   while (1) {
     // Create a link from the lock file name. If this succeeds, we're done.
     std::error_code EC =
-        sys::fs::create_link(UniqueLockFileName.str(), LockFileName.str());
+        sys::fs::create_link(UniqueLockFileName, LockFileName);
     if (!EC)
       return;
 

     // from the lock file.
     if ((Owner = readLockFile(LockFileName))) {
       // Wipe out our unique lock file (it's useless now)
-      sys::fs::remove(UniqueLockFileName.str());
+      sys::fs::remove(UniqueLockFileName);
       return;
     }
 
-    if (!sys::fs::exists(LockFileName.str())) {
+    if (!sys::fs::exists(LockFileName)) {
       // The previous owner released the lock file before we could read it.
       // Try to get ownership again.
       continue;

 
     // There is a lock file that nobody owns; try to clean it up and get
     // ownership.
-    if ((EC = sys::fs::remove(LockFileName.str()))) {
+    if ((EC = sys::fs::remove(LockFileName))) {
       Error = EC;
       return;
     }

     return;
 
   // Since we own the lock, remove the lock file and our own unique lock file.
-  sys::fs::remove(LockFileName.str());
-  sys::fs::remove(UniqueLockFileName.str());
+  sys::fs::remove(LockFileName);
+  sys::fs::remove(UniqueLockFileName);
 }
 
 LockFileManager::WaitForUnlockResult LockFileManager::waitForUnlock() {

     // If the lock file is no longer there, check if the original file is
     // available now.
     if (LockFileGone) {
-      if (sys::fs::exists(FileName.str())) {
+      if (sys::fs::exists(FileName)) {
         return Res_Success;
       }
 

lib/Support/Path.cpp

   SmallString<128> path(Path.begin(), Path.end());
   path::remove_filename(path);
   path::append(path, filename);
-  Path = path.str();
+  Path = path.to_str();
   Status = st;
 }
 

lib/Support/Process.cpp

     SmallString<128> FilePath(Dir);
     path::append(FilePath, FileName);
     if (fs::exists(Twine(FilePath))) {
-      FoundPath = FilePath.str();
+      FoundPath = FilePath.to_str();
       break;
     }
   }

lib/Support/Triple.cpp

   Triple += getVendorName();
   Triple += "-";
   Triple += getOSAndEnvironmentName();
-  setTriple(Triple.str());
+  setTriple(Triple);
 }
 
 void Triple::setVendorName(StringRef Str) {

lib/Support/Twine.cpp

   case Twine::StringRefKind:
     OS << *Ptr.stringRef;
     break;
+  case Twine::SmallStringKind:
+    OS << *Ptr.smallString;
+    break;
   case Twine::CharKind:
     OS << Ptr.character;
     break;

     OS << "stringref:\""
        << Ptr.stringRef << "\"";
     break;
+  case Twine::SmallStringKind:
+    OS << "smallstring:\""
+       << Ptr.smallString << "\"";
+    break;
   case Twine::CharKind:
     OS << "char:\"" << Ptr.character << "\"";
     break;

lib/Support/Windows/Path.inc

 
   it.IterationHandle = intptr_t(FindHandle.take());
   SmallString<128> directory_entry_path(path);
-  path::append(directory_entry_path, directory_entry_name_utf8.str());
-  it.CurrentEntry = directory_entry(directory_entry_path.str());
+  path::append(directory_entry_path, directory_entry_name_utf8);
+  it.CurrentEntry = directory_entry(directory_entry_path);
 
   return std::error_code();
 }

lib/Target/TargetLoweringObjectFile.cpp

   NameStr += DL->getPrivateGlobalPrefix();
   TM.getNameWithPrefix(NameStr, GV, Mang);
   NameStr.append(Suffix.begin(), Suffix.end());
-  return Ctx->GetOrCreateSymbol(NameStr.str());
+  return Ctx->GetOrCreateSymbol(NameStr);
 }
 
 MCSymbol *TargetLoweringObjectFile::getCFIPersonalitySymbol(

lib/Target/TargetMachine.cpp

   getNameWithPrefix(NameStr, GV, Mang);
   const TargetLoweringObjectFile &TLOF =
       getSubtargetImpl()->getTargetLowering()->getObjFileLowering();
-  return TLOF.getContext().GetOrCreateSymbol(NameStr.str());
+  return TLOF.getContext().GetOrCreateSymbol(NameStr);
 }

lib/Target/X86/AsmParser/X86AsmParser.cpp

   SmallString<16> Tmp;
   Tmp += Base;
   Tmp += ' ';
-  Op.setTokenValue(Tmp.str());
+  Op.setTokenValue(Tmp);
 
   // If this instruction starts with an 'f', then it is a floating point stack
   // instruction.  These come in up to three forms for 32-bit, 64-bit, and

lib/Transforms/Instrumentation/GCOVProfiling.cpp

       if (CompileUnit == CU) {
         SmallString<128> Filename = GCovFile->getString();
         sys::path::replace_extension(Filename, NewStem);
-        return Filename.str();
+        return Filename.to_str();
       }
     }
   }

   SmallString<128> CurPath;
   if (sys::fs::current_path(CurPath)) return FName;
   sys::path::append(CurPath, FName.str());
-  return CurPath.str();
+  return CurPath.to_str();
 }
 
 bool GCOVProfiler::runOnModule(Module &M) {

tools/bugpoint/ExecutionDriver.cpp

            << "\n";
     exit(1);
   }
-  if (writeProgramToFile(BitcodeFile.str(), BitcodeFD, M)) {
+  if (writeProgramToFile(BitcodeFile.to_str(), BitcodeFD, M)) {
     errs() << ToolName << ": Error emitting bitcode to file '" << BitcodeFile
            << "'!\n";
     exit(1);

   }
 
   // Remove the temporary bitcode file when we are done.
-  FileRemover BitcodeFileRemover(BitcodeFile.str(), !SaveTemps);
+  FileRemover BitcodeFileRemover(BitcodeFile, !SaveTemps);
 
   // Actually compile the program!
-  Interpreter->compileProgram(BitcodeFile.str(), Error, Timeout, MemoryLimit);
+  Interpreter->compileProgram(BitcodeFile.to_str(), Error, Timeout, MemoryLimit);
 }
 
 

              << EC.message() << "!\n";
       exit(1);
     }
-    BitcodeFile = UniqueFilename.str();
+    BitcodeFile = UniqueFilename.to_str();
 
     if (writeProgramToFile(BitcodeFile, UniqueFD, Program)) {
       errs() << ToolName << ": Error emitting bitcode to file '"

            << EC.message() << "\n";
     exit(1);
   }
-  OutputFile = UniqueFile.str();
+  OutputFile = UniqueFile.to_str();
 
   // Figure out which shared objects to run, if any.
   std::vector<std::string> SharedObjs(AdditionalSOs);

tools/bugpoint/ExtractFunction.cpp

   BlocksToNotExtractFile.keep();
 
   std::string uniqueFN = "--extract-blocks-file=";
-  uniqueFN += Filename.str();
+  uniqueFN += Filename.to_str();
   const char *ExtraArg = uniqueFN.c_str();
 
   std::vector<std::string> PI;

tools/bugpoint/Miscompilation.cpp

            << EC.message() << "\n";
     exit(1);
   }
-  if (BD.writeProgramToFile(TestModuleBC.str(), TestModuleFD, Test)) {
-    errs() << "Error writing bitcode to `" << TestModuleBC.str()
+  if (BD.writeProgramToFile(TestModuleBC.to_str(), TestModuleFD, Test)) {
+    errs() << "Error writing bitcode to `" << TestModuleBC
            << "'\nExiting.";
     exit(1);
   }
   delete Test;
 
-  FileRemover TestModuleBCRemover(TestModuleBC.str(), !SaveTemps);
+  FileRemover TestModuleBCRemover(TestModuleBC, !SaveTemps);
 
   // Make the shared library
   SmallString<128> SafeModuleBC;

     exit(1);
   }
 
-  if (BD.writeProgramToFile(SafeModuleBC.str(), SafeModuleFD, Safe)) {
-    errs() << "Error writing bitcode to `" << SafeModuleBC.str()
+  if (BD.writeProgramToFile(SafeModuleBC.to_str(), SafeModuleFD, Safe)) {
+    errs() << "Error writing bitcode to `" << SafeModuleBC
            << "'\nExiting.";
     exit(1);
   }
 
-  FileRemover SafeModuleBCRemover(SafeModuleBC.str(), !SaveTemps);
+  FileRemover SafeModuleBCRemover(SafeModuleBC, !SaveTemps);
 
-  std::string SharedObject = BD.compileSharedObject(SafeModuleBC.str(), Error);
+  std::string SharedObject =
+      BD.compileSharedObject(SafeModuleBC.to_str(), Error);
   if (!Error.empty())
     return false;
   delete Safe;

 
   // Run the code generator on the `Test' code, loading the shared library.
   // The function returns whether or not the new output differs from reference.
-  bool Result = BD.diffProgram(BD.getProgram(), TestModuleBC.str(),
+  bool Result = BD.diffProgram(BD.getProgram(), TestModuleBC.to_str(),
                                SharedObject, false, &Error);
   if (!Error.empty())
     return false;

     exit(1);
   }
 
-  if (writeProgramToFile(TestModuleBC.str(), TestModuleFD, ToCodeGen)) {
-    errs() << "Error writing bitcode to `" << TestModuleBC.str()
+  if (writeProgramToFile(TestModuleBC.to_str(), TestModuleFD, ToCodeGen)) {
+    errs() << "Error writing bitcode to `" << TestModuleBC
            << "'\nExiting.";
     exit(1);
   }

     exit(1);
   }
 
-  if (writeProgramToFile(SafeModuleBC.str(), SafeModuleFD, ToNotCodeGen)) {
-    errs() << "Error writing bitcode to `" << SafeModuleBC.str()
+  if (writeProgramToFile(SafeModuleBC.to_str(), SafeModuleFD, ToNotCodeGen)) {
+    errs() << "Error writing bitcode to `" << SafeModuleBC
            << "'\nExiting.";
     exit(1);
   }
-  std::string SharedObject = compileSharedObject(SafeModuleBC.str(), *Error);
+  std::string SharedObject = compileSharedObject(SafeModuleBC.to_str(), *Error);
   if (!Error->empty())
     return true;
   delete ToNotCodeGen;

 
   outs() << "You can reproduce the problem with the command line: \n";
   if (isExecutingJIT()) {
-    outs() << "  lli -load " << SharedObject << " " << TestModuleBC.str();
+    outs() << "  lli -load " << SharedObject << " " << TestModuleBC;
   } else {
-    outs() << "  llc " << TestModuleBC.str() << " -o " << TestModuleBC.str()
+    outs() << "  llc " << TestModuleBC << " -o " << TestModuleBC
            << ".s\n";
-    outs() << "  gcc " << SharedObject << " " << TestModuleBC.str()
-              << ".s -o " << TestModuleBC.str() << ".exe";
+    outs() << "  gcc " << SharedObject << " " << TestModuleBC
+              << ".s -o " << TestModuleBC << ".exe";
 #if defined (HAVE_LINK_R)
     outs() << " -Wl,-R.";
 #endif
     outs() << "\n";
-    outs() << "  " << TestModuleBC.str() << ".exe";
+    outs() << "  " << TestModuleBC << ".exe";
   }
   for (unsigned i = 0, e = InputArgv.size(); i != e; ++i)
     outs() << " " << InputArgv[i];
   outs() << '\n';
   outs() << "The shared object was created with:\n  llc -march=c "
-         << SafeModuleBC.str() << " -o temporary.c\n"
+         << SafeModuleBC << " -o temporary.c\n"
          << "  gcc -xc temporary.c -O2 -o " << SharedObject;
   if (TargetTriple.getArch() == Triple::sparc)
     outs() << " -G";              // Compile a shared library, `-G' for Sparc

tools/bugpoint/OptimizerDriver.cpp

            << EC.message() << "\n";
     return 1;
   }
-  OutputFilename = UniqueFilename.str();
+  OutputFilename = UniqueFilename.to_str();
 
   // set up the input file name
   SmallString<128> InputFilename;

tools/bugpoint/ToolRunner.cpp

     exit(1);
   }
 
-  RunProgramWithTimeout(ProgPath, Args, "", ErrorFilename.str(),
-                        ErrorFilename.str(), Timeout, MemoryLimit);
+  RunProgramWithTimeout(ProgPath, Args, "", ErrorFilename,
+                        ErrorFilename, Timeout, MemoryLimit);
   // FIXME: check return code ?
 
   // Print out the error messages generated by GCC if possible...

     SmallString<128> Storage = Result;
     sys::path::append(Storage, ExeName);
     sys::path::replace_extension(Storage, EXESuffix);
-    return Storage.str();
+    return Storage.to_str();
   }
 
   return Result.str();

     errs() << "Error making unique filename: " << EC.message() << "\n";
     exit(1);
   }
-  OutputAsmFile = UniqueFile.str();
+  OutputAsmFile = UniqueFile.to_str();
   std::vector<const char *> LLCArgs;
   LLCArgs.push_back(LLCPath.c_str());
 

         errs() << "\n";
         );
 
-  FileRemover OutputBinaryRemover(OutputBinary.str(), !SaveTemps);
+  FileRemover OutputBinaryRemover(OutputBinary, !SaveTemps);
 
   if (RemoteClientPath.empty()) {
     DEBUG(errs() << "<run locally>");
-    int ExitCode = RunProgramWithTimeout(OutputBinary.str(), &ProgramArgs[0],
+    int ExitCode = RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
                                          InputFile, OutputFile, OutputFile,
                                          Timeout, MemoryLimit, Error);
     // Treat a signal (usually SIGSEGV) or timeout as part of the program output

     errs() << "Error making unique filename: " << EC.message() << "\n";
     exit(1);
   }
-  OutputFile = UniqueFilename.str();
+  OutputFile = UniqueFilename.to_str();
 
   std::vector<const char*> GCCArgs;
 

tools/clang/lib/ARCMigrate/ARCMT.cpp

             StringRef(newText.data(), newText.size()), newFname));
     SmallString<64> filePath(file->getName());
     Unit->getFileManager().FixupRelativePath(filePath);
-    Remapper.remap(filePath.str(), std::move(memBuf));
+    Remapper.remap(filePath, std::move(memBuf));
   }
 
   return false;

tools/clang/lib/ARCMigrate/FileRemapper.cpp

   assert(!outputDir.empty());
   SmallString<128> InfoFile = outputDir;
   llvm::sys::path::append(InfoFile, "remap");
-  return InfoFile.str();
+  return InfoFile.to_str();
 }
 
 bool FileRemapper::initFromDisk(StringRef outputDir, DiagnosticsEngine &Diag,

       if (fs::createTemporaryFile(path::filename(origFE->getName()),
                                   path::extension(origFE->getName()), fd,
                                   tempPath))
-        return report("Could not create file: " + tempPath.str(), Diag);
+        return report("Could not create file: " + tempPath, Diag);
 
       llvm::raw_fd_ostream newOut(fd, /*shouldClose=*/true);
       llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();

tools/clang/lib/ARCMigrate/ObjCMT.cpp

           StringRef(SourceMgr.getFileEntryForID(FID)->getName());
       llvm::sys::fs::make_absolute(Path);
       OS << "  \"file\": \"";
-      OS.write_escaped(Path.str()) << "\",\n";
+      OS.write_escaped(Path) << "\",\n";
       OS << "  \"offset\": " << Offset << ",\n";
     }
 

             StringRef(newText.data(), newText.size()), file->getName()));
     SmallString<64> filePath(file->getName());
     FileMgr.FixupRelativePath(filePath);
-    Remapper.remap(filePath.str(), std::move(memBuf));
+    Remapper.remap(filePath, std::move(memBuf));
   }
 
   if (IsOutputFile) {

   if (fs::createTemporaryFile(path::filename(FE->getName()),
                               path::extension(FE->getName()), FD,
                               TempPath)) {
-    reportDiag("Could not create file: " + TempPath.str(), Diag);
+    reportDiag("Could not create file: " + TempPath, Diag);
     return std::string();
   }
 

   TmpOut.write(NewText.data(), NewText.size());
   TmpOut.close();
 
-  return TempPath.str();
+  return TempPath.to_str();
 }
 
 bool arcmt::getFileRemappingsFromFileList(

tools/clang/lib/ARCMigrate/TransUnbridgedCasts.cpp

         newCast += ')';
 
         if (isa<ParenExpr>(E->getSubExpr())) {
-          TA.insert(insertLoc, newCast.str());
+          TA.insert(insertLoc, newCast);
         } else {
           newCast += '(';
-          TA.insert(insertLoc, newCast.str());
+          TA.insert(insertLoc, newCast);
           TA.insertAfterToken(E->getLocEnd(), ")");
         }
       }

tools/clang/lib/AST/DeclObjC.cpp

     llvm::raw_svector_ostream os(ivarName);
     os << '_' << getIdentifier()->getName();
   }
-  return &Ctx.Idents.get(ivarName.str());
+  return &Ctx.Idents.get(ivarName);
 }
 
 /// FindPropertyDeclaration - Finds declaration of the property given its name

tools/clang/lib/AST/Expr.cpp

         Out.flush();
         if (!Buffer.empty() && Buffer.front() == '\01')
           return Buffer.substr(1);
-        return Buffer.str();
+        return Buffer.to_str();
       } else
         return ND->getIdentifier()->getName();
     }

     Out << Proto;
 
     Out.flush();
-    return Name.str().str();
+    return Name.to_str();
   }
   if (const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
     for (const DeclContext *DC = CD->getParent(); DC; DC = DC->getParent())

     Out <<  ']';
 
     Out.flush();
-    return Name.str().str();
+    return Name.to_str();
   }
   if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) {
     // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.

tools/clang/lib/AST/ItaniumMangle.cpp

     Str += llvm::utostr(AnonStructId);
 
     Out << Str.size();
-    Out << Str.str();
+    Out << Str;
     break;
   }
 

tools/clang/lib/AST/MicrosoftMangle.cpp

         llvm::SmallString<64> Name("$S");
         // Get a unique id for the anonymous struct.
         Name += llvm::utostr(Context.getAnonymousStructId(RD) + 1);
-        mangleSourceName(Name.str());
+        mangleSourceName(Name);
         break;
       }
 

         Name += llvm::utostr(Context.getAnonymousStructId(TD));
       }
       Name += ">";
-      mangleSourceName(Name.str());
+      mangleSourceName(Name);
       break;
     }
 

tools/clang/lib/Basic/FileManager.cpp

 
   SmallString<128> FilePath(Entry->getName());
   FixupRelativePath(FilePath);
-  return FS->getBufferForFile(FilePath.str(), FileSize,
+  return FS->getBufferForFile(FilePath, FileSize,
                               /*RequiresNullTerminator=*/true, isVolatile);
 }
 

tools/clang/lib/Basic/VirtualFileSystem.cpp

   if (Current != End) {
     SmallString<128> PathStr(Dir);
     llvm::sys::path::append(PathStr, (*Current)->getName());
-    llvm::ErrorOr<vfs::Status> S = FS.status(PathStr.str());
+    llvm::ErrorOr<vfs::Status> S = FS.status(PathStr);
     if (S)
       CurrentEntry = *S;
     else

   if (++Current != End) {
     SmallString<128> PathStr(Dir);
     llvm::sys::path::append(PathStr, (*Current)->getName());
-    llvm::ErrorOr<vfs::Status> S = FS.status(PathStr.str());
+    llvm::ErrorOr<vfs::Status> S = FS.status(PathStr);
     if (!S)
       return S.getError();
     CurrentEntry = *S;

tools/clang/lib/CodeGen/CGDebugInfo.cpp

     if (MainFileDir != ".") {
       llvm::SmallString<1024> MainFileDirSS(MainFileDir);
       llvm::sys::path::append(MainFileDirSS, MainFileName);
-      MainFileName = MainFileDirSS.str();
+      MainFileName = MainFileDirSS.to_str();
     }
   }
 

   llvm::DIArray fieldsArray = DBuilder.getOrCreateArray(fields);
 
   llvm::DIType type =
-      DBuilder.createStructType(tunit, typeName.str(), tunit, line,
+      DBuilder.createStructType(tunit, typeName, tunit, line,
                                 CGM.getContext().toBits(block.BlockSize),
                                 CGM.getContext().toBits(block.BlockAlign), 0,
                                 llvm::DIType(), fieldsArray);

tools/clang/lib/CodeGen/CGDeclCXX.cpp

     llvm::raw_svector_ostream Out(FnName);
     CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&VD, Out);
   }
-  llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(ty, FnName.str(),
+  llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(ty, FnName,
                                                               VD.getLocation());
 
   CodeGenFunction CGF(CGM);

 
   // Create a variable initialization function.
   llvm::Function *Fn =
-      CreateGlobalInitOrDestructFunction(FTy, FnName.str(), D->getLocation());
+      CreateGlobalInitOrDestructFunction(FTy, FnName, D->getLocation());
 
   auto *ISA = D->getAttr<InitSegAttr>();
   CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr,

tools/clang/lib/CodeGen/CGObjCMac.cpp

   Values[0] = GetClassName(OCD->getName());
   Values[1] = GetClassName(Interface->getObjCRuntimeNameAsString());
   LazySymbols.insert(Interface->getIdentifier());
-  Values[2] = EmitMethodList("OBJC_CATEGORY_INSTANCE_METHODS_" + ExtName.str(),
+  Values[2] = EmitMethodList("OBJC_CATEGORY_INSTANCE_METHODS_" + ExtName,
                              "__OBJC,__cat_inst_meth,regular,no_dead_strip",
                              InstanceMethods);
-  Values[3] = EmitMethodList("OBJC_CATEGORY_CLASS_METHODS_" + ExtName.str(),
+  Values[3] = EmitMethodList("OBJC_CATEGORY_CLASS_METHODS_" + ExtName,
                              "__OBJC,__cat_cls_meth,regular,no_dead_strip",
                              ClassMethods);
   if (Category) {
     Values[4] =
-        EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
+        EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName,
                          Category->protocol_begin(), Category->protocol_end());
   } else {
     Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);

 
   // If there is no category @interface then there can be no properties.
   if (Category) {
-    Values[6] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
+    Values[6] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName,
                                  OCD, Category, ObjCTypes);
   } else {
     Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);

                                                    Values);
 
   llvm::GlobalVariable *GV =
-      CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Init,
+      CreateMetadataVar("OBJC_CATEGORY_" + ExtName, Init,
                         "__OBJC,__category,regular,no_dead_strip", 4, true);
   DefinedCategories.push_back(GV);
-  DefinedCategoryNames.insert(ExtName.str());
+  DefinedCategoryNames.insert(ExtName.to_str());
   // method definition entries must be clear for next implementation.
   MethodDefinitions.clear();
 }

   llvm::Function *Method =
     llvm::Function::Create(MethodTy,
                            llvm::GlobalValue::InternalLinkage,
-                           Name.str(),
+                           Name,
                            &CGM.getModule());
   MethodDefinitions.insert(std::make_pair(OMD, Method));
 

     flags |= NonFragileABI_Class_Root;
     TClassName = ObjCClassName;
     TClassName += ClassName;
-    SuperClassGV = GetClassGlobal(TClassName.str(),
+    SuperClassGV = GetClassGlobal(TClassName.to_str(),
                                   ID->getClassInterface()->isWeakImported());
     TClassName = ObjCMetaClassName;
     TClassName += ClassName;
-    IsAGV = GetClassGlobal(TClassName.str(),
+    IsAGV = GetClassGlobal(TClassName.to_str(),
                            ID->getClassInterface()->isWeakImported());
   } else {
     // Has a root. Current class is not a root.

       Root = Super;
     TClassName = ObjCMetaClassName ;
     TClassName += Root->getObjCRuntimeNameAsString();
-    IsAGV = GetClassGlobal(TClassName.str(),
+    IsAGV = GetClassGlobal(TClassName.to_str(),
                            Root->isWeakImported());
 
     // work on super class metadata symbol.

     TClassName = ObjCMetaClassName;
     TClassName += ID->getClassInterface()->getSuperClass()->getObjCRuntimeNameAsString();
     SuperClassGV = GetClassGlobal(
-                                  TClassName.str(),
+                                  TClassName.to_str(),
                                   ID->getClassInterface()->getSuperClass()->isWeakImported());
   }
   llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags,

   TClassName = ObjCMetaClassName;
   TClassName += ClassName;
   llvm::GlobalVariable *MetaTClass = BuildClassMetaData(
-      TClassName.str(), IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden,
+      TClassName.to_str(), IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden,
       ID->getClassInterface()->isWeakImported());
   DefinedMetaClasses.push_back(MetaTClass);
 

     TClassName = ObjCClassName;
     TClassName += ID->getClassInterface()->getSuperClass()->getObjCRuntimeNameAsString();
     SuperClassGV = GetClassGlobal(
-                                  TClassName.str(),
+                                  TClassName.to_str(),
                                   ID->getClassInterface()->getSuperClass()->isWeakImported());
   }
   GetClassSizeInfo(ID, InstanceStart, InstanceSize);

   TClassName = ObjCClassName;
   TClassName += ClassName;
   llvm::GlobalVariable *ClassMD =
-    BuildClassMetaData(TClassName.str(), MetaTClass, SuperClassGV, CLASS_RO_GV,
+    BuildClassMetaData(TClassName.to_str(), MetaTClass, SuperClassGV, CLASS_RO_GV,
                        classIsHidden,
                        ID->getClassInterface()->isWeakImported());
   DefinedClasses.push_back(ClassMD);

   Values[0] = GetClassName(OCD->getIdentifier()->getName());
   // meta-class entry symbol
   llvm::GlobalVariable *ClassGV =
-      GetClassGlobal(ExtClassName.str(), Interface->isWeakImported());
+      GetClassGlobal(ExtClassName.to_str(), Interface->isWeakImported());
 
   Values[1] = ClassGV;
   std::vector<llvm::Constant*> Methods;

     // Instance methods should always be defined.
     Methods.push_back(GetMethodConstant(I));
 
-  Values[2] = EmitMethodList(MethodListName.str(),
+  Values[2] = EmitMethodList(MethodListName,
                              "__DATA, __objc_const",
                              Methods);
 

     // Class methods should always be defined.
     Methods.push_back(GetMethodConstant(I));
 
-  Values[3] = EmitMethodList(MethodListName.str(),
+  Values[3] = EmitMethodList(MethodListName,
                              "__DATA, __objc_const",
                              Methods);
   const ObjCCategoryDecl *Category =

                                    + Category->getName(),
                                    Category->protocol_begin(),
                                    Category->protocol_end());
-    Values[5] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
+    Values[5] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName,
                                  OCD, Category, ObjCTypes);
   } else {
     Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);

                                false,
                                llvm::GlobalValue::PrivateLinkage,
                                Init,
-                               ExtCatName.str());
+                               ExtCatName);
   GCATV->setAlignment(
     CGM.getDataLayout().getABITypeAlignment(ObjCTypes.CategorynfABITy));
   GCATV->setSection("__DATA, __objc_const");

   if (!IvarOffsetGV)
     IvarOffsetGV = new llvm::GlobalVariable(
       CGM.getModule(), ObjCTypes.IvarOffsetVarTy, false,
-      llvm::GlobalValue::ExternalLinkage, nullptr, Name.str());
+      llvm::GlobalValue::ExternalLinkage, nullptr, Name);
   return IvarOffsetGV;
 }
 

   SmallString<256> TmpName;
   Name.toVector(TmpName);
   llvm::GlobalVariable *GV =
-    CGM.getModule().getGlobalVariable(TmpName.str(), true);
+    CGM.getModule().getGlobalVariable(TmpName, true);
   if (GV)
     return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
 

   if (!Entry) {
     llvm::SmallString<64> ClassName(getClassSymbolPrefix());
     ClassName += ID->getObjCRuntimeNameAsString();
-    llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName.str(),
+    llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName.to_str(),
                                                    ID->isWeakImported());
     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
                                      false, llvm::GlobalValue::PrivateLinkage,

     llvm::SmallString<64> MetaClassName(getMetaclassSymbolPrefix());
     MetaClassName += ID->getObjCRuntimeNameAsString();
     llvm::GlobalVariable *MetaClassGV =
-      GetClassGlobal(MetaClassName.str(), Weak);
+      GetClassGlobal(MetaClassName.to_str(), Weak);
 
     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
                                      false, llvm::GlobalValue::PrivateLinkage,

   if (ID->isWeakImported()) {
     llvm::SmallString<64> ClassName(getClassSymbolPrefix());
     ClassName += ID->getObjCRuntimeNameAsString();
-    llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName.str(), true);
+    llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName.to_str(), true);
     (void)ClassGV;
     assert(ClassGV->hasExternalWeakLinkage());
   }

   llvm::Constant *Values[] = {
     llvm::ConstantExpr::getGetElementPtr(VTableGV, VTableIdx),
     GetClassName(ID->getObjCRuntimeNameAsString()),
-    GetClassGlobal(ClassName.str())
+    GetClassGlobal(ClassName.to_str())
   };
   llvm::Constant *Init =
     llvm::ConstantStruct::get(ObjCTypes.EHTypeTy, Values);

     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
                                      L,
                                      Init,
-                                     EHTYPEName.str());
+                                     EHTYPEName);
   }
   assert(Entry->getLinkage() == L);
 

tools/clang/lib/CodeGen/CGVTT.cpp

   cast<ItaniumMangleContext>(CGM.getCXXABI().getMangleContext())
       .mangleCXXVTT(RD, Out);
   Out.flush();
-  StringRef Name = OutName.str();
+  StringRef Name = OutName;
 
   // This will also defer the definition of the VTT.
   (void) CGM.getCXXABI().getAddrOfVTable(RD, CharUnits());

tools/clang/lib/CodeGen/CGVTables.cpp

       .mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(),
                            Base.getBase(), Out);
   Out.flush();
-  StringRef Name = OutName.str();
+  StringRef Name = OutName;
 
   llvm::ArrayType *ArrayType = 
     llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents());

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

   llvm::raw_svector_ostream Out(OutName);
   getMangleContext().mangleCXXVTable(RD, Out);
   Out.flush();
-  StringRef Name = OutName.str();
+  StringRef Name = OutName;
 
   ItaniumVTableContext &VTContext = CGM.getItaniumVTableContext();
   llvm::ArrayType *ArrayType = llvm::ArrayType::get(

     guard = new llvm::GlobalVariable(CGM.getModule(), guardTy,
                                      false, var->getLinkage(),
                                      llvm::ConstantInt::get(guardTy, 0),
-                                     guardName.str());
+                                     guardName);
     guard->setVisibility(var->getVisibility());
     // If the variable is thread-local, so is its guard variable.
     guard->setThreadLocalMode(var->getThreadLocalMode());

   llvm::FunctionType *FnTy = llvm::FunctionType::get(RetTy, false);
   llvm::Function *Wrapper =
       llvm::Function::Create(FnTy, getThreadLocalWrapperLinkage(VD, CGM),
-                             WrapperName.str(), &CGM.getModule());
+                             WrapperName, &CGM.getModule());
   // Always resolve references to the wrapper at link time.
   if (!Wrapper->hasLocalLinkage() && !isThreadWrapperReplaceable(VD, CGM))
     Wrapper->setVisibility(llvm::GlobalValue::HiddenVisibility);

     if (VD->hasDefinition()) {
       InitIsInitFunc = true;
       if (InitFunc)
-        Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),
+        Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName,
                                          InitFunc);
     } else {
       // Emit a weak global function referring to the initialization function.

       // its thread_local variables.
       llvm::FunctionType *FnTy = llvm::FunctionType::get(CGM.VoidTy, false);
       Init = llvm::Function::Create(
-          FnTy, llvm::GlobalVariable::ExternalWeakLinkage, InitFnName.str(),
+          FnTy, llvm::GlobalVariable::ExternalWeakLinkage, InitFnName,
           &CGM.getModule());
     }
 

   llvm::raw_svector_ostream Out(OutName);
   CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(Ty, Out);
   Out.flush();
-  StringRef Name = OutName.str();
+  StringRef Name = OutName;
 
   // We know that the mangled name of the type starts at index 4 of the
   // mangled name of the typename, so we can just index into it in order to

   llvm::raw_svector_ostream Out(OutName);
   CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
   Out.flush();
-  StringRef Name = OutName.str();
+  StringRef Name = OutName;
 
   // Look for an existing global.
   llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name);

   llvm::raw_svector_ostream Out(OutName);
   CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty, Out);
   Out.flush();
-  StringRef Name = OutName.str();
+  StringRef Name = OutName;
 
   llvm::GlobalVariable *OldGV = CGM.getModule().getNamedGlobal(Name);
   if (OldGV && !OldGV->isDeclaration()) {

tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp

     for (size_t J = 0, F = VFPtrs.size(); J != F; ++J) {
       SmallString<256> Name;
       mangleVFTableName(getMangleContext(), RD, VFPtrs[J], Name);
-      if (!ObservedMangledNames.insert(Name.str()).second)
+      if (!ObservedMangledNames.insert(Name).second)
         llvm_unreachable("Already saw this mangling before?");
     }
 #endif

         VFTable = llvm::GlobalAlias::create(
             cast<llvm::SequentialType>(VTableGEP->getType())->getElementType(),
             /*AddressSpace=*/0, llvm::GlobalValue::ExternalLinkage,
-            VFTableName.str(), VTableGEP, &CGM.getModule());
+            VFTableName, VTableGEP, &CGM.getModule());
       } else {
         // We don't need a GlobalAlias to be a symbol for the VTable if we won't
         // be referencing any RTTI data.  The GlobalVariable will end up being
         // an appropriate definition of the VFTable.
-        VTable->setName(VFTableName.str());
+        VTable->setName(VFTableName);
       }
 
       VFTable->setUnnamedAddr(true);

   llvm::FunctionType *ThunkTy = CGM.getTypes().GetFunctionType(FnInfo);
   llvm::Function *ThunkFn =
       llvm::Function::Create(ThunkTy, llvm::Function::ExternalLinkage,
-                             ThunkName.str(), &CGM.getModule());
+                             ThunkName, &CGM.getModule());
   assert(ThunkFn->getName() == ThunkName && "name was uniqued!");
 
   ThunkFn->setLinkage(MD->isExternallyVisible()

   llvm::raw_svector_ostream Out(OutName);
   getMangleContext().mangleCXXVBTable(RD, VBT.MangledPath, Out);
   Out.flush();
-  StringRef Name = OutName.str();
+  StringRef Name = OutName;
 
   llvm::ArrayType *VBTableType =
       llvm::ArrayType::get(CGM.IntTy, 1 + VBT.ReusingBase->getNumVBases());

     // visibility and dll storage class from the guarded variable.
     GI->Guard =
         new llvm::GlobalVariable(CGM.getModule(), GuardTy, false,
-                                 GV->getLinkage(), Zero, GuardName.str());
+                                 GV->getLinkage(), Zero, GuardName);
     GI->Guard->setVisibility(GV->getVisibility());
     GI->Guard->setDLLStorageClass(GV->getDLLStorageClass());
   } else {

tools/clang/lib/CodeGen/TargetInfo.cpp

     llvm::LLVMContext &Ctx = CGM.getModule().getContext();
     llvm::SmallVector<llvm::Value *, 2> MDVals;
     MDVals.push_back(GV);
-    MDVals.push_back(llvm::MDString::get(Ctx, Enc.str()));
+    MDVals.push_back(llvm::MDString::get(Ctx, Enc));
     llvm::NamedMDNode *MD =
       CGM.getModule().getOrInsertNamedMetadata("xcore.typestrings");
     MD->addOperand(llvm::MDNode::get(Ctx, MDVals));

tools/clang/lib/Driver/CrossWindowsToolChain.cpp

   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
     SmallString<128> ResourceDir(D.ResourceDir);
     llvm::sys::path::append(ResourceDir, "include");
-    addSystemInclude(DriverArgs, CC1Args, ResourceDir.str());
+    addSystemInclude(DriverArgs, CC1Args, ResourceDir);
   }
   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
 }

tools/clang/lib/Driver/Driver.cpp

     llvm::sys::path::append(P, ClangResourceDir);
   else
     llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING);
-  ResourceDir = P.str();
+  ResourceDir = P.to_str();
 }
 
 Driver::~Driver() {

 
   SmallString<64> Path(Value);
   if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
-    if (!llvm::sys::path::is_absolute(Path.str())) {
+    if (!llvm::sys::path::is_absolute(Path)) {
       SmallString<64> Directory(WorkDir->getValue());
       llvm::sys::path::append(Directory, Value);
       Path.assign(Directory);

   if (D.IsCLMode() && llvm::sys::Process::FindInEnvPath("LIB", Value))
     return true;
 
-  D.Diag(clang::diag::err_drv_no_such_file) << Path.str();
+  D.Diag(clang::diag::err_drv_no_such_file) << Path;
   return false;
 }
 

       Dir = SysRoot + Dir.substr(1);
     SmallString<128> P(Dir);
     llvm::sys::path::append(P, Name);
-    if (llvm::sys::fs::exists(Twine(P)))
-      return P.str();
+    if (llvm::sys::fs::exists(P))
+      return P.to_str();
   }
 
   SmallString<128> P(ResourceDir);
   llvm::sys::path::append(P, Name);
-  if (llvm::sys::fs::exists(Twine(P)))
-    return P.str();
+  if (llvm::sys::fs::exists(P))
+    return P.to_str();
 
   const ToolChain::path_list &List = TC.getFilePaths();
   for (ToolChain::path_list::const_iterator

       Dir = SysRoot + Dir.substr(1);
     SmallString<128> P(Dir);
     llvm::sys::path::append(P, Name);
-    if (llvm::sys::fs::exists(Twine(P)))
-      return P.str();
+    if (llvm::sys::fs::exists(P))
+      return P.to_str();
   }
 
   return Name;

     if (llvm::sys::fs::is_directory(PrefixDir)) {
       SmallString<128> P(PrefixDir);
       if (ScanDirForExecutable(P, TargetSpecificExecutables))
-        return P.str();
+        return P.to_str();
     } else {
       SmallString<128> P(PrefixDir + Name);
       if (llvm::sys::fs::can_execute(Twine(P)))
-        return P.str();
+        return P.to_str();
     }
   }
 

   for (const auto &Path : List) {
     SmallString<128> P(Path);
     if (ScanDirForExecutable(P, TargetSpecificExecutables))
-      return P.str();
+      return P.to_str();
   }
 
   // If all else failed, search the path.

     return "";
   }
 
-  return Path.str();
+  return Path.to_str();
 }
 
 /// \brief Compute target triple from args.

tools/clang/lib/Driver/MSVCToolChain.cpp

     }
   }
 
-  path = libPath.str();
+  path = libPath.to_str();
   return true;
 }
 

     // Whatever this is, Visual Studio doesn't have a toolchain for it.
     return false;
   }
-  path = BinDir.str();
+  path = BinDir.to_str();
   return true;
 }
 

                                                   const char *subfolder) const {
   llvm::SmallString<128> path(folder);
   llvm::sys::path::append(path, subfolder);
-  addSystemInclude(DriverArgs, CC1Args, path.str());
+  addSystemInclude(DriverArgs, CC1Args, path);
 }
 
 void MSVCToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,

   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
     SmallString<128> P(getDriver().ResourceDir);
     llvm::sys::path::append(P, "include");
-    addSystemInclude(DriverArgs, CC1Args, P.str());
+    addSystemInclude(DriverArgs, CC1Args, P);
   }
 
   if (DriverArgs.hasArg(options::OPT_nostdlibinc))

tools/clang/lib/Driver/Multilib.cpp

   llvm::sys::path::append(IncludeSuffix, "/", Base.includeSuffix(),
                           New.includeSuffix());
 
-  Multilib Composed(GCCSuffix.str(), OSSuffix.str(), IncludeSuffix.str());
+  Multilib Composed(GCCSuffix, OSSuffix, IncludeSuffix);
 
   Multilib::flags_list &Flags = Composed.flags();
 

tools/clang/lib/Driver/SanitizerArgs.cpp

   if (BlacklistFile) {
     SmallString<64> Path(D.ResourceDir);
     llvm::sys::path::append(Path, BlacklistFile);
-    BLPath = Path.str();
+    BLPath = Path.to_str();
     return true;
   }
   return false;

tools/clang/lib/Driver/ToolChains.cpp

   // For now, allow missing resource libraries to support developers who may
   // not have compiler-rt checked out or integrated into their build (unless
   // we explicitly force linking with this library).
-  if (AlwaysLink || llvm::sys::fs::exists(P.str()))
-    CmdArgs.push_back(Args.MakeArgString(P.str()));
+  if (AlwaysLink || llvm::sys::fs::exists(P))
+    CmdArgs.push_back(Args.MakeArgString(P));
 
   // Adding the rpaths might negatively interact when other rpaths are involved,
   // so we should make sure we add the rpaths last, after all user-specified

     // Add the path to the resource dir to rpath to support using the dylib
     // from the default location without copying.
     CmdArgs.push_back("-rpath");
-    CmdArgs.push_back(Args.MakeArgString(Dir.str()));
+    CmdArgs.push_back(Args.MakeArgString(Dir));
   }
 }
 

       SmallString<128> P(A->getValue());
       llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
 
-      if (!llvm::sys::fs::exists(P.str())) {
+      if (!llvm::sys::fs::exists(P)) {
         llvm::sys::path::remove_filename(P);
         llvm::sys::path::append(P, "libstdc++.6.dylib");
-        if (llvm::sys::fs::exists(P.str())) {
-          CmdArgs.push_back(Args.MakeArgString(P.str()));
+        if (llvm::sys::fs::exists(P)) {
+          CmdArgs.push_back(Args.MakeArgString(P));
           return;
         }
       }

 
   // For now, allow missing resource libraries to support developers who may
   // not have compiler-rt checked out or integrated into their build.
-  if (llvm::sys::fs::exists(P.str()))
-    CmdArgs.push_back(Args.MakeArgString(P.str()));
+  if (llvm::sys::fs::exists(P))
+    CmdArgs.push_back(Args.MakeArgString(P));
 }
 
 DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,

 
   llvm::sys::path::append(IncludeDir, "hexagon/include/c++/");
   llvm::sys::path::append(IncludeDir, Ver);
-  addSystemInclude(DriverArgs, CC1Args, IncludeDir.str());
+  addSystemInclude(DriverArgs, CC1Args, IncludeDir);
 }
 
 ToolChain::CXXStdlibType

   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
     SmallString<128> P(D.ResourceDir);
     llvm::sys::path::append(P, "include");
-    addSystemInclude(DriverArgs, CC1Args, P.str());
+    addSystemInclude(DriverArgs, CC1Args, P);
   }
 
   if (DriverArgs.hasArg(options::OPT_nostdlibinc))

tools/clang/lib/Driver/Tools.cpp

       P += ".dummy";
       if (UsePCH) {
         llvm::sys::path::replace_extension(P, "pch");
-        if (llvm::sys::fs::exists(P.str()))
+        if (llvm::sys::fs::exists(P))
           FoundPCH = true;
       }
 
       if (!FoundPCH) {
         llvm::sys::path::replace_extension(P, "pth");
-        if (llvm::sys::fs::exists(P.str()))
+        if (llvm::sys::fs::exists(P))
           FoundPTH = true;
       }
 
       if (!FoundPCH && !FoundPTH) {
         llvm::sys::path::replace_extension(P, "gch");
-        if (llvm::sys::fs::exists(P.str())) {
+        if (llvm::sys::fs::exists(P)) {
           FoundPCH = UsePCH;
           FoundPTH = !UsePCH;
         }

             CmdArgs.push_back("-include-pch");
           else
             CmdArgs.push_back("-include-pth");
-          CmdArgs.push_back(Args.MakeArgString(P.str()));
+          CmdArgs.push_back(Args.MakeArgString(P));
           continue;
         } else {
           // Ignore the PCH if not first on command line and emit warning.
           D.Diag(diag::warn_drv_pch_not_first_include)
-              << P.str() << A->getAsString(Args);
+              << P << A->getAsString(Args);
         }
       }
     }

       } else {
         CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
       }
-      if (llvm::sys::path::is_relative(CoverageFilename.str())) {
+      if (llvm::sys::path::is_relative(CoverageFilename)) {
         SmallString<128> Pwd;
         if (!llvm::sys::fs::current_path(Pwd)) {
-          llvm::sys::path::append(Pwd, CoverageFilename.str());
+          llvm::sys::path::append(Pwd, CoverageFilename);
           CoverageFilename.swap(Pwd);
         }
       }

       Flags += EscapedArg;
     }
     CmdArgs.push_back("-dwarf-debug-flags");
-    CmdArgs.push_back(Args.MakeArgString(Flags.str()));
+    CmdArgs.push_back(Args.MakeArgString(Flags));
   }
 
   // Add the split debug info name to the command lines here so we

       Flags += EscapedArg;
     }
     CmdArgs.push_back("-dwarf-debug-flags");
-    CmdArgs.push_back(Args.MakeArgString(Flags.str()));
+    CmdArgs.push_back(Args.MakeArgString(Flags));
   }
 
   // FIXME: Add -static support, once we have it.

                                          visualStudioBinDir)) {
     SmallString<128> FilePath(visualStudioBinDir);
     llvm::sys::path::append(FilePath, Exe);
-    if (llvm::sys::fs::can_execute(FilePath.c_str()))
-      return FilePath.str();
+    if (llvm::sys::fs::can_execute(FilePath))
+      return FilePath.to_str();
   }
 
   return Exe;

 
     SmallString<128> ImplibName(Output.getFilename());
     llvm::sys::path::replace_extension(ImplibName, "lib");
-    CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
-                                         ImplibName.str()));
+    CmdArgs.push_back(Args.MakeArgString("-implib:" +
+                                         ImplibName));
   }
 
   if (getToolChain().getSanitizerArgs().needsAsanRt()) {

tools/clang/lib/Edit/EditedSource.cpp

     StrVec += text;
   }
 
-  return commitInsert(OrigLoc, Offs, StrVec.str(), beforePreviousInsertions);
+  return commitInsert(OrigLoc, Offs, StrVec, beforePreviousInsertions);
 }
 
 void EditedSource::commitRemove(SourceLocation OrigLoc,

       continue;
     }
 
-    applyRewrite(receiver, StrVec.str(), CurOffs, CurLen, SourceMgr, LangOpts);
+    applyRewrite(receiver, StrVec, CurOffs, CurLen, SourceMgr, LangOpts);
     CurOffs = offs;
     StrVec = act.Text;
     CurLen = act.RemoveLen;

     CurEnd = CurOffs.getWithOffset(CurLen);
   }
 
-  applyRewrite(receiver, StrVec.str(), CurOffs, CurLen, SourceMgr, LangOpts);
+  applyRewrite(receiver, StrVec, CurOffs, CurLen, SourceMgr, LangOpts);
 }
 
 void EditedSource::clearRewrites() {

tools/clang/lib/Frontend/ASTUnit.cpp

   SmallString<128> Path;
   llvm::sys::fs::createTemporaryFile("preamble", "pch", Path);
 
-  return Path.str();
+  return Path.to_str();
 }
 
 /// \brief Compute the preamble for the main file, providing the source buffer

   TempPath = File;
   TempPath += "-%%%%%%%%";
   int fd;
-  if (llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath))
+  if (llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath))
     return true;
 
   // FIXME: Can we somehow regenerate the stat cache here, or do we need to 

     return true;
   }
 
-  if (llvm::sys::fs::rename(TempPath.str(), File)) {
-    llvm::sys::fs::remove(TempPath.str());
+  if (llvm::sys::fs::rename(TempPath, File)) {
+    llvm::sys::fs::remove(TempPath);
     return true;
   }
 

tools/clang/lib/Frontend/CacheTokens.cpp

 
   // Generate the PTH file.
   PP.getFileManager().removeStatCache(StatCache);
-  PW.GeneratePTH(MainFilePath.str());
+  PW.GeneratePTH(MainFilePath.to_str());
 }
 
 //===----------------------------------------------------------------------===//

tools/clang/lib/Frontend/CompilerInstance.cpp

         // relative to that.
         FileMgr->FixupRelativePath(NewOutFile);
         if (std::error_code ec =
-                llvm::sys::fs::rename(it->TempFilename, NewOutFile.str())) {
+                llvm::sys::fs::rename(it->TempFilename, NewOutFile)) {
           getDiagnostics().Report(diag::err_unable_to_rename_temp)
             << it->TempFilename << it->Filename << ec.message();
 

   } else if (!Extension.empty()) {
     SmallString<128> Path(InFile);
     llvm::sys::path::replace_extension(Path, Extension);
-    OutFile = Path.str();
+    OutFile = Path.to_str();
   } else {
     OutFile = "-";
   }

     TempPath += "-%%%%%%%%";
     int fd;
     std::error_code EC =
-        llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
+        llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
 
     if (CreateMissingDirectories &&
         EC == llvm::errc::no_such_file_or_directory) {

       StringRef Parent = llvm::sys::path::parent_path(OutputPath);
       EC = llvm::sys::fs::create_directories(Parent);
       if (!EC) {
-        EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
+        EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
       }
     }
 
     if (!EC) {
       OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
-      OSFile = TempFile = TempPath.str();
+      OSFile = TempFile = TempPath.to_str();
     }
     // If we failed to create the temporary, fallback to writing to the file
     // directly. This handles the corner case where we cannot write to the

   SmallString<128> ModuleCachePathNative;
   llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
   for (llvm::sys::fs::directory_iterator
-         Dir(ModuleCachePathNative.str(), EC), DirEnd;
+         Dir(ModuleCachePathNative, EC), DirEnd;
        Dir != DirEnd && !EC; Dir.increment(EC)) {
     // If we don't have a directory, there's nothing to look into.
     if (!llvm::sys::fs::is_directory(Dir->path()))

tools/clang/lib/Frontend/CompilerInvocation.cpp

     llvm::sys::path::append(P, "lib", "clang", CLANG_VERSION_STRING);
   }
 
-  return P.str();
+  return P.to_str();
 }
 
 static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {

     llvm::sys::path::append(systemVersionFile, "SystemVersion.plist");
 
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer =
-        llvm::MemoryBuffer::getFile(systemVersionFile.str());
+        llvm::MemoryBuffer::getFile(systemVersionFile);
     if (buffer) {
       code = hash_combine(code, buffer.get()->getBuffer());
 

tools/clang/lib/Frontend/FrontendAction.cpp

       SmallString<128> DirNative;
       llvm::sys::path::native(PCHDir->getName(), DirNative);
       bool Found = false;
-      for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd;
+      for (llvm::sys::fs::directory_iterator Dir(DirNative, EC), DirEnd;
            Dir != DirEnd && !EC; Dir.increment(EC)) {
         // Check whether this is an acceptable AST file.
         if (ASTReader::isAcceptableASTFile(Dir->path(), FileMgr,

tools/clang/lib/Frontend/FrontendActions.cpp

     std::error_code EC;
     SmallString<128> DirNative;
     llvm::sys::path::native(UmbrellaDir->getName(), DirNative);
-    for (llvm::sys::fs::recursive_directory_iterator Dir(DirNative.str(), EC), 
+    for (llvm::sys::fs::recursive_directory_iterator Dir(DirNative, EC), 
                                                      DirEnd;
          Dir != DirEnd && !EC; Dir.increment(EC)) {
       // Check whether this entry has an extension typically associated with 

tools/clang/lib/Frontend/InitHeaderSearch.cpp

     // supplied path.
     SmallString<128> P = StringRef(HSOpts.ResourceDir);
     llvm::sys::path::append(P, "include");
-    AddUnmappedPath(P.str(), ExternCSystem, false);
+    AddUnmappedPath(P, ExternCSystem, false);
   }
 
   // All remaining additions are for system include directories, early exit if

       // <sysroot>/i686-w64-mingw32/include
       SmallString<128> P = StringRef(HSOpts.ResourceDir);
       llvm::sys::path::append(P, "../../../i686-w64-mingw32/include");
-      AddPath(P.str(), System, false);
+      AddPath(P, System, false);
 
       // <sysroot>/x86_64-w64-mingw32/include
       P.resize(HSOpts.ResourceDir.size());
       llvm::sys::path::append(P, "../../../x86_64-w64-mingw32/include");
-      AddPath(P.str(), System, false);
+      AddPath(P, System, false);
 
       // mingw.org crt include paths
       // <sysroot>/include
       P.resize(HSOpts.ResourceDir.size());
       llvm::sys::path::append(P, "../../../include");
-      AddPath(P.str(), System, false);
+      AddPath(P, System, false);
       AddPath("/mingw/include", System, false);
 #if defined(LLVM_ON_WIN32)
       AddPath("c:/mingw/include", System, false); 

 
           // Get foo/include/c++/v1
           llvm::sys::path::append(P, "include", "c++", "v1");
-          AddUnmappedPath(P.str(), CXXSystem, false);
+          AddUnmappedPath(P, CXXSystem, false);
         }
       }
       // On Solaris, include the support directory for things like xlocale and

     // Set up the builtin include directory in the module map.
     SmallString<128> P = StringRef(HSOpts.ResourceDir);
     llvm::sys::path::append(P, "include");
-    if (const DirectoryEntry *Dir = HS.getFileMgr().getDirectory(P.str()))
+    if (const DirectoryEntry *Dir = HS.getFileMgr().getDirectory(P))
       HS.getModuleMap().setBuiltinIncludeDir(Dir);
   }
 

tools/clang/lib/Frontend/LogDiagnosticPrinter.cpp

   // Format the message.
   SmallString<100> MessageStr;
   Info.FormatDiagnostic(MessageStr);
-  DE.Message = MessageStr.str();
+  DE.Message = MessageStr.to_str();
 
   // Set the location information.
   DE.Filename = "";

tools/clang/lib/Frontend/ModuleDependencyCollector.cpp

   if (std::error_code EC = fs::create_directories(path::parent_path(Dest),
                                                    /*IgnoreExisting=*/true))
     return EC;
-  if (std::error_code EC = fs::copy_file(AbsoluteSrc.str(), Dest.str()))
+  if (std::error_code EC = fs::copy_file(AbsoluteSrc, Dest))
     return EC;
   // Use the absolute path under the root for the file mapping.
-  Collector.addFileMapping(AbsoluteSrc.str(), Dest.str());
+  Collector.addFileMapping(AbsoluteSrc, Dest);
   return std::error_code();
 }
 

tools/clang/lib/Frontend/Rewrite/FrontendActions.cpp

     SmallString<128> Path(Filename);
     llvm::sys::path::replace_extension(Path,
       NewSuffix + llvm::sys::path::extension(Path));
-    return Path.str();
+    return Path.to_str();
   }
 };
 

     llvm::sys::fs::createTemporaryFile(llvm::sys::path::filename(Filename),
                                        llvm::sys::path::extension(Filename), fd,
                                        Path);
-    return Path.str();
+    return Path.to_str();
   }
 };
 } // end anonymous namespace

tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp

          "Unexpected diagnostic with valid location outside of a source file");
   SDiagsRenderer Renderer(*this, *LangOpts, &*State->DiagOpts);
   Renderer.emitDiagnostic(Info.getLocation(), DiagLevel,
-                          State->diagBuf.str(),
+                          State->diagBuf,
                           Info.getRanges(),
                           Info.getFixItHints(),
                           &Info.getSourceManager(),

tools/clang/lib/Frontend/TextDiagnostic.cpp

     }
     
     print_reversed = !was_printable;
-    to_print += res.first.str();
+    to_print += res.first;
   }
   
   if (print_reversed && DiagOpts->ShowColors)

tools/clang/lib/Frontend/TextDiagnosticBuffer.cpp

   default: llvm_unreachable(
                          "Diagnostic not handled during diagnostic buffering!");
   case DiagnosticsEngine::Note:
-    Notes.push_back(std::make_pair(Info.getLocation(), Buf.str()));
+    Notes.push_back(std::make_pair(Info.getLocation(), Buf.to_str()));
     break;
   case DiagnosticsEngine::Warning:
-    Warnings.push_back(std::make_pair(Info.getLocation(), Buf.str()));
+    Warnings.push_back(std::make_pair(Info.getLocation(), Buf.to_str()));
     break;
   case DiagnosticsEngine::Remark:
-    Remarks.push_back(std::make_pair(Info.getLocation(), Buf.str()));
+    Remarks.push_back(std::make_pair(Info.getLocation(), Buf.to_str()));
     break;
   case DiagnosticsEngine::Error:
   case DiagnosticsEngine::Fatal:
-    Errors.push_back(std::make_pair(Info.getLocation(), Buf.str()));
+    Errors.push_back(std::make_pair(Info.getLocation(), Buf.to_str()));
     break;
   }
 }

tools/clang/lib/Index/CommentToXML.cpp

     const DeclInfo *DI, SmallString<128> &Declaration) {
   // FIXME. formatting API expects null terminated input string.
   // There might be more efficient way of doing this.
-  std::string StringDecl = Declaration.str();
+  std::string StringDecl = Declaration.to_str();
 
   // Formatter specific code.
   // Form a unique in memory buffer name.

tools/clang/lib/Lex/HeaderSearch.cpp

     // error if they are imported in the same translation.
     SmallString<256> AbsModuleMapPath(ModuleMapPath);
     llvm::sys::fs::make_absolute(AbsModuleMapPath);
-    llvm::APInt Code(64, llvm::hash_value(AbsModuleMapPath.str().lower()));
+    llvm::APInt Code(64, llvm::hash_value(AbsModuleMapPath.lower()));
     SmallString<128> HashStr;
     Code.toStringUnsigned(HashStr, /*Radix*/36);
-    llvm::sys::path::append(Result, ModuleName + "-" + HashStr.str() + ".pcm");
+    llvm::sys::path::append(Result, ModuleName + "-" + HashStr + ".pcm");
   }
-  return Result.str().str();
+  return Result.to_str();
 }
 
 Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) {

       RelativePath->append(Filename.begin(), Filename.end());
     }
 
-    return getFileAndSuggestModule(HS, TmpDir.str(), getDir(),
+    return getFileAndSuggestModule(HS, TmpDir, getDir(),
                                    isSystemHeaderDirectory(),
                                    SuggestedModule);
   }

     HS.IncrementFrameworkLookupCount();
 
     // If the framework dir doesn't exist, we fail.
-    const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName.str());
+    const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName);
     if (!Dir) return nullptr;
 
     // Otherwise, if it does, remember that this is the right direntry for this

     if (getDirCharacteristic() == SrcMgr::C_User) {
       SmallString<1024> SystemFrameworkMarker(FrameworkName);
       SystemFrameworkMarker += ".system_framework";
-      if (llvm::sys::fs::exists(SystemFrameworkMarker.str())) {
+      if (llvm::sys::fs::exists(SystemFrameworkMarker)) {
         CacheEntry.IsUserSpecifiedSystemFramework = true;
       }
     }

   }
 
   FrameworkName.append(Filename.begin()+SlashPos+1, Filename.end());
-  const FileEntry *FE = FileMgr.getFile(FrameworkName.str(),
+  const FileEntry *FE = FileMgr.getFile(FrameworkName,
                                         /*openFile=*/!SuggestedModule);
   if (!FE) {
     // Check "/System/Library/Frameworks/Cocoa.framework/PrivateHeaders/file.h"

       SearchPath->insert(SearchPath->begin()+OrigSize, Private,
                          Private+strlen(Private));
 
-    FE = FileMgr.getFile(FrameworkName.str(), /*openFile=*/!SuggestedModule);
+    FE = FileMgr.getFile(FrameworkName, /*openFile=*/!SuggestedModule);
   }
 
   // If we found the header and are allowed to suggest a module, do so now.

       bool IncluderIsSystemHeader =
           getFileInfo(Includer).DirInfo != SrcMgr::C_User;
       if (const FileEntry *FE = getFileAndSuggestModule(
-              *this, TmpDir.str(), IncluderAndDir.second,
+              *this, TmpDir, IncluderAndDir.second,
               IncluderIsSystemHeader, SuggestedModule)) {
         // Leave CurDir unset.
         // This file is a system header or C++ unfriendly if the old file is.

     ++NumSubFrameworkLookups;
 
     // If the framework dir doesn't exist, we fail.
-    const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName.str());
+    const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName);
     if (!Dir) return nullptr;
 
     // Otherwise, if it does, remember that this is the right direntry for this

   }
 
   HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
-  if (!(FE = FileMgr.getFile(HeadersFilename.str(), /*openFile=*/true))) {
+  if (!(FE = FileMgr.getFile(HeadersFilename, /*openFile=*/true))) {
 
     // Check ".../Frameworks/HIToolbox.framework/PrivateHeaders/HIToolbox.h"
     HeadersFilename = FrameworkName;

     }
 
     HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
-    if (!(FE = FileMgr.getFile(HeadersFilename.str(), /*openFile=*/true)))
+    if (!(FE = FileMgr.getFile(HeadersFilename, /*openFile=*/true)))
       return nullptr;
   }
 

                               DirNative);
       
       // Search each of the ".framework" directories to load them as modules.
-      for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd;
+      for (llvm::sys::fs::directory_iterator Dir(DirNative, EC), DirEnd;
            Dir != DirEnd && !EC; Dir.increment(EC)) {
         if (llvm::sys::path::extension(Dir->path()) != ".framework")
           continue;

   std::error_code EC;
   SmallString<128> DirNative;
   llvm::sys::path::native(SearchDir.getDir()->getName(), DirNative);
-  for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd;
+  for (llvm::sys::fs::directory_iterator Dir(DirNative, EC), DirEnd;
        Dir != DirEnd && !EC; Dir.increment(EC)) {
     loadModuleMapFile(Dir->path(), SearchDir.isSystemHeaderDirectory(),
                       SearchDir.isFramework());

tools/clang/lib/Lex/ModuleMap.cpp

   llvm::sys::path::append(SubframeworksDirName, "Frameworks");
   llvm::sys::path::native(SubframeworksDirName);
   for (llvm::sys::fs::directory_iterator 
-         Dir(SubframeworksDirName.str(), EC), DirEnd;
+         Dir(SubframeworksDirName, EC), DirEnd;
        Dir != DirEnd && !EC; Dir.increment(EC)) {
     if (!StringRef(Dir->path()).endswith(".framework"))
       continue;

   if (llvm::sys::path::is_relative(FileNameRef)) {
     ModuleMapFileName += Directory->getName();
     llvm::sys::path::append(ModuleMapFileName, FileName);
-    FileNameRef = ModuleMapFileName.str();
+    FileNameRef = ModuleMapFileName;
   }
   if (const FileEntry *File = SourceMgr.getFileManager().getFile(FileNameRef))
     Map.parseModuleMapFile(File, /*IsSystem=*/false);

tools/clang/lib/Lex/PPDirectives.cpp

 
   // Find the first non-whitespace character, so that we can make the
   // diagnostic more succinct.
-  StringRef Msg = Message.str().ltrim(" ");
+  StringRef Msg = StringRef(Message).ltrim(" ");
 
   if (isWarning)
     Diag(Tok, diag::pp_hash_warning) << Msg;

     FilenameBuffer.push_back('<');
     if (ConcatenateIncludeName(FilenameBuffer, End))
       return;   // Found <eod> but no ">"?  Diagnostic already emitted.
-    Filename = FilenameBuffer.str();
+    Filename = FilenameBuffer;
     CharEnd = End.getLocWithOffset(1);
     break;
   default:

       Diag(HashLoc, diag::warn_auto_module_import)
         << IncludeKind << PathString 
         << FixItHint::CreateReplacement(ReplaceRange,
-             "@import " + PathString.str().str() + ";");
+             "@import " + PathString.to_str() + ";");
     }
     
     // Load the module. Only make macros visible. We'll make the declarations

tools/clang/lib/Lex/PPMacroExpansion.cpp

       Tok.setKind(tok::eod);
       return false;   // Found <eod> but no ">"?  Diagnostic already emitted.
     }
-    Filename = FilenameBuffer.str();
+    Filename = FilenameBuffer;
     break;
   default:
     PP.Diag(Tok.getLocation(), diag::err_pp_expects_filename);

     if (PLoc.isValid()) {
       FN += PLoc.getFilename();
       Lexer::Stringify(FN);
-      OS << '"' << FN.str() << '"';
+      OS << '"' << FN << '"';
     }
     Tok.setKind(tok::string_literal);
   } else if (II == Ident__DATE__) {

tools/clang/lib/Lex/Pragma.cpp

     SourceLocation End;
     if (ConcatenateIncludeName(FileNameBuffer, End))
       return; // Diagnostic already emitted
-    SourceFileName = FileNameBuffer.str();
+    SourceFileName = FileNameBuffer;
   } else {
     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
     return;

     SourceLocation End;
     if (ConcatenateIncludeName(FileNameBuffer, End))
       return; // Diagnostic already emitted
-    ReplaceFileName = FileNameBuffer.str();
+    ReplaceFileName = FileNameBuffer;
   } else {
     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
     return;

tools/clang/lib/Lex/TokenLexer.cpp

           // disabling it.
           PP.Diag(Loc, PP.getLangOpts().MicrosoftExt ? diag::ext_pp_bad_paste_ms
                                                      : diag::err_pp_bad_paste)
-              << Buffer.str();
+              << Buffer;
         }
 
         // An error has occurred so exit loop.

tools/clang/lib/Parse/ParseInit.cpp

 
     Diag(NameLoc, diag::ext_gnu_old_style_field_designator)
       << FixItHint::CreateReplacement(SourceRange(NameLoc, ColonLoc),
-                                      NewSyntax.str());
+                                      NewSyntax);
 
     Designation D;
     D.AddDesignator(Designator::getField(FieldName, SourceLocation(), NameLoc));

tools/clang/lib/Rewrite/Rewriter.cpp

         indentedStr += indentSpace;
       }
     }
-    Str = indentedStr.str();
+    Str = indentedStr;
   }
 
   getEditBuffer(FID).InsertText(StartOffs, Str, InsertAfter);

     TempFilename = Filename;
     TempFilename += "-%%%%%%%%";
     int FD;
-    if (llvm::sys::fs::createUniqueFile(TempFilename.str(), FD, TempFilename)) {
+    if (llvm::sys::fs::createUniqueFile(TempFilename, FD, TempFilename)) {
       AllWritten = false;
       Diagnostics.Report(clang::diag::err_unable_to_make_temp)
         << TempFilename;

     FileStream.reset();
 #endif
     if (std::error_code ec =
-            llvm::sys::fs::rename(TempFilename.str(), Filename)) {
+            llvm::sys::fs::rename(TempFilename, Filename)) {
       AllWritten = false;
       Diagnostics.Report(clang::diag::err_unable_to_rename_temp)
         << TempFilename << Filename << ec.message();
       // If the remove fails, there's not a lot we can do - this is already an
       // error.
-      llvm::sys::fs::remove(TempFilename.str());
+      llvm::sys::fs::remove(TempFilename);
     }
   }
 

tools/clang/lib/Sema/SemaCodeComplete.cpp

           Arg += ", ...";
         else
           Arg += "...";
-        Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
+        Result.AddPlaceholderChunk(Result.getAllocator().CopyString(StringRef(Arg)));
         break;
       }
 

tools/clang/lib/Sema/SemaDecl.cpp

             << "  int " << FTI.Params[i].Ident->getName() << ";\n";
         Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
             << FTI.Params[i].Ident
-            << FixItHint::CreateInsertion(LocAfterDecls, Code.str());
+            << FixItHint::CreateInsertion(LocAfterDecls, Code);
 
         // Implicitly declare the argument as type 'int' for lack of a better
         // type.

tools/clang/lib/Sema/SemaExpr.cpp

   // turned off separately if needed.
   if (LeftBits == ResultBits - 1) {
     S.Diag(Loc, diag::warn_shift_result_sets_sign_bit)
-        << HexResult.str() << LHSType
+        << HexResult << LHSType
         << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
     return;
   }
 
   S.Diag(Loc, diag::warn_shift_result_gt_typewidth)
-    << HexResult.str() << Result.getMinSignedBits() << LHSType
+    << HexResult << Result.getMinSignedBits() << LHSType
     << Left.getBitWidth() << LHS.get()->getSourceRange()
     << RHS.get()->getSourceRange();
 }

tools/clang/lib/Sema/SemaStmt.cpp

           if (PrevString == CurrString)
             Diag(CaseVals[i].second->getLHS()->getLocStart(),
                  diag::err_duplicate_case) <<
-                 (PrevString.empty() ? CaseValStr.str() : PrevString);
+                 (PrevString.empty() ? CaseValStr : PrevString);
           else
             Diag(CaseVals[i].second->getLHS()->getLocStart(),
                  diag::err_duplicate_case_differing_expr) <<
-                 (PrevString.empty() ? CaseValStr.str() : PrevString) <<
-                 (CurrString.empty() ? CaseValStr.str() : CurrString) <<
+                 (PrevString.empty() ? CaseValStr : PrevString) <<
+                 (CurrString.empty() ? CaseValStr : CurrString) <<
                  CaseValStr;
 
           Diag(CaseVals[i-1].second->getLHS()->getLocStart(),

tools/clang/lib/Serialization/ASTReader.cpp

     path::append(currPCHPath, "..");
   path::append(currPCHPath, fileDirI, fileDirE);
   path::append(currPCHPath, path::filename(Filename));
-  return currPCHPath.str();
+  return currPCHPath.to_str();
 }
 
 bool ASTReader::ReadSLocEntry(int ID) {

tools/clang/lib/Serialization/ASTReaderStmt.cpp

 
   // Read string data
   SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
-  E->setString(Reader.getContext(), Str.str(), kind, isPascal);
+  E->setString(Reader.getContext(), Str, kind, isPascal);
   Idx += Len;
 
   // Read source locations

tools/clang/lib/Serialization/ASTWriter.cpp

     auto addModMap = [&](const FileEntry *F) {
       SmallString<128> ModuleMap(F->getName());
       llvm::sys::fs::make_absolute(ModuleMap);
-      AddString(ModuleMap.str(), Record);
+      AddString(ModuleMap, Record);
     };
 
     auto &Map = PP.getHeaderSearchInfo().getModuleMap();

   Record.push_back(NumHeaderSearchEntries);
   Record.push_back(TableData.size());
   TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
-  Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str());
+  Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData);
   
   // Free all of the strings we had to duplicate.
   for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I)

 
   Record.push_back(MACRO_TABLE);
   Record.push_back(BucketOffset);
-  Stream.EmitRecordWithBlob(MacroTableAbbrev, Record, MacroTable.str());
+  Stream.EmitRecordWithBlob(MacroTableAbbrev, Record, MacroTable);
   Record.clear();
 
   // Write the offsets table for macro IDs.

     Record.push_back(METHOD_POOL);
     Record.push_back(BucketOffset);
     Record.push_back(NumTableEntries);
-    Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str());
+    Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool);
 
     // Create a blob abbreviation for the selector table offsets.
     Abbrev = new BitCodeAbbrev();

     RecordData Record;
     Record.push_back(IDENTIFIER_TABLE);
     Record.push_back(BucketOffset);
-    Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str());
+    Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable);
   }
 
   // Write the offsets table for identifier IDs.

   Record.push_back(DECL_CONTEXT_VISIBLE);
   Record.push_back(BucketOffset);
   Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record,
-                            LookupTable.str());
+                            LookupTable);
   ++NumVisibleDeclContexts;
   return Offset;
 }

   Record.push_back(UPDATE_VISIBLE);
   Record.push_back(getDeclID(cast<Decl>(DC)));
   Record.push_back(BucketOffset);
-  Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str());
+  Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable);
 }
 
 /// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions.

tools/clang/lib/Serialization/GlobalModuleIndex.cpp

     Record.clear();
     Record.push_back(IDENTIFIER_INDEX);
     Record.push_back(BucketOffset);
-    Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str());
+    Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable);
   }
 
   Stream.ExitBlock();

     return EC_IOError;
 
   // Remove the old index file. It isn't relevant any more.
-  llvm::sys::fs::remove(IndexPath.str());
+  llvm::sys::fs::remove(IndexPath);
 
   // Rename the newly-written index file to the proper name.
-  if (llvm::sys::fs::rename(IndexTmpPath.str(), IndexPath.str())) {
+  if (llvm::sys::fs::rename(IndexTmpPath, IndexPath)) {
     // Rename failed; just remove the 
-    llvm::sys::fs::remove(IndexTmpPath.str());
+    llvm::sys::fs::remove(IndexTmpPath);
     return EC_IOError;
   }
 

tools/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp

   os.flush();
   BugReport *report =
     new BugReport(*BT_null,
-                  buf.empty() ? BT_null->getDescription() : buf.str(),
+                  buf.empty() ? BT_null->getDescription() : buf,
                   N);
 
   bugreporter::trackNullOrUndefValue(N, bugreporter::getDerefExpr(S), *report);

tools/clang/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp

       llvm::raw_svector_ostream os(PropNameWithUnderscore);
       os << '_' << PropName;
     }
-    if (IvarName == PropNameWithUnderscore.str())
+    if (IvarName == PropNameWithUnderscore)
       return Iv;
   }
 

tools/clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

       llvm::sys::path::append(Model, Directory, "report-%%%%%%.html");
 
       if (std::error_code EC =
-          llvm::sys::fs::createUniqueFile(Model.str(), FD, ResultPath)) {
+          llvm::sys::fs::createUniqueFile(Model, FD, ResultPath)) {
           llvm::errs() << "warning: could not create file in '" << Directory
                        << "': " << EC.message() << '\n';
           return;

                    << "-" << i << ".html";
           llvm::sys::path::append(Model, Directory,
                                   filename.str());
-          EC = llvm::sys::fs::openFileForWrite(Model.str(),
+          EC = llvm::sys::fs::openFileForWrite(Model,
                                                FD,
                                                llvm::sys::fs::F_RW |
                                                llvm::sys::fs::F_Excl);
           if (EC && EC != std::errc::file_exists) {
-              llvm::errs() << "warning: could not create file '" << Model.str()
+              llvm::errs() << "warning: could not create file '" << Model
                            << "': " << EC.message() << '\n';
               return;
           }

tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

   SmallString<128> P;
   int FD;
   llvm::sys::fs::createTemporaryFile("llvm_ubi", "", FD, P);
-  llvm::errs() << "Writing '" << P.str() << "'.\n";
+  llvm::errs() << "Writing '" << P << "'.\n";
 
   auto Stream = llvm::make_unique<llvm::raw_fd_ostream>(FD, true);
 

tools/clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp

   else
     fileName = llvm::StringRef(D->getName().str() + ".model");
 
-  if (!llvm::sys::fs::exists(fileName.str())) {
+  if (!llvm::sys::fs::exists(fileName)) {
     Bodies[D->getName()] = nullptr;
     return;
   }

tools/clang/lib/Tooling/JSONCompilationDatabase.cpp

 
   std::string Error;
   llvm::raw_string_ostream ES(Error);
-  StringRef Match = MatchTrie.findEquivalent(NativeFilePath.str(), ES);
+  StringRef Match = MatchTrie.findEquivalent(NativeFilePath, ES);
   if (Match.empty())
     return std::vector<CompileCommand>();
   llvm::StringMap< std::vector<CompileCommandRef> >::const_iterator

       SmallString<128> AbsolutePath(
           Directory->getValue(DirectoryStorage));
       llvm::sys::path::append(AbsolutePath, FileName);
-      llvm::sys::path::native(AbsolutePath.str(), NativeFilePath);
+      llvm::sys::path::native(AbsolutePath, NativeFilePath);
     } else {
       llvm::sys::path::native(FileName, NativeFilePath);
     }
     IndexByFile[NativeFilePath].push_back(
         CompileCommandRef(Directory, Command));
-    MatchTrie.insert(NativeFilePath.str());
+    MatchTrie.insert(NativeFilePath);
   }
   return true;
 }

tools/clang/lib/Tooling/Tooling.cpp

   assert(!EC);
   (void)EC;
   llvm::sys::path::native(AbsolutePath);
-  return AbsolutePath.str();
+  return AbsolutePath.to_str();
 }
 
 namespace {

tools/clang/tools/driver/driver.cpp

   // Do a PATH lookup, if there are no directory components.
   if (llvm::sys::path::filename(InstalledPath) == InstalledPath)
     if (llvm::ErrorOr<std::string> Tmp = llvm::sys::findProgramByName(
-            llvm::sys::path::filename(InstalledPath.str())))
+            llvm::sys::path::filename(InstalledPath)))
       InstalledPath = *Tmp;
   llvm::sys::fs::make_absolute(InstalledPath);
   InstalledPath = llvm::sys::path::parent_path(InstalledPath);

tools/clang/tools/libclang/CIndex.cpp

 
   llvm::TimeRecord TR = llvm::TimeRecord::getCurrentTime();
   OS << llvm::format("%7.4f] ", TR.getWallTime() - sBeginTR.getWallTime());
-  OS << Msg.str() << '\n';
+  OS << Msg << '\n';
 
   if (Trace) {
     llvm::sys::PrintStackTrace(stderr);

tools/clang/tools/libclang/CIndexCodeCompletion.cpp

   if (Buffer.empty())
     Buffer.append(Old.begin(), Old.end());
   Buffer.append(New.begin(), New.end());
-  Old = Buffer.str();
+  Old = Buffer;
 }
 
 /// \brief Get the typed-text blocks from the given code-completion string

tools/clang/tools/libclang/CIndexer.cpp

   llvm::sys::path::append(LibClangPath, "clang", CLANG_VERSION_STRING);
 
   // Cache our result.
-  ResourcesPath = LibClangPath.str();
+  ResourcesPath = LibClangPath.to_str();
   return ResourcesPath;
 }

tools/clang/tools/libclang/CXComment.cpp

   SmallString<128> Text;
   TU->CommentToXML->convertHTMLTagNodeToText(
       HTC, Text, cxtu::getASTUnit(TU)->getASTContext());
-  return cxstring::createDup(Text.str());
+  return cxstring::createDup(Text);
 }
 
 CXString clang_FullComment_getAsHTML(CXComment CXC) {

   SmallString<1024> HTML;
   TU->CommentToXML
       ->convertCommentToHTML(FC, HTML, cxtu::getASTUnit(TU)->getASTContext());
-  return cxstring::createDup(HTML.str());
+  return cxstring::createDup(HTML);
 }
 
 CXString clang_FullComment_getAsXML(CXComment CXC) {

   SmallString<1024> XML;
   TU->CommentToXML
       ->convertCommentToXML(FC, XML, cxtu::getASTUnit(TU)->getASTContext());
-  return cxstring::createDup(XML.str());
+  return cxstring::createDup(XML);
 }
 
 } // end extern "C"

tools/clang/tools/libclang/IndexingContext.cpp

       llvm::raw_svector_ostream OS(StrBuf);
       D->printName(OS);
     }
-    EntityInfo.name = SA.copyCStr(StrBuf.str());
+    EntityInfo.name = SA.copyCStr(StrBuf);
   }
 
   {

     if (Ignore) {
       EntityInfo.USR = nullptr;
     } else {
-      EntityInfo.USR = SA.copyCStr(StrBuf.str());
+      EntityInfo.USR = SA.copyCStr(StrBuf);
     }
   }
 }

tools/clang/utils/TableGen/ClangAttrEmitter.cpp

 
     OS <<
       "  case " << I << " : {\n"
-      "    OS << \"" + Prefix.str() + Spelling.str();
+      "    OS << \"" + Prefix + Spelling;
 
     if (Variety == "Pragma") {
       OS << " \";\n";

 
     if (!Args.empty())
       OS << ")";
-    OS << Suffix.str() + "\";\n";
+    OS << Suffix + "\";\n";
 
     OS <<
       "    break;\n"

tools/clang/utils/TableGen/ClangCommentHTMLNamedCharacterReferenceEmitter.cpp

     }
     CLiteral.append(";");
 
-    StringMatcher::StringPair Match(Spelling, CLiteral.str());
+    StringMatcher::StringPair Match(Spelling, CLiteral.to_str());
     NameToUTF8.push_back(Match);
   }
 

tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp

           Replacement += (*I)->ExplicitDef->getName();
           Replacement += ">";
         }
-        SMFixIt FixIt(InGroupRange, Replacement.str());
+        SMFixIt FixIt(InGroupRange, Replacement);
 
         SrcMgr.PrintMessage(NextDiagGroup->getLoc().front(),
                             SourceMgr::DK_Error,

   SmallString<256> enumName = llvm::StringRef("DiagCat_");
   for (llvm::StringRef::iterator I = name.begin(), E = name.end(); I != E; ++I)
     enumName += isalnum(*I) ? *I : '_';
-  return enumName.str();
+  return enumName.to_str();
 }
 
 /// \brief Emit the array of diagnostic subgroups.

tools/llvm-cov/CodeCoverage.cpp

         errs() << "error: " << File << ": " << EC.message();
         return 1;
       }
-      SourceFiles.push_back(Path.str());
+      SourceFiles.push_back(Path.to_str());
     }
     return 0;
   };

tools/llvm-cov/gcov.cpp

     sys::path::replace_extension(CoverageFileStem, "");
 
   std::string GCNO = InputGCNO.empty()
-                         ? std::string(CoverageFileStem.str()) + ".gcno"
+                         ? CoverageFileStem.to_str() + ".gcno"
                          : InputGCNO;
   std::string GCDA = InputGCDA.empty()
-                         ? std::string(CoverageFileStem.str()) + ".gcda"
+                         ? CoverageFileStem.to_str() + ".gcda"
                          : InputGCDA;
   GCOVFile GF;
 

tools/llvm-objdump/MachODump.cpp

                          const MCAsmInfo &MAI) {
   // Flush the stream before taking its content.
   CommentStream.flush();
-  StringRef Comments = CommentsToEmit.str();
+  StringRef Comments = CommentsToEmit;
   // Get the default information for printing a comment.
   const char *CommentBegin = MAI.getCommentString();
   unsigned CommentColumn = MAI.getCommentColumn();

tools/llvm-symbolizer/LLVMSymbolize.cpp

   }
   sys::path::append(ResourceName, "Contents", "Resources", "DWARF");
   sys::path::append(ResourceName, Basename);
-  return ResourceName.str();
+  return ResourceName.to_str();
 }
 
 static bool checkFileCRC(StringRef Path, uint32_t CRCHash) {

   // Try /path/to/original_binary/debuglink_name
   llvm::sys::path::append(DebugPath, DebuglinkName);
   if (checkFileCRC(DebugPath, CRCHash)) {
-    Result = DebugPath.str();
+    Result = DebugPath.to_str();
     return true;
   }
   // Try /path/to/original_binary/.debug/debuglink_name

   DebugPath = OrigRealPath;
   llvm::sys::path::append(DebugPath, ".debug", DebuglinkName);
   if (checkFileCRC(DebugPath, CRCHash)) {
-    Result = DebugPath.str();
+    Result = DebugPath.to_str();
     return true;
   }
   // Try /usr/lib/debug/path/to/original_binary/debuglink_name

   llvm::sys::path::append(DebugPath, llvm::sys::path::relative_path(OrigDir),
                           DebuglinkName);
   if (checkFileCRC(DebugPath, CRCHash)) {
-    Result = DebugPath.str();
+    Result = DebugPath.to_str();
     return true;
   }
   return false;

utils/FileCheck/FileCheck.cpp

   }
 
   return std::unique_ptr<MemoryBuffer>(
-      MemoryBuffer::getMemBufferCopy(NewFile.str(), MB->getBufferIdentifier()));
+      MemoryBuffer::getMemBufferCopy(NewFile, MB->getBufferIdentifier()));
 }
 
 static bool IsPartOfWord(char c) {

utils/TableGen/AsmWriterEmitter.cpp

     OS.flush();
 
     // Emit the string.
-    O.indent(6) << "AsmString = \"" << OutString.str() << "\";\n";
+    O.indent(6) << "AsmString = \"" << OutString << "\";\n";
 
     O.indent(6) << "break;\n";
     O.indent(4) << '}';

utils/TableGen/DAGISelMatcherEmitter.cpp

             << " children in Scope";
       }
 
-      OS << '\n' << TmpBuf.str();
+      OS << '\n' << TmpBuf;
       CurrentIdx += ChildSize;
     }
 

       if (!OmitComments)
         OS << "// ->" << CurrentIdx+ChildSize;
       OS << '\n';
-      OS << TmpBuf.str();
+      OS << TmpBuf;
       CurrentIdx += ChildSize;
     }
 

utils/TableGen/FixedLenDecoderEmitter.cpp

   // overkill for now, though.
 
   // Make sure the predicate is in the table.
-  Decoders.insert(Decoder.str());
+  Decoders.insert(Decoder.to_str());
   // Now figure out the index for when we write out the table.
   DecoderSet::const_iterator P = std::find(Decoders.begin(),
                                            Decoders.end(),
-                                           Decoder.str());
+                                           Decoder);
   return (unsigned)(P - Decoders.begin());
 }