Add a user-defined literal for StringRef

[malcolm.parsons]

Summary

User-defined literals are supported by GCC 4.7, Clang 3.1 and MSVC 2015.

A user-defined literal for StringRef makes it easy to create StringRefs
containing embedded nulls.
It is also constexpr, so global tables of StringRef don't need a static
initializer.

Inspired by D25639.

[idlecode]

include/llvm/ADT/StringRef.h

778

Does this operator need it's own namespace?

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1221

getOrCreateSymbol takes Twine as argument so StringRef conversion is not needed.
There is few other such use-cases but it would be quite tedious to fix them all manually - maybe clang-tidy could take care of it in the future.

[mehdi_amini]

+chandler as a reviewer for the usage of user string literals.

[mehdi_amini]

include/llvm/ADT/StringRef.h

74

Is this related to this patch?

88

same.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1221

Are you sure that using a Twine with a const char * is equivalent? I wonder if there won't be an extra call to strlen at the point where the Twine is serialized.

lib/CodeGen/AsmPrinter/DIEHash.cpp

41

Why not just return "";?

lib/IR/Value.cpp

197

same.

lib/MC/MCAsmStreamer.cpp

350

Same in this context.

[malcolm.parsons]

include/llvm/ADT/StringRef.h

74

No.

88

Yes. This constructor needs to be constexpr, so that the constexpr UDL can call it. It can't use assert in C++11.

lib/CodeGen/AsmPrinter/DIEHash.cpp

41

I wonder this about the original.
These transformations were made with sed.

[malcolm.parsons]

The LLVM coding standards don't mention UDL.

The Google C++ Style Guide says
Pro: User-defined literals are a very concise notation for creating objects of user-defined types.
Con: User-defined literals allow the creation of new syntactic forms that are unfamiliar even to experienced C++ programmers.
Decision: Do not overload operator"", i.e. do not introduce user-defined literals

http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0403r0.html proposes a UDL for std::string_view.

I think the pros outweigh the cons.

[chandlerc]

In D26332#590536, @malcolm.parsons wrote:

The LLVM coding standards don't mention UDL.

The Google C++ Style Guide says
Pro: User-defined literals are a very concise notation for creating objects of user-defined types.
Con: User-defined literals allow the creation of new syntactic forms that are unfamiliar even to experienced C++ programmers.
Decision: Do not overload operator"", i.e. do not introduce user-defined literals

http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0403r0.html proposes a UDL for std::string_view.

I think the pros outweigh the cons.

FWIW, I disagree.

I think that UDLs introduce a surprising and novel syntax for calling functions. If there is an overwhelming desire to add UDLs for StringRef, we could do so, but so far I find the benefit provided relatively small and increasing the syntax scope of the language a high price to pay.

For example, in the overwhelming majority of the cases in this patch, I suspect the construction of the StringRef could be skipped entirely, and at most some missing overloads added to cause the code to work as-is without any need for further syntactic contortions.

[malcolm.parsons]

In D26332#603406, @chandlerc wrote:

I think that UDLs introduce a surprising and novel syntax for calling functions.

Calling methods on a literal StringRef is indeed surprising and novel.
I see some of those in this patch; they were not intentional and I'm removing them.

In the overwhelming majority of the cases in this patch, I suspect the construction of the StringRef could be skipped entirely, and at most some missing overloads added to cause the code to work as-is without any need for further syntactic contortions.

I'll remove the cases that don't have embedded nulls and add some that are constructed statically (PR11944).

[malcolm.parsons]

Make namespace inline.
Only use UDL where useful.

[zturner]

If the goal here is to achieve constexprness so it doesn't require a static initializer, how about reviving Mehdi's patch which make the const char * constructor explicit, and then adding a constexpr char array constructor?

[chandlerc]

There are a bunch of unrelated cleanups here. I don't know if those are good or not, but they make it really hard to even read this patch.

As several have said, I don't think continuing to update this patch is the right path forward. IMO you should:

1. take any pure cleanup (IE, unrelated to UDLs) parts of this patch, factor them into nice small patches that touch an isolated part of LLVM and send those out for review.

2. send a mail to llvm-dev explaining *why* you think we need a UDL for StringRef (what problems it solves, why the issues raised by myself and Pete don't apply) and why other solutions don't work.

Then #2 can resolve the actual debate. Note that if the "why" is what Zach hypothesizes, I would much prefer the approach he suggested to a UDL.

-Chandler

[malcolm.parsons]

In D26332#604408, @zturner wrote:

If the goal here is to achieve constexprness so it doesn't require a static initializer, how about reviving Mehdi's patch which make the const char * constructor explicit, and then adding a constexpr char array constructor?

A char array constructor cannot tell whether the array is a literal or not.
A UDL can only be called with a literal.

[zturner]

In D26332#604537, @malcolm.parsons wrote:

In D26332#604408, @zturner wrote:

If the goal here is to achieve constexprness so it doesn't require a static initializer, how about reviving Mehdi's patch which make the const char * constructor explicit, and then adding a constexpr char array constructor?

A char array constructor cannot tell whether the array is a literal or not.
A UDL can only be called with a literal.

I think as Chandler said, perhaps taking this to llvm-dev where more people will have a chance to chime in might be a good path forward

include/llvm/ADT/StringRef.h

static int compareMemory(const char *Lhs, const char *Rhs, size_t Length) {
       return ::memcmp(Lhs,Rhs,Length);
     }
 
   public:
     /// @name Constructors
     /// @{
 
     /// Construct an empty string ref.
-    /*implicit*/ StringRef() : Data(nullptr), Length(0) {}
+    /*implicit*/ constexpr StringRef() : Data(nullptr), Length(0) {}
 
     /// Disable conversion from nullptr.  This prevents things like
     /// if (S == nullptr)
     StringRef(std::nullptr_t) = delete;
 
     /// Construct a string ref from a cstring.
     LLVM_ATTRIBUTE_ALWAYS_INLINE
     /*implicit*/ StringRef(const char *Str)
         : Data(Str), Length(Str ? ::strlen(Str) : 0) {}
 
     /// Construct a string ref from a pointer and length.
-    LLVM_ATTRIBUTE_ALWAYS_INLINE
+    constexpr LLVM_ATTRIBUTE_ALWAYS_INLINE
     /*implicit*/ StringRef(const char *data, size_t length)
-      : Data(data), Length(length) {
-        assert((data || length == 0) &&
-        "StringRef cannot be built from a NULL argument with non-null length");
-      }
+        : Data(data), Length(data ? length : 0) {}
 
     /// Construct a string ref from an std::string.
     LLVM_ATTRIBUTE_ALWAYS_INLINE
     /*implicit*/ StringRef(const std::string &Str)
       : Data(Str.data()), Length(Str.length()) {}
 
     static StringRef withNullAsEmpty(const char *data) {
       return StringRef(data ? data : "");
namespace llvm {
   /// @}
 
   /// \brief Compute a hash_code for a StringRef.
   hash_code hash_value(StringRef S);
 
   // StringRefs can be treated like a POD type.
   template <typename T> struct isPodLike;
   template <> struct isPodLike<StringRef> { static const bool value = true; };
+
+  namespace operators {
+  /// User defined literal
+  /// Create a StringRef from a literal string.
+  constexpr llvm::StringRef operator"" _sr(const char *S, size_t Length) {
+    return llvm::StringRef(S, Length);
   }
+  } // end namespace operators
+  } // end namespace llvm
 
 #endif

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 #include "llvm/Support/Timer.h"
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "asm-printer"
 
 static const char *const DWARFGroupName = "DWARF Emission";
 static const char *const DbgTimerName = "Debug Info Emission";
 static const char *const EHTimerName = "DWARF Exception Writer";
 static const char *const CodeViewLineTablesGroupName = "CodeView Line Tables";
 
bool AsmPrinter::doFinalization(Module &M) {
   if (MMI->usesMorestackAddr()) {
     unsigned Align = 1;
     MCSection *ReadOnlySection = getObjFileLowering().getSectionForConstant(
         getDataLayout(), SectionKind::getReadOnly(),
         /*C=*/nullptr, Align);
     OutStreamer->SwitchSection(ReadOnlySection);
 
     MCSymbol *AddrSymbol =
-        OutContext.getOrCreateSymbol(StringRef("__morestack_addr"));
+        OutContext.getOrCreateSymbol("__morestack_addr"_sr);
     OutStreamer->EmitLabel(AddrSymbol);
 
     unsigned PtrSize = M.getDataLayout().getPointerSize(0);
     OutStreamer->EmitSymbolValue(GetExternalSymbolSymbol("__morestack"),
                                  PtrSize);
   }
 
   // If we don't have any trampolines, then we don't require stack memory

lib/CodeGen/AsmPrinter/DIEHash.cpp

 #include "llvm/CodeGen/DIE.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "dwarfdebug"
 
 /// \brief Grabs the string in whichever attribute is passed in and returns
 /// a reference to it.
 static StringRef getDIEStringAttr(const DIE &Die, uint16_t Attr) {
   // Iterate through all the attributes until we find the one we're
   // looking for, if we can't find it return an empty string.
   for (const auto &V : Die.values())
     if (V.getAttribute() == Attr)
       return V.getDIEString().getString();
 
-  return StringRef("");
+  return ""_sr;
 }
 
 /// \brief Adds the string in \p Str to the hash. This also hashes
 /// a trailing NULL with the string.
 void DIEHash::addString(StringRef Str) {
   DEBUG(dbgs() << "Adding string " << Str << " to hash.\n");
   Hash.update(Str);
   Hash.update(makeArrayRef((uint8_t)'\0'));

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 using namespace llvm;
+using namespace llvm::operators;
 using namespace dwarf;
 
 //===----------------------------------------------------------------------===//
 //                                  ELF
 //===----------------------------------------------------------------------===//
 
 MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
     const GlobalValue *GV, const TargetMachine &TM,
     MachineModuleInfo *MMI) const {
   unsigned Encoding = getPersonalityEncoding();
   if ((Encoding & 0x80) == dwarf::DW_EH_PE_indirect)
-    return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
+    return getContext().getOrCreateSymbol("DW.ref."_sr +
                                           TM.getSymbol(GV, getMangler())->getName());
   if ((Encoding & 0x70) == dwarf::DW_EH_PE_absptr)
     return TM.getSymbol(GV, getMangler());
   report_fatal_error("We do not support this DWARF encoding yet!");
 }
 
 void TargetLoweringObjectFileELF::emitPersonalityValue(
     MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
if (!ErrorCode.empty())
     report_fatal_error("Invalid section specifier '" + Section + "': " +
                        ErrorCode + ".");
 
   // Get the section.
   MCSectionMachO *S = getContext().getMachOSection(
       Segment, Section, TAA, StubSize, SectionKind::getData());
   Streamer.SwitchSection(S);
   Streamer.EmitLabel(getContext().
-                     getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
+                     getOrCreateSymbol("L_OBJC_IMAGE_INFO"_sr));
   Streamer.EmitIntValue(VersionVal, 4);
   Streamer.EmitIntValue(ImageInfoFlags, 4);
   Streamer.AddBlankLine();
 }
 
 static void checkMachOComdat(const GlobalValue *GV) {
   const Comdat *C = GV->getComdat();
   if (!C)

lib/CodeGen/TargetPassConfig.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Instrumentation.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/SymbolRewriter.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 static cl::opt<bool> DisablePostRA("disable-post-ra", cl::Hidden,
     cl::desc("Disable Post Regalloc"));
 static cl::opt<bool> DisableBranchFold("disable-branch-fold", cl::Hidden,
     cl::desc("Disable branch folding"));
 static cl::opt<bool> DisableTailDuplicate("disable-tail-duplicate", cl::Hidden,
     cl::desc("Disable tail duplication"));
 static cl::opt<bool> DisableEarlyTailDup("disable-early-taildup", cl::Hidden,

 void TargetPassConfig::addMachinePasses() {
   AddingMachinePasses = true;
 
   // Insert a machine instr printer pass after the specified pass.
   if (!StringRef(PrintMachineInstrs.getValue()).equals("") &&
       !StringRef(PrintMachineInstrs.getValue()).equals("option-unspecified")) {
     const PassRegistry *PR = PassRegistry::getPassRegistry();
     const PassInfo *TPI = PR->getPassInfo(PrintMachineInstrs.getValue());
-    const PassInfo *IPI = PR->getPassInfo(StringRef("machineinstr-printer"));
+    const PassInfo *IPI = PR->getPassInfo("machineinstr-printer"_sr);
     assert (TPI && IPI && "Pass ID not registered!");
     const char *TID = (const char *)(TPI->getTypeInfo());
     const char *IID = (const char *)(IPI->getTypeInfo());
     insertPass(TID, IID);
   }
 
   // Print the instruction selected machine code...
   printAndVerify("After Instruction Selection");

lib/IR/Value.cpp

 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 //===----------------------------------------------------------------------===//
 //                                Value Class
 //===----------------------------------------------------------------------===//
 static inline Type *checkType(Type *Ty) {
   assert(Ty && "Value defined with a null type: Error!");
   return Ty;
 }
void Value::setValueName(ValueName *VN) {
   Ctx.pImpl->ValueNames[this] = VN;
 }
 
 StringRef Value::getName() const {
   // Make sure the empty string is still a C string. For historical reasons,
   // some clients want to call .data() on the result and expect it to be null
   // terminated.
   if (!hasName())
-    return StringRef("", 0);
+    return ""_sr;
   return getValueName()->getKey();
 }
 
 void Value::setNameImpl(const Twine &NewName) {
   // Fast-path: LLVMContext can be set to strip out non-GlobalValue names
   if (getContext().shouldDiscardValueNames() && !isa<GlobalValue>(this))
     return;
 

lib/MC/MCAsmStreamer.cpp

 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include <cctype>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 
 class MCAsmStreamer final : public MCStreamer {
   std::unique_ptr<formatted_raw_ostream> OSOwner;
   formatted_raw_ostream &OS;
   const MCAsmInfo *MAI;
   std::unique_ptr<MCInstPrinter> InstPrinter;
void MCAsmStreamer::emitRawComment(const Twine &T, bool TabPrefix) {
   OS << MAI->getCommentString() << T;
   EmitEOL();
 }
 
 void MCAsmStreamer::addExplicitComment(const Twine &T) {
   StringRef c = T.getSingleStringRef();
   if (c.equals(StringRef(MAI->getSeparatorString())))
     return;
-  if (c.startswith(StringRef("//"))) {
+  if (c.startswith("//"_sr)) {
     ExplicitCommentToEmit.append("\t");
     ExplicitCommentToEmit.append(MAI->getCommentString());
     // drop //
     ExplicitCommentToEmit.append(c.slice(2, c.size()).str());
-  } else if (c.startswith(StringRef("/*"))) {
+  } else if (c.startswith("/*"_sr)) {
     size_t p = 2, len = c.size() - 2;
     // emit each line in comment as separate newline.
     do {
       size_t newp = std::min(len, c.find_first_of("\r\n", p));
       ExplicitCommentToEmit.append("\t");
       ExplicitCommentToEmit.append(MAI->getCommentString());
       ExplicitCommentToEmit.append(c.slice(p, newp).str());
       // If we have another line in this comment add line

lib/MC/MCDwarf.cpp

 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 static inline uint64_t ScaleAddrDelta(MCContext &Context, uint64_t AddrDelta) {
   unsigned MinInsnLength = Context.getAsmInfo()->getMinInstAlignment();
   if (MinInsnLength == 1)
     return AddrDelta;
   if (AddrDelta % MinInsnLength != 0) {
     // TODO: report this error, but really only once.
     ;
MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
   for (char Length : StandardOpcodeLengths)
     MCOS->EmitIntValue(Length, 1);
 
   // Put out the directory and file tables.
 
   // First the directory table.
   for (unsigned i = 0; i < MCDwarfDirs.size(); i++) {
     MCOS->EmitBytes(MCDwarfDirs[i]); // the DirectoryName
-    MCOS->EmitBytes(StringRef("\0", 1)); // the null term. of the string
+    MCOS->EmitBytes("\0"_sr); // the null term. of the string
   }
   MCOS->EmitIntValue(0, 1); // Terminate the directory list
 
   // Second the file table.
   for (unsigned i = 1; i < MCDwarfFiles.size(); i++) {
     assert(!MCDwarfFiles[i].Name.empty());
     MCOS->EmitBytes(MCDwarfFiles[i].Name); // FileName
-    MCOS->EmitBytes(StringRef("\0", 1)); // the null term. of the string
+    MCOS->EmitBytes("\0"_sr); // the null term. of the string
     // the Directory num
     MCOS->EmitULEB128IntValue(MCDwarfFiles[i].DirIndex);
     MCOS->EmitIntValue(0, 1); // last modification timestamp (always 0)
     MCOS->EmitIntValue(0, 1); // filesize (always 0)
   }
   MCOS->EmitIntValue(0, 1); // Terminate the file list
 
   // This is the end of the prologue, so set the value of the symbol at the
if (!DwarfDebugFlags.empty()){
     MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
   }
 
   // AT_producer, the version of the assembler tool.
   StringRef DwarfDebugProducer = context.getDwarfDebugProducer();
   if (!DwarfDebugProducer.empty())
     MCOS->EmitBytes(DwarfDebugProducer);
   else
-    MCOS->EmitBytes(StringRef("llvm-mc (based on LLVM " PACKAGE_VERSION ")"));
+    MCOS->EmitBytes("llvm-mc (based on LLVM " PACKAGE_VERSION ")"_sr);
   MCOS->EmitIntValue(0, 1); // NULL byte to terminate the string.
 
   // AT_language, a 4 byte value.  We use DW_LANG_Mips_Assembler as the dwarf2
   // draft has no standard code for assembler.
   MCOS->EmitIntValue(dwarf::DW_LANG_Mips_Assembler, 2);
 
   // Third part: the list of label DIEs.
 

lib/MC/MCParser/AsmParser.cpp

 #include <memory>
 #include <sstream>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 MCAsmParserSemaCallback::~MCAsmParserSemaCallback() {}
 
 static cl::opt<unsigned> AsmMacroMaxNestingDepth(
      "asm-macro-max-nesting-depth", cl::init(20), cl::Hidden,
      cl::desc("The maximum nesting depth allowed for assembly macros."));
 
 namespace {

 ///   ::= ( .ascii | .asciz | .string ) [ "string" ( , "string" )* ]
 bool AsmParser::parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated) {
   auto parseOp = [&]() -> bool {
     std::string Data;
     if (checkForValidSection() || parseEscapedString(Data))
       return true;
     getStreamer().EmitBytes(Data);
     if (ZeroTerminated)
-      getStreamer().EmitBytes(StringRef("\0", 1));
+      getStreamer().EmitBytes("\0"_sr);
     return false;
   };
 
   if (parseMany(parseOp))
     return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   return false;
 }
 

lib/Object/MachOObjectFile.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cctype>
 #include <cstring>
 #include <limits>
 #include <list>
 
 using namespace llvm;
+using namespace llvm::operators;
 using namespace object;
 
 namespace {
   struct section_base {
     char sectname[16];
     char segname[16];
   };
 }
if (auto SegOrErr = getStructOrErr<Segment>(Obj, Load.Ptr)) {
     if (BigSize > FileSize)
       return malformedError("load command " + Twine(LoadCommandIndex) +
                             " fileoff field plus filesize field in " +
                             CmdName + " extends past the end of the file");
     if (S.vmsize != 0 && S.filesize > S.vmsize)
       return malformedError("load command " + Twine(LoadCommandIndex) +
                             " fileoff field in " + CmdName +
                             " greater than vmsize field");
-    IsPageZeroSegment |= StringRef("__PAGEZERO").equals(S.segname);
+    IsPageZeroSegment |= "__PAGEZERO"_sr.equals(S.segname);
   } else
     return SegOrErr.takeError();
 
   return Error::success();
 }
 
 static Error checkSymtabCommand(const MachOObjectFile *Obj,
                                 const MachOObjectFile::LoadCommandInfo &Load,

lib/Support/GraphWriter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Program.h"
 using namespace llvm;
+using namespace llvm::operators;
 
 static cl::opt<bool> ViewBackground("view-background", cl::Hidden,
   cl::desc("Execute graph viewer in the background. Creates tmp file litter."));
 
 std::string llvm::DOT::EscapeString(const std::string &Label) {
   std::string Str(Label);
   for (unsigned i = 0; i != Str.length(); ++i)
   switch (Str[i]) {
if (Viewer &&
     case VK_Ghostview:
       args.push_back("--spartan");
       args.push_back(OutputFilename.c_str());
       break;
     case VK_CmdStart:
       args.push_back("/S");
       args.push_back("/C");
       StartArg =
-          (StringRef("start ") + (wait ? "/WAIT " : "") + OutputFilename).str();
+          ("start "_sr + (wait ? "/WAIT " : "") + OutputFilename).str();
       args.push_back(StartArg.c_str());
       break;
     case VK_None:
       llvm_unreachable("Invalid viewer");
     }
     args.push_back(nullptr);
 
     ErrMsg.clear();

lib/Target/AArch64/AArch64ISelLowering.cpp

 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetOptions.h"
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "aarch64-lower"
 
 STATISTIC(NumTailCalls, "Number of tail calls");
 STATISTIC(NumShiftInserts, "Number of vector shift inserts");
 
 static cl::opt<bool>
 EnableAArch64SlrGeneration("aarch64-shift-insert-generation", cl::Hidden,
if (Constraint.size() == 1) {
     // The instructions that this constraint is designed for can
     // only take 128-bit registers so just use that regclass.
     case 'x':
       if (VT.getSizeInBits() == 128)
         return std::make_pair(0U, &AArch64::FPR128_loRegClass);
       break;
     }
   }
-  if (StringRef("{cc}").equals_lower(Constraint))
+  if ("{cc}"_sr.equals_lower(Constraint))
     return std::make_pair(unsigned(AArch64::NZCV), &AArch64::CCRRegClass);
 
   // Use the default implementation in TargetLowering to convert the register
   // constraint into a member of a register class.
   std::pair<unsigned, const TargetRegisterClass *> Res;
   Res = TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
 
   // Not found as a standard register?

lib/Target/ARM/ARMISelLowering.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetOptions.h"
 #include <utility>
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "arm-isel"
 
 STATISTIC(NumTailCalls, "Number of tail calls");
 STATISTIC(NumMovwMovt, "Number of GAs materialized with movw + movt");
 STATISTIC(NumLoopByVals, "Number of loops generated for byval arguments");
 STATISTIC(NumConstpoolPromoted,
   "Number of constants with their storage promoted into constant pools");
case 'x':
         return RCPair(0U, &ARM::QPR_8RegClass);
       break;
     case 't':
       if (VT == MVT::f32)
         return RCPair(0U, &ARM::SPRRegClass);
       break;
     }
   }
-  if (StringRef("{cc}").equals_lower(Constraint))
+  if ("{cc}"_sr.equals_lower(Constraint))
     return std::make_pair(unsigned(ARM::CPSR), &ARM::CCRRegClass);
 
   return TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
 }
 
 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
 /// vector.  If it is invalid, don't add anything to Ops.
 void ARMTargetLowering::LowerAsmOperandForConstraint(SDValue Op,

lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 static std::string GetAEABIUnwindPersonalityName(unsigned Index) {
   assert(Index < ARM::EHABI::NUM_PERSONALITY_INDEX &&
          "Invalid personality index");
   return (Twine("__aeabi_unwind_cpp_pr") + Twine(Index)).str();
 }
 
 namespace {
if (AttributeItem *Item = getAttributeItem(Attribute)) {
       return;
     }
 
     // Create new attribute item
     AttributeItem Item = {
       AttributeItem::NumericAttribute,
       Attribute,
       Value,
-      StringRef("")
+      ""_sr
     };
     Contents.push_back(Item);
   }
 
   void setAttributeItem(unsigned Attribute, StringRef Value,
                         bool OverwriteExisting) {
     // Look for existing attribute item
     if (AttributeItem *Item = getAttributeItem(Attribute)) {

lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp

 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 static cl::opt<bool> EnableFutureRegs("mfuture-regs",
                                       cl::desc("Enable future registers"));
 
 static cl::opt<bool> WarnMissingParenthesis("mwarn-missing-parenthesis",
 cl::desc("Warn for missing parenthesis around predicate registers"),
 cl::init(true));
 static cl::opt<bool> ErrorMissingParenthesis("merror-missing-parenthesis",
if (!Parser.getStreamer().hasRawTextSupport()) {
       // check if this as an immediate or a symbol
       int64_t Value;
       bool Absolute = MO_1.getExpr()->evaluateAsAbsolute(Value);
       if (Absolute) {
         // Create a new section - one for each constant
         // Some or all of the zeros are replaced with the given immediate.
         if (is32bit) {
           std::string myImmStr = utohexstr(static_cast<uint32_t>(Value));
-          myCharStr = StringRef(".gnu.linkonce.l4.CONST_00000000")
+          myCharStr = ".gnu.linkonce.l4.CONST_00000000"_sr
                           .drop_back(myImmStr.size())
                           .str() +
                       myImmStr;
         } else {
           std::string myImmStr = utohexstr(Value);
-          myCharStr = StringRef(".gnu.linkonce.l8.CONST_0000000000000000")
+          myCharStr = ".gnu.linkonce.l8.CONST_0000000000000000"_sr
                           .drop_back(myImmStr.size())
                           .str() +
                       myImmStr;
         }
 
         mySection = getContext().getELFSection(myCharStr, ELF::SHT_PROGBITS,
                                                ELF::SHF_ALLOC | ELF::SHF_WRITE);
       } else if (MO_1.isExpr()) {

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Transforms/Utils/UnrollLoop.h"
 #include <sstream>
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEPOTNAME "__local_depot"
 
 static cl::opt<bool>
 EmitLineNumbers("nvptx-emit-line-numbers", cl::Hidden,
                 cl::desc("NVPTX Specific: Emit Line numbers even without -G"),
                 cl::init(true));
 
for (auto I = MBB.pred_begin(); I != MBB.pred_end(); ++I) {
     }
   }
   return false;
 }
 
 void NVPTXAsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) const {
   AsmPrinter::EmitBasicBlockStart(MBB);
   if (isLoopHeaderOfNoUnroll(MBB))
-    OutStreamer->EmitRawText(StringRef("\t.pragma \"nounroll\";\n"));
+    OutStreamer->EmitRawText("\t.pragma \"nounroll\";\n"_sr);
 }
 
 void NVPTXAsmPrinter::EmitFunctionEntryLabel() {
   SmallString<128> Str;
   raw_svector_ostream O(Str);
 
   if (!GlobalsEmitted) {
     emitGlobals(*MF->getFunction()->getParent());
void NVPTXAsmPrinter::EmitFunctionEntryLabel() {
 
   OutStreamer->EmitRawText(O.str());
 
   prevDebugLoc = DebugLoc();
 }
 
 void NVPTXAsmPrinter::EmitFunctionBodyStart() {
   VRegMapping.clear();
-  OutStreamer->EmitRawText(StringRef("{\n"));
+  OutStreamer->EmitRawText("{\n"_sr);
   setAndEmitFunctionVirtualRegisters(*MF);
 
   SmallString<128> Str;
   raw_svector_ostream O(Str);
   emitDemotedVars(MF->getFunction(), O);
   OutStreamer->EmitRawText(O.str());
 }
 
 void NVPTXAsmPrinter::EmitFunctionBodyEnd() {
-  OutStreamer->EmitRawText(StringRef("}\n"));
+  OutStreamer->EmitRawText("}\n"_sr);
   VRegMapping.clear();
 }
 
 void NVPTXAsmPrinter::emitImplicitDef(const MachineInstr *MI) const {
   unsigned RegNo = MI->getOperand(0).getReg();
   if (TargetRegisterInfo::isVirtualRegister(RegNo)) {
     OutStreamer->AddComment(Twine("implicit-def: ") +
                             getVirtualRegisterName(RegNo));

lib/Target/PowerPC/PPCAsmPrinter.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "asmprinter"
 
 namespace {
 class PPCAsmPrinter : public AsmPrinter {
 protected:
   MapVector<MCSymbol *, MCSymbol *> TOC;
   const PPCSubtarget *Subtarget;
void PPCAsmPrinter::EmitInstruction(const MachineInstr *MI) {
   case PPC::MoveGOTtoLR: {
     // Transform %LR = MoveGOTtoLR
     // Into this: bl _GLOBAL_OFFSET_TABLE_@local-4
     // _GLOBAL_OFFSET_TABLE_@local-4 (instruction preceding
     // _GLOBAL_OFFSET_TABLE_) has exactly one instruction:
     //      blrl
     // This will return the pointer to _GLOBAL_OFFSET_TABLE_@local
     MCSymbol *GOTSymbol =
-      OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
+      OutContext.getOrCreateSymbol("_GLOBAL_OFFSET_TABLE_"_sr);
     const MCExpr *OffsExpr =
       MCBinaryExpr::createSub(MCSymbolRefExpr::create(GOTSymbol,
                                                       MCSymbolRefExpr::VK_PPC_LOCAL,
                                                       OutContext),
                               MCConstantExpr::create(4, OutContext),
                               OutContext);
 
     // Emit the 'bl'.
const MCExpr *Exp =
       MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO,
                               OutContext);
     TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
     EmitToStreamer(*OutStreamer, TmpInst);
     return;
   }
 
   case PPC::PPC32PICGOT: {
-    MCSymbol *GOTSymbol = OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
+    MCSymbol *GOTSymbol = OutContext.getOrCreateSymbol("_GLOBAL_OFFSET_TABLE_"_sr);
     MCSymbol *GOTRef = OutContext.createTempSymbol();
     MCSymbol *NextInstr = OutContext.createTempSymbol();
 
     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL)
       // FIXME: We would like an efficient form for this, so we don't have to do
       // a lot of extra uniquing.
       .addExpr(MCSymbolRefExpr::create(NextInstr, OutContext)));
     const MCExpr *OffsExpr =
case PPC::PPC32PICGOT: {
     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADD4)
                                  .addReg(MI->getOperand(0).getReg())
                                  .addReg(MI->getOperand(1).getReg())
                                  .addReg(MI->getOperand(0).getReg()));
     return;
   }
   case PPC::PPC32GOT: {
     MCSymbol *GOTSymbol =
-        OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
+        OutContext.getOrCreateSymbol("_GLOBAL_OFFSET_TABLE_"_sr);
     const MCExpr *SymGotTlsL = MCSymbolRefExpr::create(
         GOTSymbol, MCSymbolRefExpr::VK_PPC_LO, OutContext);
     const MCExpr *SymGotTlsHA = MCSymbolRefExpr::create(
         GOTSymbol, MCSymbolRefExpr::VK_PPC_HA, OutContext);
     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LI)
                                  .addReg(MI->getOperand(0).getReg())
                                  .addExpr(SymGotTlsL));
     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
if (Subtarget->isELFv2ABI()) {
     // In the Large code model, we allow arbitrary displacements between
     // the text section and its associated TOC section.  We place the
     // full 8-byte offset to the TOC in memory immediatedly preceding
     // the function global entry point.
     if (TM.getCodeModel() == CodeModel::Large
         && !MF->getRegInfo().use_empty(PPC::X2)) {
       const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
 
-      MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(StringRef(".TOC."));
+      MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(".TOC."_sr);
       MCSymbol *GlobalEPSymbol = PPCFI->getGlobalEPSymbol();
       const MCExpr *TOCDeltaExpr =
         MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
                                 MCSymbolRefExpr::create(GlobalEPSymbol,
                                                         OutContext),
                                 OutContext);
 
       OutStreamer->EmitLabel(PPCFI->getTOCOffsetSymbol());
void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
   OutStreamer->SwitchSection(Section);
   OutStreamer->EmitLabel(CurrentFnSym);
   OutStreamer->EmitValueToAlignment(8);
   MCSymbol *Symbol1 = CurrentFnSymForSize;
   // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
   // entry point.
   OutStreamer->EmitValue(MCSymbolRefExpr::create(Symbol1, OutContext),
                          8 /*size*/);
-  MCSymbol *Symbol2 = OutContext.getOrCreateSymbol(StringRef(".TOC."));
+  MCSymbol *Symbol2 = OutContext.getOrCreateSymbol(".TOC."_sr);
   // Generates a R_PPC64_TOC relocation for TOC base insertion.
   OutStreamer->EmitValue(
     MCSymbolRefExpr::create(Symbol2, MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
     8/*size*/);
   // Emit a null environment pointer.
   OutStreamer->EmitIntValue(0, 8 /* size */);
   OutStreamer->SwitchSection(Current.first, Current.second);
 }
if (Subtarget->isELFv2ABI()
     const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
 
     MCSymbol *GlobalEntryLabel = PPCFI->getGlobalEPSymbol();
     OutStreamer->EmitLabel(GlobalEntryLabel);
     const MCSymbolRefExpr *GlobalEntryLabelExp =
       MCSymbolRefExpr::create(GlobalEntryLabel, OutContext);
 
     if (TM.getCodeModel() != CodeModel::Large) {
-      MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(StringRef(".TOC."));
+      MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(".TOC."_sr);
       const MCExpr *TOCDeltaExpr =
         MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
                                 GlobalEntryLabelExp, OutContext);
 
       const MCExpr *TOCDeltaHi =
         PPCMCExpr::createHa(TOCDeltaExpr, false, OutContext);
       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
                                    .addReg(PPC::X2)

lib/Target/PowerPC/PPCISelLowering.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetOptions.h"
 #include <list>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "ppc-lowering"
 
 static cl::opt<bool> DisablePPCPreinc("disable-ppc-preinc",
 cl::desc("disable preincrement load/store generation on PPC"), cl::Hidden);
 
 static cl::opt<bool> DisableILPPref("disable-ppc-ilp-pref",
 cl::desc("disable setting the node scheduling preference to ILP on PPC"), cl::Hidden);
PPCTargetLowering::getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
   // the AsmName field from *RegisterInfo.td, then this would not be necessary.
   if (R.first && VT == MVT::i64 && Subtarget.isPPC64() &&
       PPC::GPRCRegClass.contains(R.first))
     return std::make_pair(TRI->getMatchingSuperReg(R.first,
                             PPC::sub_32, &PPC::G8RCRegClass),
                           &PPC::G8RCRegClass);
 
   // GCC accepts 'cc' as an alias for 'cr0', and we need to do the same.
-  if (!R.second && StringRef("{cc}").equals_lower(Constraint)) {
+  if (!R.second && "{cc}"_sr.equals_lower(Constraint)) {
     R.first = PPC::CR0;
     R.second = &PPC::CRRCRegClass;
   }
 
   return R;
 }
 
 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops

lib/Target/X86/X86AsmPrinter.cpp

 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TargetRegistry.h"
 using namespace llvm;
+using namespace llvm::operators;
 
 //===----------------------------------------------------------------------===//
 // Primitive Helper Functions.
 //===----------------------------------------------------------------------===//
 
 /// runOnMachineFunction - Emit the function body.
 ///
 bool X86AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
void X86AsmPrinter::EmitStartOfAsmFile(Module &M) {
 
   if (TT.isOSBinFormatMachO())
     OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
 
   if (TT.isOSBinFormatCOFF()) {
     // Emit an absolute @feat.00 symbol.  This appears to be some kind of
     // compiler features bitfield read by link.exe.
     if (TT.getArch() == Triple::x86) {
-      MCSymbol *S = MMI->getContext().getOrCreateSymbol(StringRef("@feat.00"));
+      MCSymbol *S = MMI->getContext().getOrCreateSymbol("@feat.00"_sr);
       OutStreamer->BeginCOFFSymbolDef(S);
       OutStreamer->EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_STATIC);
       OutStreamer->EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_NULL);
       OutStreamer->EndCOFFSymbolDef();
       // According to the PE-COFF spec, the LSB of this value marks the object
       // for "registered SEH".  This means that all SEH handler entry points
       // must be registered in .sxdata.  Use of any unregistered handlers will
       // cause the process to terminate immediately.  LLVM does not know how to

lib/Target/X86/X86ISelLowering.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Target/TargetOptions.h"
 #include "X86IntrinsicsInfo.h"
 #include <bitset>
 #include <numeric>
 #include <cctype>
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "x86-isel"
 
 STATISTIC(NumTailCalls, "Number of tail calls");
 
 static cl::opt<bool> ExperimentalVectorWideningLegalization(
     "x86-experimental-vector-widening-legalization", cl::init(false),
     cl::desc("Enable an experimental vector type legalization through widening "
if (Constraint.size() == 7 && Constraint[0] == '{' &&
         Constraint[6] == '}') {
 
       Res.first = X86::FP0+Constraint[4]-'0';
       Res.second = &X86::RFP80RegClass;
       return Res;
     }
 
     // GCC allows "st(0)" to be called just plain "st".
-    if (StringRef("{st}").equals_lower(Constraint)) {
+    if ("{st}"_sr.equals_lower(Constraint)) {
       Res.first = X86::FP0;
       Res.second = &X86::RFP80RegClass;
       return Res;
     }
 
     // flags -> EFLAGS
-    if (StringRef("{flags}").equals_lower(Constraint)) {
+    if ("{flags}"_sr.equals_lower(Constraint)) {
       Res.first = X86::EFLAGS;
       Res.second = &X86::CCRRegClass;
       return Res;
     }
 
     // 'A' means EAX + EDX.
     if (Constraint == "A") {
       Res.first = X86::EAX;

lib/Target/X86/X86MCInstLower.cpp

 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 
 /// X86MCInstLower - This class is used to lower an MachineInstr into an MCInst.
 class X86MCInstLower {
   MCContext &Ctx;
   const MachineFunction &MF;
   const TargetMachine &TM;
case X86::Int_MemBarrier:
     OutStreamer->emitRawComment("MEMBARRIER");
     return;
 
 
   case X86::EH_RETURN:
   case X86::EH_RETURN64: {
     // Lower these as normal, but add some comments.
     unsigned Reg = MI->getOperand(0).getReg();
-    OutStreamer->AddComment(StringRef("eh_return, addr: %") +
+    OutStreamer->AddComment("eh_return, addr: %"_sr +
                             X86ATTInstPrinter::getRegisterName(Reg));
     break;
   }
   case X86::CLEANUPRET: {
     // Lower these as normal, but add some comments.
     OutStreamer->AddComment("CLEANUPRET");
     break;
   }

lib/Target/XCore/XCoreAsmPrinter.cpp

 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include <algorithm>
 #include <cctype>
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "asm-printer"
 
 namespace {
   class XCoreAsmPrinter : public AsmPrinter {
     XCoreMCInstLower MCInstLowering;
     XCoreTargetStreamer &getTargetStreamer();
 

 
 void XCoreAsmPrinter::emitArrayBound(MCSymbol *Sym, const GlobalVariable *GV) {
   assert( ( GV->hasExternalLinkage() || GV->hasWeakLinkage() ||
             GV->hasLinkOnceLinkage() || GV->hasCommonLinkage() ) &&
           "Unexpected linkage");
   if (ArrayType *ATy = dyn_cast<ArrayType>(GV->getValueType())) {
 
     MCSymbol *SymGlob = OutContext.getOrCreateSymbol(
-                          Twine(Sym->getName() + StringRef(".globound")));
+                          Twine(Sym->getName() + ".globound"_sr));
     OutStreamer->EmitSymbolAttribute(SymGlob, MCSA_Global);
     OutStreamer->EmitAssignment(SymGlob,
                                 MCConstantExpr::create(ATy->getNumElements(),
                                                        OutContext));
     if (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
         GV->hasCommonLinkage()) {
       OutStreamer->EmitSymbolAttribute(SymGlob, MCSA_Weak);
     }

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 #include <algorithm>
 #include <iomanip>
 #include <limits>
 #include <sstream>
 #include <string>
 #include <system_error>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "asan"
 
 static const uint64_t kDefaultShadowScale = 3;
 static const uint64_t kDefaultShadowOffset32 = 1ULL << 29;
 static const uint64_t kDefaultShadowOffset64 = 1ULL << 44;
 static const uint64_t kDynamicShadowSentinel = ~(uint64_t)0;
 static const uint64_t kIOSShadowOffset32 = 1ULL << 30;
AsanHandleNoReturnFunc = checkSanitizerInterfaceFunction(
       M.getOrInsertFunction(kAsanHandleNoReturnName, IRB.getVoidTy(), nullptr));
 
   AsanPtrCmpFunction = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       kAsanPtrCmp, IRB.getVoidTy(), IntptrTy, IntptrTy, nullptr));
   AsanPtrSubFunction = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       kAsanPtrSub, IRB.getVoidTy(), IntptrTy, IntptrTy, nullptr));
   // We insert an empty inline asm after __asan_report* to avoid callback merge.
   EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false),
-                            StringRef(""), StringRef(""),
+                            ""_sr, ""_sr,
                             /*hasSideEffects=*/true);
 }
 
 // virtual
 bool AddressSanitizer::doInitialization(Module &M) {
   // Initialize the private fields. No one has accessed them before.
 
   GlobalsMD.init(M);

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Instrumentation.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "msan"
 
 static const unsigned kOriginSize = 4;
 static const unsigned kMinOriginAlignment = 4;
 static const unsigned kShadowTLSAlignment = 8;
 
 // These constants must be kept in sync with the ones in msan.h.
VAArgOverflowSizeTLS = new GlobalVariable(
     "__msan_va_arg_overflow_size_tls", nullptr,
     GlobalVariable::InitialExecTLSModel);
   OriginTLS = new GlobalVariable(
     M, IRB.getInt32Ty(), false, GlobalVariable::ExternalLinkage, nullptr,
     "__msan_origin_tls", nullptr, GlobalVariable::InitialExecTLSModel);
 
   // We insert an empty inline asm after __msan_report* to avoid callback merge.
   EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false),
-                            StringRef(""), StringRef(""),
+                            ""_sr, ""_sr,
                             /*hasSideEffects=*/true);
 }
 
 /// \brief Module-level initialization.
 ///
 /// inserts a call to __msan_init to the module's constructor list.
 bool MemorySanitizer::doInitialization(Module &M) {
   auto &DL = M.getDataLayout();

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include <algorithm>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "pgo-instrumentation"
 
 STATISTIC(NumOfPGOInstrument, "Number of edges instrumented.");
 STATISTIC(NumOfPGOSelectInsts, "Number of select instruction instrumented.");
 STATISTIC(NumOfPGOEdge, "Number of edges.");
 STATISTIC(NumOfPGOBB, "Number of basic-blocks.");
 STATISTIC(NumOfPGOSplit, "Number of critical edge splits.");
if (Error E = ReaderOrErr.takeError()) {
     });
     return false;
   }
 
   std::unique_ptr<IndexedInstrProfReader> PGOReader =
       std::move(ReaderOrErr.get());
   if (!PGOReader) {
     Ctx.diagnose(DiagnosticInfoPGOProfile(ProfileFileName.data(),
-                                          StringRef("Cannot get PGOReader")));
+                                          "Cannot get PGOReader"_sr));
     return false;
   }
   // TODO: might need to change the warning once the clang option is finalized.
   if (!PGOReader->isIRLevelProfile()) {
     Ctx.diagnose(DiagnosticInfoPGOProfile(
         ProfileFileName.data(), "Not an IR level instrumentation profile"));
     return false;
   }

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Instrumentation.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 #define DEBUG_TYPE "sancov"
 
 static const char *const SanCovModuleInitName = "__sanitizer_cov_module_init";
 static const char *const SanCovName = "__sanitizer_cov";
 static const char *const SanCovWithCheckName = "__sanitizer_cov_with_check";
 static const char *const SanCovIndirCallName = "__sanitizer_cov_indir_call16";
 static const char *const SanCovTracePCIndirName =
SanCovTraceGepFunction =
       checkSanitizerInterfaceFunction(M.getOrInsertFunction(
           SanCovTraceGep, VoidTy, IntptrTy, nullptr));
   SanCovTraceSwitchFunction =
       checkSanitizerInterfaceFunction(M.getOrInsertFunction(
           SanCovTraceSwitchName, VoidTy, Int64Ty, Int64PtrTy, nullptr));
 
   // We insert an empty inline asm after cov callbacks to avoid callback merge.
   EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false),
-                            StringRef(""), StringRef(""),
+                            ""_sr, ""_sr,
                             /*hasSideEffects=*/true);
 
   SanCovTracePC = checkSanitizerInterfaceFunction(
       M.getOrInsertFunction(SanCovTracePCName, VoidTy, nullptr));
   SanCovTracePCGuard = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       SanCovTracePCGuardName, VoidTy, Int32PtrTy, nullptr));
   SanCovTraceEnter = checkSanitizerInterfaceFunction(
       M.getOrInsertFunction(SanCovTraceEnterName, VoidTy, Int32PtrTy, nullptr));

tools/dsymutil/MachOUtils.cpp

 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCMachObjectWriter.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 
+using namespace llvm::operators;
+
 namespace llvm {
 namespace dsymutil {
 namespace MachOUtils {
 
 std::string getArchName(StringRef Arch) {
   if (Arch.startswith("thumb"))
     return (llvm::Twine("arm") + Arch.drop_front(5)).str();
   return Arch;

 // When the __LINKEDIT segment is transfered, its offset and size are set resp.
 // to \a LinkeditOffset and \a LinkeditSize.
 template <typename SegmentTy>
 static void transferSegmentAndSections(
     const object::MachOObjectFile::LoadCommandInfo &LCI, SegmentTy Segment,
     const object::MachOObjectFile &Obj, MCObjectWriter &Writer,
     uint64_t LinkeditOffset, uint64_t LinkeditSize, uint64_t DwarfSegmentSize,
     uint64_t &GapForDwarf, uint64_t &EndAddress) {
-  if (StringRef("__DWARF") == Segment.segname)
+  if ("__DWARF"_sr == Segment.segname)
     return;
 
   Segment.fileoff = Segment.filesize = 0;
 
-  if (StringRef("__LINKEDIT") == Segment.segname) {
+  if ("__LINKEDIT"_sr == Segment.segname) {
     Segment.fileoff = LinkeditOffset;
     Segment.filesize = LinkeditSize;
   }
 
   // Check if the end address of the last segment and our current
   // start address leave a sufficient gap to store the __DWARF
   // segment.
   uint64_t PrevEndAddress = EndAddress;
if (Obj.is64Bit())
     return Obj.getHeader64().filetype != MachO::MH_OBJECT;
   else
     return Obj.getHeader().filetype != MachO::MH_OBJECT;
 }
 
 static bool hasLinkEditSegment(const object::MachOObjectFile &Obj) {
   bool HasLinkEditSegment = false;
   iterateOnSegments(Obj, [&](const MachO::segment_command_64 &Segment) {
-    if (StringRef("__LINKEDIT") == Segment.segname)
+    if ("__LINKEDIT"_sr == Segment.segname)
       HasLinkEditSegment = true;
   });
   return HasLinkEditSegment;
 }
 
 static unsigned segmentLoadCommandSize(bool Is64Bit, unsigned NumSections) {
   if (Is64Bit)
     return sizeof(MachO::segment_command_64) +
if (ShouldEmitSymtab) {
     LoadCommandSize += sizeof(MachO::symtab_command);
     ++NumLoadCommands;
   }
 
   unsigned HeaderSize =
       Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
   // We will copy every segment that isn't __DWARF.
   iterateOnSegments(InputBinary, [&](const MachO::segment_command_64 &Segment) {
-    if (StringRef("__DWARF") == Segment.segname)
+    if ("__DWARF"_sr == Segment.segname)
       return;
 
     ++NumLoadCommands;
     LoadCommandSize += segmentLoadCommandSize(Is64Bit, Segment.nsects);
   });
 
   // We will add our own brand new __DWARF segment if we have debug
   // info.

tools/dsymutil/dsymutil.cpp

 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/TargetSelect.h"
 #include <cstdint>
 #include <string>
 
 using namespace llvm::dsymutil;
+using namespace llvm::operators;
 
 namespace {
 using namespace llvm::cl;
 
 OptionCategory DsymCategory("Specific Options");
 static opt<bool> Help("h", desc("Alias for -help"), Hidden);
 static opt<bool> Version("v", desc("Alias for -version"), Hidden);
 
static std::string getOutputFileName(llvm::StringRef InputFile,
   // A bundle hierarchy looks like this:
   //   <bundle name>.dSYM/
   //       Contents/
   //          Info.plist
   //          Resources/
   //             DWARF/
   //                <DWARF file(s)>
   std::string DwarfFile =
-      InputFile == "-" ? llvm::StringRef("a.out") : InputFile;
+      InputFile == "-" ? "a.out"_sr : InputFile;
   llvm::SmallString<128> BundleDir(OutputFileOpt);
   if (BundleDir.empty())
     BundleDir = DwarfFile + ".dSYM";
   if (!createBundleDir(BundleDir) || !createPlistFile(BundleDir))
     return "";
 
   llvm::sys::path::append(BundleDir, "Contents", "Resources", "DWARF",
                           llvm::sys::path::filename(DwarfFile));

tools/llvm-pdbdump/LLVMOutputStyle.cpp

 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
 #include "llvm/Object/COFF.h"
 
 #include <unordered_map>
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::msf;
+using namespace llvm::operators;
 using namespace llvm::pdb;
 
 namespace {
 struct PageStats {
   explicit PageStats(const BitVector &FreePages)
       : Upm(FreePages), ActualUsedPages(FreePages.size()),
         MultiUsePages(FreePages.size()), UseAfterFreePages(FreePages.size()) {
     const_cast<BitVector &>(Upm).flip();
for (auto &Modi : DS->modules()) {
                 else
                   return Result.takeError();
                 P.flush();
                 for (const auto &N : L.LineNumbers) {
                   DictScope DDD(P, "Line");
                   LineInfo LI(N.Flags);
                   P.printNumber("Offset", N.Offset);
                   if (LI.isAlwaysStepInto())
-                    P.printString("StepInto", StringRef("Always"));
+                    P.printString("StepInto", "Always"_sr);
                   else if (LI.isNeverStepInto())
-                    P.printString("StepInto", StringRef("Never"));
+                    P.printString("StepInto", "Never"_sr);
                   else
                     P.printNumber("LineNumberStart", LI.getStartLine());
                   P.printNumber("EndDelta", LI.getLineDelta());
                   P.printBoolean("IsStatement", LI.isStatement());
                 }
                 for (const auto &C : L.Columns) {
                   DictScope DDD(P, "Column");
                   P.printNumber("Start", C.StartColumn);

tools/llvm-readobj/ARMAttributeParser.cpp

 #include "ARMAttributeParser.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace llvm::ARMBuildAttrs;
+using namespace llvm::operators;
 
 
 static const EnumEntry<unsigned> TagNames[] = {
   { "Tag_File", ARMBuildAttrs::File },
   { "Tag_Section", ARMBuildAttrs::Section },
   { "Tag_Symbol", ARMBuildAttrs::Symbol },
 };
 
void ARMAttributeParser::compatibility(AttrType Tag, const uint8_t *Data,
   StringRef String = ParseString(Data, Offset);
 
   DictScope AS(SW, "Attribute");
   SW.printNumber("Tag", Tag);
   SW.startLine() << "Value: " << Integer << ", " << String << '\n';
   SW.printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
   switch (Integer) {
   case 0:
-    SW.printString("Description", StringRef("No Specific Requirements"));
+    SW.printString("Description", "No Specific Requirements"_sr);
     break;
   case 1:
-    SW.printString("Description", StringRef("AEABI Conformant"));
+    SW.printString("Description", "AEABI Conformant"_sr);
     break;
   default:
-    SW.printString("Description", StringRef("AEABI Non-Conformant"));
+    SW.printString("Description", "AEABI Non-Conformant"_sr);
     break;
   }
 }
 
 void ARMAttributeParser::CPU_unaligned_access(AttrType Tag, const uint8_t *Data,
                                               uint32_t &Offset) {
   static const char *const Strings[] = { "Not Permitted", "v6-style" };
 

tools/llvm-readobj/ARMEHABIPrinter.h

 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Support/ARMEHABI.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/type_traits.h"
 
+using namespace llvm::operators;
+
 namespace llvm {
 namespace ARM {
 namespace EHABI {
 
 class OpcodeDecoder {
   ScopedPrinter &SW;
   raw_ostream &OS;
 
void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr *IT,
   /// |1| 0 | Ix | data for pers routine |
   /// +-+---+----+-----------------------+
   /// |  more personality routine data   |
 
   const support::ulittle32_t Word =
     *reinterpret_cast<const support::ulittle32_t *>(Contents->data() + TableEntryOffset);
 
   if (Word & 0x80000000) {
-    SW.printString("Model", StringRef("Compact"));
+    SW.printString("Model", "Compact"_sr);
 
     unsigned PersonalityIndex = (Word & 0x0f000000) >> 24;
     SW.printNumber("PersonalityIndex", PersonalityIndex);
 
     switch (PersonalityIndex) {
     case AEABI_UNWIND_CPP_PR0:
       PrintOpcodes(Contents->data() + TableEntryOffset, 3, 1);
       break;
     case AEABI_UNWIND_CPP_PR1:
     case AEABI_UNWIND_CPP_PR2:
       unsigned AdditionalWords = (Word & 0x00ff0000) >> 16;
       PrintOpcodes(Contents->data() + TableEntryOffset, 2 + 4 * AdditionalWords,
                    2);
       break;
     }
   } else {
-    SW.printString("Model", StringRef("Generic"));
+    SW.printString("Model", "Generic"_sr);
 
     uint64_t Address = PREL31(Word, EHT->sh_addr);
     SW.printHex("PersonalityRoutineAddress", Address);
     if (ErrorOr<StringRef> Name = FunctionAtAddress(EHT->sh_link, Address))
       SW.printString("PersonalityRoutineName", *Name);
   }
 }
 
for (unsigned Entry = 0; Entry < Entries; ++Entry) {
     }
 
     const uint64_t Offset = PREL31(Word0, IT->sh_addr);
     SW.printHex("FunctionAddress", Offset);
     if (ErrorOr<StringRef> Name = FunctionAtAddress(IT->sh_link, Offset))
       SW.printString("FunctionName", *Name);
 
     if (Word1 == EXIDX_CANTUNWIND) {
-      SW.printString("Model", StringRef("CantUnwind"));
+      SW.printString("Model", "CantUnwind"_sr);
       continue;
     }
 
     if (Word1 & 0x80000000) {
-      SW.printString("Model", StringRef("Compact (Inline)"));
+      SW.printString("Model", "Compact (Inline)"_sr);
 
       unsigned PersonalityIndex = (Word1 & 0x0f000000) >> 24;
       SW.printNumber("PersonalityIndex", PersonalityIndex);
 
       PrintOpcodes(Contents->data() + Entry * IndexTableEntrySize + 4, 3, 1);
     } else {
       const Elf_Shdr *EHT =
         FindExceptionTable(SectionIndex, Entry * IndexTableEntrySize + 4);

tools/llvm-readobj/COFFDumper.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
 #include <system_error>
 #include <time.h>
 
 using namespace llvm;
 using namespace llvm::object;
+using namespace llvm::operators;
 using namespace llvm::codeview;
 using namespace llvm::msf;
 using namespace llvm::support;
 using namespace llvm::Win64EH;
 
 namespace {
 
 class COFFDumper : public ObjDumper {
while (DE.isValidOffset(Offset)) {
           error(object_error::parse_failed);
           return;
         }
         char Buffer[32];
         format("+0x%X", PC).snprint(Buffer, 32);
         ListScope PCScope(W, Buffer);
         LineInfo LI(LineData);
         if (LI.isAlwaysStepInto())
-          W.printString("StepInto", StringRef("Always"));
+          W.printString("StepInto", "Always"_sr);
         else if (LI.isNeverStepInto())
-          W.printString("StepInto", StringRef("Never"));
+          W.printString("StepInto", "Never"_sr);
         else
           W.printNumber("LineNumberStart", LI.getStartLine());
         W.printNumber("LineNumberEndDelta", LI.getLineDelta());
         W.printBoolean("IsStatement", LI.isStatement());
         if (HasColumnInformation &&
             ColumnDE.isValidOffsetForDataOfSize(ColumnOffset, 4)) {
           uint16_t ColStart = ColumnDE.getU16(&ColumnOffset);
           W.printNumber("ColStart", ColStart);
getSectionName(const llvm::object::COFFObjectFile *Obj, int32_t SectionNumber,
                const coff_section *Section) {
   if (Section) {
     StringRef SectionName;
     if (std::error_code EC = Obj->getSectionName(Section, SectionName))
       return EC;
     return SectionName;
   }
   if (SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
-    return StringRef("IMAGE_SYM_DEBUG");
+    return "IMAGE_SYM_DEBUG"_sr;
   if (SectionNumber == llvm::COFF::IMAGE_SYM_ABSOLUTE)
-    return StringRef("IMAGE_SYM_ABSOLUTE");
+    return "IMAGE_SYM_ABSOLUTE"_sr;
   if (SectionNumber == llvm::COFF::IMAGE_SYM_UNDEFINED)
-    return StringRef("IMAGE_SYM_UNDEFINED");
-  return StringRef("");
+    return "IMAGE_SYM_UNDEFINED"_sr;
+  return ""_sr;
 }
 
 void COFFDumper::printSymbol(const SymbolRef &Sym) {
   DictScope D(W, "Symbol");
 
   COFFSymbolRef Symbol = Obj->getCOFFSymbol(Sym);
   const coff_section *Section;
   if (std::error_code EC = Obj->getSection(Symbol.getSectionNumber(), Section)) {

tools/llvm-readobj/ELFDumper.cpp

 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MipsABIFlags.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
+using namespace llvm::operators;
 using namespace ELF;
 
 #define LLVM_READOBJ_ENUM_CASE(ns, enum) \
   case ns::enum: return #enum;
 
 #define ENUM_ENT(enum, altName) \
   { #enum, altName, ELF::enum }
 

 template <typename ELFT>
 StringRef ELFDumper<ELFT>::getSymbolVersion(StringRef StrTab,
                                             const Elf_Sym *symb,
                                             bool &IsDefault) const {
   // This is a dynamic symbol. Look in the GNU symbol version table.
   if (!dot_gnu_version_sec) {
     // No version table.
     IsDefault = false;
-    return StringRef("");
+    return ""_sr;
   }
 
   // Determine the position in the symbol table of this entry.
   size_t entry_index = (reinterpret_cast<uintptr_t>(symb) -
                         reinterpret_cast<uintptr_t>(DynSymRegion.Addr)) /
                        sizeof(Elf_Sym);
 
   // Get the corresponding version index entry
   const Elf_Versym *vs = unwrapOrError(
       Obj->template getEntry<Elf_Versym>(dot_gnu_version_sec, entry_index));
   size_t version_index = vs->vs_index & ELF::VERSYM_VERSION;
 
   // Special markers for unversioned symbols.
   if (version_index == ELF::VER_NDX_LOCAL ||
       version_index == ELF::VER_NDX_GLOBAL) {
     IsDefault = false;
-    return StringRef("");
+    return ""_sr;
   }
 
   // Lookup this symbol in the version table
   LoadVersionMap();
   if (version_index >= VersionMap.size() || VersionMap[version_index].isNull())
     reportError("Invalid version entry");
   const VersionMapEntry &entry = VersionMap[version_index];
 
template <class ELFT> void MipsGOTParser<ELFT>::parseGOT() {
 
   W.printHex("Canonical gp value", GOTShdr->sh_addr + 0x7ff0);
   {
     ListScope RS(W, "Reserved entries");
 
     {
       DictScope D(W, "Entry");
       printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
-      W.printString("Purpose", StringRef("Lazy resolver"));
+      W.printString("Purpose", "Lazy resolver"_sr);
     }
 
     if (It != GotLocalEnd && (*It >> (sizeof(GOTEntry) * 8 - 1)) != 0) {
       DictScope D(W, "Entry");
       printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
-      W.printString("Purpose", StringRef("Module pointer (GNU extension)"));
+      W.printString("Purpose", "Module pointer (GNU extension)"_sr);
     }
   }
   {
     ListScope LS(W, "Local entries");
     for (; It != GotLocalEnd; ++It) {
       DictScope D(W, "Entry");
       printGotEntry(GOTShdr->sh_addr, GotBegin, It);
     }

tools/llvm-readobj/Win64EHDumper.cpp

 #include "Win64EHDumper.h"
 #include "llvm-readobj.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 using namespace llvm::object;
+using namespace llvm::operators;
 using namespace llvm::Win64EH;
 
 static const EnumEntry<unsigned> UnwindFlags[] = {
   { "ExceptionHandler", UNW_ExceptionHandler },
   { "TerminateHandler", UNW_TerminateHandler },
   { "ChainInfo"       , UNW_ChainInfo        }
 };
 
void Dumper::printUnwindInfo(const Context &Ctx, const coff_section *Section,
   SW.printNumber("Version", UI.getVersion());
   SW.printFlags("Flags", UI.getFlags(), makeArrayRef(UnwindFlags));
   SW.printNumber("PrologSize", UI.PrologSize);
   if (UI.getFrameRegister()) {
     SW.printEnum("FrameRegister", UI.getFrameRegister(),
                  makeArrayRef(UnwindOpInfo));
     SW.printHex("FrameOffset", UI.getFrameOffset());
   } else {
-    SW.printString("FrameRegister", StringRef("-"));
-    SW.printString("FrameOffset", StringRef("-"));
+    SW.printString("FrameRegister", "-"_sr);
+    SW.printString("FrameOffset", "-"_sr);
   }
 
   SW.printNumber("UnwindCodeCount", UI.NumCodes);
   {
     ListScope UCS(SW, "UnwindCodes");
     ArrayRef<UnwindCode> UC(&UI.UnwindCodes[0], UI.NumCodes);
     for (const UnwindCode *UCI = UC.begin(), *UCE = UC.end(); UCI < UCE; ++UCI) {
       unsigned UsedSlots = getNumUsedSlots(*UCI);

unittests/ADT/APIntTest.cpp

 //===- llvm/unittest/ADT/APInt.cpp - APInt unit tests ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 #include <array>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 
 TEST(APIntTest, ValueInit) {
   APInt Zero = APInt();
   EXPECT_TRUE(!Zero);
   EXPECT_TRUE(!Zero.zext(64));
   EXPECT_TRUE(!Zero.sext(64));

 TEST(APIntTest, StringDeath) {
   EXPECT_DEATH(APInt(0, "", 0), "Bitwidth too small");
   EXPECT_DEATH(APInt(32, "", 0), "Invalid string length");
   EXPECT_DEATH(APInt(32, "0", 0), "Radix should be 2, 8, 10, 16, or 36!");
   EXPECT_DEATH(APInt(32, "", 10), "Invalid string length");
   EXPECT_DEATH(APInt(32, "-", 10), "String is only a sign, needs a value.");
   EXPECT_DEATH(APInt(1, "1234", 10), "Insufficient bit width");
   EXPECT_DEATH(APInt(32, "\0", 10), "Invalid string length");
-  EXPECT_DEATH(APInt(32, StringRef("1\02", 3), 10), "Invalid character in digit string");
+  EXPECT_DEATH(APInt(32, "1\02"_sr, 10), "Invalid character in digit string");
   EXPECT_DEATH(APInt(32, "1L", 10), "Invalid character in digit string");
 }
 #endif
 #endif
 
 TEST(APIntTest, mul_clear) {
   APInt ValA(65, -1ULL);
   APInt ValB(65, 4);

unittests/ADT/STLExtrasTest.cpp

 //===- STLExtrasTest.cpp - Unit tests for STL extras ----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "gtest/gtest.h"
 
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 
 int f(rank<0>) { return 0; }
 int f(rank<1>) { return 1; }
 int f(rank<2>) { return 2; }
 int f(rank<4>) { return 4; }
 
public:
   template <typename... Ts>
   auto operator()(Ts &&... Items)
       -> decltype(std::make_tuple(apply_one(Items)...)) {
     return std::make_tuple(apply_one(Items)...);
   }
 };
 
 TEST(STLExtrasTest, ApplyTupleVariadic) {
-  auto Items = std::make_tuple(1, llvm::StringRef("Test"), 'X');
+  auto Items = std::make_tuple(1, "Test"_sr, 'X');
   auto Values = apply_tuple(apply_variadic(), Items);
 
   EXPECT_EQ(2, std::get<0>(Values));
   EXPECT_EQ("Tes", std::get<1>(Values));
   EXPECT_EQ('Y', std::get<2>(Values));
 }
 }

unittests/ADT/StringRefTest.cpp

std::ostream &operator<<(std::ostream &OS,
   OS << "(" << P.first << ", " << P.second << ")";
   return OS;
 }
 
 }
 
 namespace {
 TEST(StringRefTest, Construction) {
+  using namespace llvm::operators;
+
   EXPECT_EQ("", StringRef());
   EXPECT_EQ("hello", StringRef("hello"));
   EXPECT_EQ("hello", StringRef("hello world", 5));
   EXPECT_EQ("hello", StringRef(std::string("hello")));
+  EXPECT_EQ("", ""_sr);
+  EXPECT_EQ("hello", "hello"_sr);
 }
 
 TEST(StringRefTest, Iteration) {
   StringRef S("hello");
   const char *p = "hello";
   for (const char *it = S.begin(), *ie = S.end(); it != ie; ++it, ++p)
     EXPECT_EQ(*it, *p);
 }

unittests/ADT/StringSwitchTest.cpp

 //===- llvm/unittest/ADT/StringSwitchTest.cpp - StringSwitch unit tests ---===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringSwitch.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 TEST(StringSwitchTest, Case) {
   auto Translate = [](StringRef S) {
     return llvm::StringSwitch<int>(S)
         .Case("0", 0)
         .Case("1", 1)
         .Case("2", 2)
         .Case("3", 3)
TEST(StringSwitchTest, Cases) {
 
   auto Translate = [](StringRef S) {
     return llvm::StringSwitch<OSType>(S)
         .Cases("wind\0ws", "win32", "winnt", OSType::Windows)
         .Cases("linux", "unix", "*nix", "posix", OSType::Linux)
         .Default(OSType::Unknown);
   };
 
-  EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("wind\0ws", 7)));
+  EXPECT_EQ(OSType::Windows, Translate("wind\0ws"_sr));
   EXPECT_EQ(OSType::Windows, Translate("win32"));
   EXPECT_EQ(OSType::Windows, Translate("winnt"));
 
   EXPECT_EQ(OSType::Linux, Translate("linux"));
   EXPECT_EQ(OSType::Linux, Translate("unix"));
   EXPECT_EQ(OSType::Linux, Translate("*nix"));
   EXPECT_EQ(OSType::Linux, Translate("posix"));
 
TEST(StringSwitchTest, CasesLower) {
 
   auto Translate = [](StringRef S) {
     return llvm::StringSwitch<OSType>(S)
         .CasesLower("wind\0ws", "win32", "winnt", OSType::Windows)
         .CasesLower("linux", "unix", "*nix", "posix", OSType::Linux)
         .Default(OSType::Unknown);
   };
 
-  EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("WIND\0WS", 7)));
+  EXPECT_EQ(OSType::Windows, Translate("WIND\0WS"_sr));
   EXPECT_EQ(OSType::Windows, Translate("WIN32"));
   EXPECT_EQ(OSType::Windows, Translate("WINNT"));
 
   EXPECT_EQ(OSType::Linux, Translate("LINUX"));
   EXPECT_EQ(OSType::Linux, Translate("UNIX"));
   EXPECT_EQ(OSType::Linux, Translate("*NIX"));
   EXPECT_EQ(OSType::Linux, Translate("POSIX"));
 
-  EXPECT_EQ(OSType::Windows, Translate(llvm::StringRef("wind\0ws", 7)));
+  EXPECT_EQ(OSType::Windows, Translate("wind\0ws"_sr));
   EXPECT_EQ(OSType::Linux, Translate("linux"));
 
   EXPECT_EQ(OSType::Unknown, Translate("wind"));
   EXPECT_EQ(OSType::Unknown, Translate(""));
 }

unittests/ADT/TwineTest.cpp

 //===- TwineTest.cpp - Twine unit tests -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 
 std::string repr(const Twine &Value) {
   std::string res;
   llvm::raw_string_ostream OS(res);
   Value.printRepr(OS);
   return OS.str();
 }
 
 TEST(TwineTest, Construction) {
   EXPECT_EQ("", Twine().str());
   EXPECT_EQ("hi", Twine("hi").str());
   EXPECT_EQ("hi", Twine(std::string("hi")).str());
-  EXPECT_EQ("hi", Twine(StringRef("hi")).str());
+  EXPECT_EQ("hi", Twine("hi"_sr).str());
   EXPECT_EQ("hi", Twine(StringRef(std::string("hi"))).str());
   EXPECT_EQ("hi", Twine(StringRef("hithere", 2)).str());
   EXPECT_EQ("hi", Twine(SmallString<4>("hi")).str());
 }
 
 TEST(TwineTest, Numbers) {
   EXPECT_EQ("123", Twine(123U).str());
   EXPECT_EQ("123", Twine(123).str());
TEST(TwineTest, Concat) {
   EXPECT_EQ("(Twine cstring:\"a\" rope:(Twine smallstring:\"b\" cstring:\"c\"))",
             repr(Twine("a").concat(Twine(SmallString<3>("b")).concat(Twine("c")))));
 }
 
 TEST(TwineTest, toNullTerminatedStringRef) {
   SmallString<8> storage;
   EXPECT_EQ(0, *Twine("hello").toNullTerminatedStringRef(storage).end());
   EXPECT_EQ(0,
-           *Twine(StringRef("hello")).toNullTerminatedStringRef(storage).end());
+           *Twine("hello"_sr).toNullTerminatedStringRef(storage).end());
   EXPECT_EQ(0, *Twine(SmallString<11>("hello"))
                     .toNullTerminatedStringRef(storage)
                     .end());
 }
 
   // I suppose linking in the entire code generator to add a unit test to check
   // the code size of the concat operation is overkill... :)
 
 } // end anonymous namespace

unittests/Bitcode/BitstreamWriterTest.cpp

 //===- BitstreamWriterTest.cpp - Tests for BitstreamWriter ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Bitcode/BitstreamWriter.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 
 TEST(BitstreamWriterTest, emitBlob) {
   SmallString<64> Buffer;
   BitstreamWriter W(Buffer);
   W.emitBlob("str", /* ShouldEmitSize */ false);
-  EXPECT_EQ(StringRef("str\0", 4), Buffer);
+  EXPECT_EQ("str\0"_sr, Buffer);
 }
 
 TEST(BitstreamWriterTest, emitBlobWithSize) {
   SmallString<64> Buffer;
   {
     BitstreamWriter W(Buffer);
     W.emitBlob("str");
   }
TEST(BitstreamWriterTest, emitBlobWithSize) {
   }
   EXPECT_EQ(StringRef(Expected), Buffer);
 }
 
 TEST(BitstreamWriterTest, emitBlobEmpty) {
   SmallString<64> Buffer;
   BitstreamWriter W(Buffer);
   W.emitBlob("", /* ShouldEmitSize */ false);
-  EXPECT_EQ(StringRef(""), Buffer);
+  EXPECT_EQ(""_sr, Buffer);
 }
 
 TEST(BitstreamWriterTest, emitBlob4ByteAligned) {
   SmallString<64> Buffer;
   BitstreamWriter W(Buffer);
   W.emitBlob("str0", /* ShouldEmitSize */ false);
-  EXPECT_EQ(StringRef("str0"), Buffer);
+  EXPECT_EQ("str0"_sr, Buffer);
 }
 
 } // end namespace

unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp

 #include "llvm/DebugInfo/MSF/StreamRef.h"
 #include "llvm/DebugInfo/MSF/StreamWriter.h"
 #include "gtest/gtest.h"
 
 #include <unordered_map>
 
 using namespace llvm;
 using namespace llvm::msf;
+using namespace llvm::operators;
 
 namespace {
 
 static const uint32_t BlocksAry[] = {0, 1, 2, 5, 4, 3, 6, 7, 8, 9};
 static uint8_t DataAry[] = {'A', 'B', 'C', 'F', 'E', 'D', 'G', 'H', 'I', 'J'};
 
 class DiscontiguousStream : public WritableStream {
 public:

 TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
                                            F.layout(), F);
 
   StreamReader R(*S);
   StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA";
   EXPECT_NO_ERROR(R.readFixedString(Str, 1));
-  EXPECT_EQ(Str, StringRef("A"));
+  EXPECT_EQ(Str, "A"_sr);
   EXPECT_EQ(0U, S->getNumBytesCopied());
 }
 
 // Tests that a read which crosses a block boundary, but where the subsequent
 // blocks are still contiguous in memory to the previous block works and does
 // not allocate memory.
 TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
                                            F.layout(), F);
   StreamReader R(*S);
   StringRef Str;
   EXPECT_NO_ERROR(R.readFixedString(Str, 2));
-  EXPECT_EQ(Str, StringRef("AB"));
+  EXPECT_EQ(Str, "AB"_sr);
   EXPECT_EQ(0U, S->getNumBytesCopied());
 
   R.setOffset(6);
   EXPECT_NO_ERROR(R.readFixedString(Str, 4));
-  EXPECT_EQ(Str, StringRef("GHIJ"));
+  EXPECT_EQ(Str, "GHIJ"_sr);
   EXPECT_EQ(0U, S->getNumBytesCopied());
 }
 
 // Tests that a read which crosses a block boundary and cannot be referenced
 // contiguously works and allocates only the precise amount of bytes
 // requested.
 TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
                                            F.layout(), F);
   StreamReader R(*S);
   StringRef Str;
   EXPECT_NO_ERROR(R.readFixedString(Str, 10));
-  EXPECT_EQ(Str, StringRef("ABCDEFGHIJ"));
+  EXPECT_EQ(Str, "ABCDEFGHIJ"_sr);
   EXPECT_EQ(10U, S->getNumBytesCopied());
 }
 
 // Test that an out of bounds read which doesn't cross a block boundary
 // fails and allocates no memory.
 TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),

 // beyond the end of a StreamRef fails.
 TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
                                            F.layout(), F);
   StreamReader R(*S);
   StringRef Str;
   EXPECT_NO_ERROR(R.readFixedString(Str, 1));
-  EXPECT_EQ(Str, StringRef("A"));
+  EXPECT_EQ(Str, "A"_sr);
   EXPECT_EQ(0U, S->getNumBytesCopied());
 }
 
 // Tests that a read which is not aligned on the same boundary as a previous
 // cached request, but which is known to overlap that request, shares the
 // previous allocation.
 TEST(MappedBlockStreamTest, UnalignedOverlappingRead) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
                                            F.layout(), F);
   StreamReader R(*S);
   StringRef Str1;
   StringRef Str2;
   EXPECT_NO_ERROR(R.readFixedString(Str1, 7));
-  EXPECT_EQ(Str1, StringRef("ABCDEFG"));
+  EXPECT_EQ(Str1, "ABCDEFG"_sr);
   EXPECT_EQ(7U, S->getNumBytesCopied());
 
   R.setOffset(2);
   EXPECT_NO_ERROR(R.readFixedString(Str2, 3));
-  EXPECT_EQ(Str2, StringRef("CDE"));
+  EXPECT_EQ(Str2, "CDE"_sr);
   EXPECT_EQ(Str1.data() + 2, Str2.data());
   EXPECT_EQ(7U, S->getNumBytesCopied());
 }
 
 // Tests that a read which is not aligned on the same boundary as a previous
 // cached request, but which only partially overlaps a previous cached request,
 // still works correctly and allocates again from the shared pool.
 TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.block_count(),
                                            F.layout(), F);
   StreamReader R(*S);
   StringRef Str1;
   StringRef Str2;
   EXPECT_NO_ERROR(R.readFixedString(Str1, 6));
-  EXPECT_EQ(Str1, StringRef("ABCDEF"));
+  EXPECT_EQ(Str1, "ABCDEF"_sr);
   EXPECT_EQ(6U, S->getNumBytesCopied());
 
   R.setOffset(4);
   EXPECT_NO_ERROR(R.readFixedString(Str2, 4));
-  EXPECT_EQ(Str2, StringRef("EFGH"));
+  EXPECT_EQ(Str2, "EFGH"_sr);
   EXPECT_EQ(10U, S->getNumBytesCopied());
 }
 
 TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) {
   static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
   static uint8_t LargeBuffer[] = {'0', '1', '2', '3', '4', '5',
                                   '6', '7', '8', '9', 'A'};
   static uint8_t SmallBuffer[] = {'0', '1', '2'};

unittests/IR/DebugInfoTest.cpp

 //===- llvm/unittest/IR/DebugInfo.cpp - DebugInfo tests -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 
 TEST(DINodeTest, getFlag) {
   // Some valid flags.
   EXPECT_EQ(DINode::FlagPublic, DINode::getFlag("DIFlagPublic"));
   EXPECT_EQ(DINode::FlagProtected, DINode::getFlag("DIFlagProtected"));
   EXPECT_EQ(DINode::FlagPrivate, DINode::getFlag("DIFlagPrivate"));
   EXPECT_EQ(DINode::FlagVector, DINode::getFlag("DIFlagVector"));
   EXPECT_EQ(DINode::FlagRValueReference,
             DINode::getFlag("DIFlagRValueReference"));
 
   // FlagAccessibility shouldn't work.
   EXPECT_EQ(0u, DINode::getFlag("DIFlagAccessibility"));
 
   // Some other invalid strings.
   EXPECT_EQ(0u, DINode::getFlag("FlagVector"));
   EXPECT_EQ(0u, DINode::getFlag("Vector"));
   EXPECT_EQ(0u, DINode::getFlag("other things"));
   EXPECT_EQ(0u, DINode::getFlag("DIFlagOther"));
 }
 
 TEST(DINodeTest, getFlagString) {
   // Some valid flags.
-  EXPECT_EQ(StringRef("DIFlagPublic"),
+  EXPECT_EQ("DIFlagPublic"_sr,
             DINode::getFlagString(DINode::FlagPublic));
-  EXPECT_EQ(StringRef("DIFlagProtected"),
+  EXPECT_EQ("DIFlagProtected"_sr,
             DINode::getFlagString(DINode::FlagProtected));
-  EXPECT_EQ(StringRef("DIFlagPrivate"),
+  EXPECT_EQ("DIFlagPrivate"_sr,
             DINode::getFlagString(DINode::FlagPrivate));
-  EXPECT_EQ(StringRef("DIFlagVector"),
+  EXPECT_EQ("DIFlagVector"_sr,
             DINode::getFlagString(DINode::FlagVector));
-  EXPECT_EQ(StringRef("DIFlagRValueReference"),
+  EXPECT_EQ("DIFlagRValueReference"_sr,
             DINode::getFlagString(DINode::FlagRValueReference));
 
   // FlagAccessibility actually equals FlagPublic.
-  EXPECT_EQ(StringRef("DIFlagPublic"),
+  EXPECT_EQ("DIFlagPublic"_sr,
             DINode::getFlagString(DINode::FlagAccessibility));
 
   // Some other invalid flags.
   EXPECT_EQ(StringRef(),
             DINode::getFlagString(DINode::FlagPublic | DINode::FlagVector));
   EXPECT_EQ(StringRef(), DINode::getFlagString(DINode::FlagFwdDecl |
                                                DINode::FlagArtificial));
   EXPECT_EQ(StringRef(),

unittests/IR/MDBuilderTest.cpp

 //===- llvm/unittests/MDBuilderTest.cpp - MDBuilder unit tests ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Operator.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 
 class MDBuilderTest : public testing::Test {
 protected:
   LLVMContext Context;
 };
 
 TEST_F(MDBuilderTest, createString) {
   MDBuilder MDHelper(Context);
   MDString *Str0 = MDHelper.createString("");
   MDString *Str1 = MDHelper.createString("string");
-  EXPECT_EQ(Str0->getString(), StringRef(""));
-  EXPECT_EQ(Str1->getString(), StringRef("string"));
+  EXPECT_EQ(Str0->getString(), ""_sr);
+  EXPECT_EQ(Str1->getString(), "string"_sr);
 }
 TEST_F(MDBuilderTest, createFPMath) {
   MDBuilder MDHelper(Context);
   MDNode *MD0 = MDHelper.createFPMath(0.0);
   MDNode *MD1 = MDHelper.createFPMath(1.0);
   EXPECT_EQ(MD0, (MDNode *)nullptr);
   EXPECT_NE(MD1, (MDNode *)nullptr);
   EXPECT_EQ(MD1->getNumOperands(), 1U);

unittests/ProfileData/InstrProfTest.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ProfileData/InstrProfWriter.h"
 #include "llvm/Support/Compression.h"
 #include "gtest/gtest.h"
 #include <cstdarg>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 static ::testing::AssertionResult NoError(Error E) {
   if (!E)
     return ::testing::AssertionSuccess();
   return ::testing::AssertionFailure() << "error: " << toString(std::move(E))
                                        << "\n";
 }
 

 TEST_P(MaybeSparseInstrProfTest, write_and_read_one_function) {
   InstrProfRecord Record("foo", 0x1234, {1, 2, 3, 4});
   NoError(Writer.addRecord(std::move(Record)));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   auto I = Reader->begin(), E = Reader->end();
   ASSERT_TRUE(I != E);
-  ASSERT_EQ(StringRef("foo"), I->Name);
+  ASSERT_EQ("foo"_sr, I->Name);
   ASSERT_EQ(0x1234U, I->Hash);
   ASSERT_EQ(4U, I->Counts.size());
   ASSERT_EQ(1U, I->Counts[0]);
   ASSERT_EQ(2U, I->Counts[1]);
   ASSERT_EQ(3U, I->Counts[2]);
   ASSERT_EQ(4U, I->Counts[3]);
   ASSERT_TRUE(++I == E);
 }
TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write) {
   std::unique_ptr<InstrProfValueData[]> VD =
       R->getValueForSite(IPVK_IndirectCallTarget, 0, &TotalC);
 
   ASSERT_EQ(3U, VD[0].Count);
   ASSERT_EQ(2U, VD[1].Count);
   ASSERT_EQ(1U, VD[2].Count);
   ASSERT_EQ(6U, TotalC);
 
-  ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), StringRef("callee3"));
-  ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), StringRef("callee2"));
-  ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), StringRef("callee1"));
+  ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), "callee3"_sr);
+  ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), "callee2"_sr);
+  ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), "callee1"_sr);
 }
 
 TEST_P(MaybeSparseInstrProfTest, annotate_vp_data) {
   InstrProfRecord Record("caller", 0x1234, {1, 2});
   Record.reserveSites(IPVK_IndirectCallTarget, 1);
   InstrProfValueData VD0[] = {{1000, 1}, {2000, 2}, {3000, 3}, {5000, 5},
                               {4000, 4}, {6000, 6}};
   Record.addValueData(IPVK_IndirectCallTarget, 0, VD0, 6, nullptr);
TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write_with_weight) {
   uint64_t TotalC;
   std::unique_ptr<InstrProfValueData[]> VD =
       R->getValueForSite(IPVK_IndirectCallTarget, 0, &TotalC);
   ASSERT_EQ(30U, VD[0].Count);
   ASSERT_EQ(20U, VD[1].Count);
   ASSERT_EQ(10U, VD[2].Count);
   ASSERT_EQ(60U, TotalC);
 
-  ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), StringRef("callee3"));
-  ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), StringRef("callee2"));
-  ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), StringRef("callee1"));
+  ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), "callee3"_sr);
+  ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), "callee2"_sr);
+  ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), "callee1"_sr);
 }
 
 TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write_big_endian) {
   InstrProfRecord Record1("caller", 0x1234, {1, 2});
   InstrProfRecord Record2("callee1", 0x1235, {3, 4});
   InstrProfRecord Record3("callee2", 0x1235, {3, 4});
   InstrProfRecord Record4("callee3", 0x1235, {3, 4});
 
TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write_big_endian) {
   ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
   ASSERT_EQ(2U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
 
   std::unique_ptr<InstrProfValueData[]> VD =
       R->getValueForSite(IPVK_IndirectCallTarget, 0);
-  ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), StringRef("callee3"));
-  ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), StringRef("callee2"));
-  ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), StringRef("callee1"));
+  ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), "callee3"_sr);
+  ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), "callee2"_sr);
+  ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), "callee1"_sr);
 
   // Restore little endian default:
   Writer.setValueProfDataEndianness(support::little);
 }
 
 TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge1) {
   static const char caller[] = "caller";
   InstrProfRecord Record11(caller, 0x1234, {1, 2});
TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge1) {
   ASSERT_EQ(4U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
   ASSERT_EQ(4U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 4));
 
   std::unique_ptr<InstrProfValueData[]> VD =
       R->getValueForSite(IPVK_IndirectCallTarget, 0);
-  ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), StringRef("callee2"));
+  ASSERT_EQ(StringRef((const char *)VD[0].Value, 7), "callee2"_sr);
   ASSERT_EQ(7U, VD[0].Count);
-  ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), StringRef("callee3"));
+  ASSERT_EQ(StringRef((const char *)VD[1].Value, 7), "callee3"_sr);
   ASSERT_EQ(6U, VD[1].Count);
-  ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), StringRef("callee4"));
+  ASSERT_EQ(StringRef((const char *)VD[2].Value, 7), "callee4"_sr);
   ASSERT_EQ(4U, VD[2].Count);
-  ASSERT_EQ(StringRef((const char *)VD[3].Value, 7), StringRef("callee1"));
+  ASSERT_EQ(StringRef((const char *)VD[3].Value, 7), "callee1"_sr);
   ASSERT_EQ(1U, VD[3].Count);
 
   std::unique_ptr<InstrProfValueData[]> VD_2(
       R->getValueForSite(IPVK_IndirectCallTarget, 2));
-  ASSERT_EQ(StringRef((const char *)VD_2[0].Value, 7), StringRef("callee3"));
+  ASSERT_EQ(StringRef((const char *)VD_2[0].Value, 7), "callee3"_sr);
   ASSERT_EQ(6U, VD_2[0].Count);
-  ASSERT_EQ(StringRef((const char *)VD_2[1].Value, 7), StringRef("callee4"));
+  ASSERT_EQ(StringRef((const char *)VD_2[1].Value, 7), "callee4"_sr);
   ASSERT_EQ(4U, VD_2[1].Count);
-  ASSERT_EQ(StringRef((const char *)VD_2[2].Value, 7), StringRef("callee2"));
+  ASSERT_EQ(StringRef((const char *)VD_2[2].Value, 7), "callee2"_sr);
   ASSERT_EQ(3U, VD_2[2].Count);
-  ASSERT_EQ(StringRef((const char *)VD_2[3].Value, 7), StringRef("callee1"));
+  ASSERT_EQ(StringRef((const char *)VD_2[3].Value, 7), "callee1"_sr);
   ASSERT_EQ(1U, VD_2[3].Count);
 
   std::unique_ptr<InstrProfValueData[]> VD_3(
       R->getValueForSite(IPVK_IndirectCallTarget, 3));
-  ASSERT_EQ(StringRef((const char *)VD_3[0].Value, 7), StringRef("callee1"));
+  ASSERT_EQ(StringRef((const char *)VD_3[0].Value, 7), "callee1"_sr);
   ASSERT_EQ(1U, VD_3[0].Count);
 
   std::unique_ptr<InstrProfValueData[]> VD_4(
       R->getValueForSite(IPVK_IndirectCallTarget, 4));
-  ASSERT_EQ(StringRef((const char *)VD_4[0].Value, 7), StringRef("callee3"));
+  ASSERT_EQ(StringRef((const char *)VD_4[0].Value, 7), "callee3"_sr);
   ASSERT_EQ(6U, VD_4[0].Count);
-  ASSERT_EQ(StringRef((const char *)VD_4[1].Value, 7), StringRef("callee2"));
+  ASSERT_EQ(StringRef((const char *)VD_4[1].Value, 7), "callee2"_sr);
   ASSERT_EQ(4U, VD_4[1].Count);
-  ASSERT_EQ(StringRef((const char *)VD_4[2].Value, 7), StringRef("callee1"));
+  ASSERT_EQ(StringRef((const char *)VD_4[2].Value, 7), "callee1"_sr);
   ASSERT_EQ(2U, VD_4[2].Count);
 }
 
 TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge1_saturation) {
   static const char bar[] = "bar";
 
   const uint64_t Max = std::numeric_limits<uint64_t>::max();
 
TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge1_saturation) {
   ASSERT_EQ(Max, ReadRecord1->Counts[0]);
 
   Expected<InstrProfRecord> ReadRecord2 =
       Reader->getInstrProfRecord("baz", 0x5678);
   ASSERT_TRUE(bool(ReadRecord2));
   ASSERT_EQ(1U, ReadRecord2->getNumValueSites(IPVK_IndirectCallTarget));
   std::unique_ptr<InstrProfValueData[]> VD =
       ReadRecord2->getValueForSite(IPVK_IndirectCallTarget, 0);
-  ASSERT_EQ(StringRef("bar"), StringRef((const char *)VD[0].Value, 3));
+  ASSERT_EQ("bar"_sr, StringRef((const char *)VD[0].Value, 3));
   ASSERT_EQ(Max, VD[0].Count);
 }
 
 // This test tests that when there are too many values
 // for a given site, the merged results are properly
 // truncated.
 TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge_site_trunc) {
   static const char caller[] = "caller";
TEST_P(MaybeSparseInstrProfTest, value_prof_data_read_write) {
   ASSERT_EQ(0U, Record.getNumValueDataForSite(IPVK_IndirectCallTarget, 4));
 
   auto Cmp = [](const InstrProfValueData &VD1, const InstrProfValueData &VD2) {
     return VD1.Count > VD2.Count;
   };
   std::unique_ptr<InstrProfValueData[]> VD_0(
       Record.getValueForSite(IPVK_IndirectCallTarget, 0));
   std::sort(&VD_0[0], &VD_0[5], Cmp);
-  ASSERT_EQ(StringRef((const char *)VD_0[0].Value, 7), StringRef("callee2"));
+  ASSERT_EQ(StringRef((const char *)VD_0[0].Value, 7), "callee2"_sr);
   ASSERT_EQ(1000U, VD_0[0].Count);
-  ASSERT_EQ(StringRef((const char *)VD_0[1].Value, 7), StringRef("callee3"));
+  ASSERT_EQ(StringRef((const char *)VD_0[1].Value, 7), "callee3"_sr);
   ASSERT_EQ(500U, VD_0[1].Count);
-  ASSERT_EQ(StringRef((const char *)VD_0[2].Value, 7), StringRef("callee1"));
+  ASSERT_EQ(StringRef((const char *)VD_0[2].Value, 7), "callee1"_sr);
   ASSERT_EQ(400U, VD_0[2].Count);
-  ASSERT_EQ(StringRef((const char *)VD_0[3].Value, 7), StringRef("callee4"));
+  ASSERT_EQ(StringRef((const char *)VD_0[3].Value, 7), "callee4"_sr);
   ASSERT_EQ(300U, VD_0[3].Count);
-  ASSERT_EQ(StringRef((const char *)VD_0[4].Value, 7), StringRef("callee5"));
+  ASSERT_EQ(StringRef((const char *)VD_0[4].Value, 7), "callee5"_sr);
   ASSERT_EQ(100U, VD_0[4].Count);
 
   std::unique_ptr<InstrProfValueData[]> VD_1(
       Record.getValueForSite(IPVK_IndirectCallTarget, 1));
   std::sort(&VD_1[0], &VD_1[4], Cmp);
-  ASSERT_EQ(StringRef((const char *)VD_1[0].Value, 7), StringRef("callee2"));
+  ASSERT_EQ(StringRef((const char *)VD_1[0].Value, 7), "callee2"_sr);
   ASSERT_EQ(2500U, VD_1[0].Count);
-  ASSERT_EQ(StringRef((const char *)VD_1[1].Value, 7), StringRef("callee1"));
+  ASSERT_EQ(StringRef((const char *)VD_1[1].Value, 7), "callee1"_sr);
   ASSERT_EQ(1300U, VD_1[1].Count);
-  ASSERT_EQ(StringRef((const char *)VD_1[2].Value, 7), StringRef("callee3"));
+  ASSERT_EQ(StringRef((const char *)VD_1[2].Value, 7), "callee3"_sr);
   ASSERT_EQ(1000U, VD_1[2].Count);
-  ASSERT_EQ(StringRef((const char *)VD_1[3].Value, 7), StringRef("callee5"));
+  ASSERT_EQ(StringRef((const char *)VD_1[3].Value, 7), "callee5"_sr);
   ASSERT_EQ(800U, VD_1[3].Count);
 
   std::unique_ptr<InstrProfValueData[]> VD_2(
       Record.getValueForSite(IPVK_IndirectCallTarget, 2));
   std::sort(&VD_2[0], &VD_2[3], Cmp);
-  ASSERT_EQ(StringRef((const char *)VD_2[0].Value, 7), StringRef("callee4"));
+  ASSERT_EQ(StringRef((const char *)VD_2[0].Value, 7), "callee4"_sr);
   ASSERT_EQ(5500U, VD_2[0].Count);
-  ASSERT_EQ(StringRef((const char *)VD_2[1].Value, 7), StringRef("callee3"));
+  ASSERT_EQ(StringRef((const char *)VD_2[1].Value, 7), "callee3"_sr);
   ASSERT_EQ(1000U, VD_2[1].Count);
-  ASSERT_EQ(StringRef((const char *)VD_2[2].Value, 7), StringRef("callee6"));
+  ASSERT_EQ(StringRef((const char *)VD_2[2].Value, 7), "callee6"_sr);
   ASSERT_EQ(800U, VD_2[2].Count);
 
   std::unique_ptr<InstrProfValueData[]> VD_3(
       Record.getValueForSite(IPVK_IndirectCallTarget, 3));
   std::sort(&VD_3[0], &VD_3[2], Cmp);
-  ASSERT_EQ(StringRef((const char *)VD_3[0].Value, 7), StringRef("callee3"));
+  ASSERT_EQ(StringRef((const char *)VD_3[0].Value, 7), "callee3"_sr);
   ASSERT_EQ(2000U, VD_3[0].Count);
-  ASSERT_EQ(StringRef((const char *)VD_3[1].Value, 7), StringRef("callee2"));
+  ASSERT_EQ(StringRef((const char *)VD_3[1].Value, 7), "callee2"_sr);
   ASSERT_EQ(1800U, VD_3[1].Count);
 }
 
 TEST_P(MaybeSparseInstrProfTest, value_prof_data_read_write_mapping) {
 
   InstrProfRecord SrcRecord("caller", 0x1234, {1ULL << 31, 2});
   addValueProfData(SrcRecord);
   std::unique_ptr<ValueProfData> VPData =
TEST_P(MaybeSparseInstrProfTest, instr_prof_symtab_test) {
   FuncNames.push_back("func2");
   FuncNames.push_back("func3");
   FuncNames.push_back("bar1");
   FuncNames.push_back("bar2");
   FuncNames.push_back("bar3");
   InstrProfSymtab Symtab;
   Symtab.create(FuncNames);
   StringRef R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func1"));
-  ASSERT_EQ(StringRef("func1"), R);
+  ASSERT_EQ("func1"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func2"));
-  ASSERT_EQ(StringRef("func2"), R);
+  ASSERT_EQ("func2"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func3"));
-  ASSERT_EQ(StringRef("func3"), R);
+  ASSERT_EQ("func3"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("bar1"));
-  ASSERT_EQ(StringRef("bar1"), R);
+  ASSERT_EQ("bar1"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("bar2"));
-  ASSERT_EQ(StringRef("bar2"), R);
+  ASSERT_EQ("bar2"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("bar3"));
-  ASSERT_EQ(StringRef("bar3"), R);
+  ASSERT_EQ("bar3"_sr, R);
 
   // negative tests
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("bar4"));
   ASSERT_EQ(StringRef(), R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("foo4"));
   ASSERT_EQ(StringRef(), R);
 
   // Now incrementally update the symtab
   Symtab.addFuncName("blah_1");
   Symtab.addFuncName("blah_2");
   Symtab.addFuncName("blah_3");
   // Finalize it
   Symtab.finalizeSymtab();
 
   // Check again
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("blah_1"));
-  ASSERT_EQ(StringRef("blah_1"), R);
+  ASSERT_EQ("blah_1"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("blah_2"));
-  ASSERT_EQ(StringRef("blah_2"), R);
+  ASSERT_EQ("blah_2"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("blah_3"));
-  ASSERT_EQ(StringRef("blah_3"), R);
+  ASSERT_EQ("blah_3"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func1"));
-  ASSERT_EQ(StringRef("func1"), R);
+  ASSERT_EQ("func1"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func2"));
-  ASSERT_EQ(StringRef("func2"), R);
+  ASSERT_EQ("func2"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("func3"));
-  ASSERT_EQ(StringRef("func3"), R);
+  ASSERT_EQ("func3"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("bar1"));
-  ASSERT_EQ(StringRef("bar1"), R);
+  ASSERT_EQ("bar1"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("bar2"));
-  ASSERT_EQ(StringRef("bar2"), R);
+  ASSERT_EQ("bar2"_sr, R);
   R = Symtab.getFuncName(IndexedInstrProf::ComputeHash("bar3"));
-  ASSERT_EQ(StringRef("bar3"), R);
+  ASSERT_EQ("bar3"_sr, R);
 }
 
 // Testing symtab creator interface used by value profile transformer.
 TEST_P(MaybeSparseInstrProfTest, instr_prof_symtab_module_test) {
   LLVMContext Ctx;
   std::unique_ptr<Module> M = llvm::make_unique<Module>("MyModule.cpp", Ctx);
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
                                         /*isVarArg=*/false);
for (int Padding = 0; Padding < 2; Padding++) {
 
       // Now decompress:
       InstrProfSymtab Symtab;
       NoError(Symtab.create(StringRef(FuncNameStrings)));
 
       // Now do the checks:
       // First sampling some data points:
       StringRef R = Symtab.getFuncName(IndexedInstrProf::ComputeHash(FuncNames1[0]));
-      ASSERT_EQ(StringRef("func_0"), R);
+      ASSERT_EQ("func_0"_sr, R);
       R = Symtab.getFuncName(IndexedInstrProf::ComputeHash(FuncNames1[1]));
-      ASSERT_EQ(StringRef("f oooooooooooooo_0"), R);
+      ASSERT_EQ("f oooooooooooooo_0"_sr, R);
       for (int I = 0; I < 3; I++) {
         std::string N[4];
         N[0] = FuncNames1[2 * I];
         N[1] = FuncNames1[2 * I + 1];
         N[2] = FuncNames2[2 * I];
         N[3] = FuncNames2[2 * I + 1];
         for (int J = 0; J < 4; J++) {
           StringRef R = Symtab.getFuncName(IndexedInstrProf::ComputeHash(N[J]));

unittests/Support/CompressionTest.cpp

 
 #include "llvm/Support/Compression.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 
 #if LLVM_ENABLE_ZLIB == 1 && HAVE_LIBZ
 
 void TestZlibCompression(StringRef Input, zlib::CompressionLevel Level) {
   SmallString<32> Compressed;
   SmallString<32> Uncompressed;
TEST(CompressionTest, Zlib) {
   TestZlibCompression(BinaryDataStr, zlib::BestSizeCompression);
   TestZlibCompression(BinaryDataStr, zlib::BestSpeedCompression);
   TestZlibCompression(BinaryDataStr, zlib::DefaultCompression);
 }
 
 TEST(CompressionTest, ZlibCRC32) {
   EXPECT_EQ(
       0x414FA339U,
-      zlib::crc32(StringRef("The quick brown fox jumps over the lazy dog")));
+      zlib::crc32("The quick brown fox jumps over the lazy dog"_sr));
 }
 
 #endif
 
 }

unittests/Support/ConvertUTFTest.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Format.h"
 #include "gtest/gtest.h"
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 TEST(ConvertUTFTest, ConvertUTF16LittleEndianToUTF8String) {
   // Src is the look of disapproval.
   static const char Src[] = "\xff\xfe\xa0\x0c_\x00\xa0\x0c";
   ArrayRef<char> Ref(Src, sizeof(Src) - 1);
   std::string Result;
   bool Success = convertUTF16ToUTF8String(Ref, Result);
   EXPECT_TRUE(Success);
TEST(ConvertUTFTest, UTF8ToUTF32Lenient) {
 
   //
   // First possible sequence of a certain length
   //
 
   // U+0000 NULL
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
       ConvertUTFResultContainer(conversionOK).withScalars(0x0000),
-      StringRef("\x00", 1)));
+      "\x00"_sr));
 
   // U+0080 PADDING CHARACTER
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
       ConvertUTFResultContainer(conversionOK).withScalars(0x0080),
       "\xc2\x80"));
 
   // U+0800 SAMARITAN LETTER ALAF
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
TEST(ConvertUTFTest, UTF8ToUTF32Lenient) {
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
       ConvertUTFResultContainer(sourceIllegal)
           .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
       "\xfc\x80\x80\x80\x80\xaf"));
 
   // U+0000 NULL
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
       ConvertUTFResultContainer(conversionOK).withScalars(0x0000),
-      StringRef("\x00", 1)));
+      "\x00"_sr));
 
   // Overlong sequences of the above.
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
       ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
       "\xc0\x80"));
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
       ConvertUTFResultContainer(sourceIllegal)
           .withScalars(0xfffd, 0xfffd, 0xfffd),

unittests/Support/DwarfTest.cpp

 //===- unittest/Support/DwarfTest.cpp - Dwarf support tests ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Dwarf.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::dwarf;
+using namespace llvm::operators;
 
 namespace {
 
 TEST(DwarfTest, TagStringOnInvalid) {
   // This is invalid, so it shouldn't be stringified.
   EXPECT_EQ(StringRef(), TagString(DW_TAG_invalid));
 
   // These aren't really tags: they describe ranges within tags.  They
TEST(DwarfTest, getAttributeEncoding) {
   EXPECT_EQ(0u, getAttributeEncoding("something else"));
 
   // AttributeEncoding range markers should not be recognized.
   EXPECT_EQ(0u, getAttributeEncoding("DW_ATE_lo_user"));
   EXPECT_EQ(0u, getAttributeEncoding("DW_ATE_hi_user"));
 }
 
 TEST(DwarfTest, VirtualityString) {
-  EXPECT_EQ(StringRef("DW_VIRTUALITY_none"),
+  EXPECT_EQ("DW_VIRTUALITY_none"_sr,
             VirtualityString(DW_VIRTUALITY_none));
-  EXPECT_EQ(StringRef("DW_VIRTUALITY_virtual"),
+  EXPECT_EQ("DW_VIRTUALITY_virtual"_sr,
             VirtualityString(DW_VIRTUALITY_virtual));
-  EXPECT_EQ(StringRef("DW_VIRTUALITY_pure_virtual"),
+  EXPECT_EQ("DW_VIRTUALITY_pure_virtual"_sr,
             VirtualityString(DW_VIRTUALITY_pure_virtual));
 
   // DW_VIRTUALITY_max should be pure virtual.
-  EXPECT_EQ(StringRef("DW_VIRTUALITY_pure_virtual"),
+  EXPECT_EQ("DW_VIRTUALITY_pure_virtual"_sr,
             VirtualityString(DW_VIRTUALITY_max));
 
   // Invalid numbers shouldn't be stringified.
   EXPECT_EQ(StringRef(), VirtualityString(DW_VIRTUALITY_max + 1));
   EXPECT_EQ(StringRef(), VirtualityString(DW_VIRTUALITY_max + 77));
 }
 
 TEST(DwarfTest, getVirtuality) {

unittests/Support/Path.cpp

 #include <winerror.h>
 #endif
 
 #ifdef LLVM_ON_UNIX
 #include <sys/stat.h>
 #endif
 
 using namespace llvm;
+using namespace llvm::operators;
 using namespace llvm::sys;
 
 #define ASSERT_NO_ERROR(x)                                                     \
   if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
     SmallString<128> MessageStorage;                                           \
     raw_svector_ostream Message(MessageStorage);                               \
     Message << #x ": did not return errc::success.\n"                          \
             << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
TEST(Support, Path) {
 
   SmallString<32> Relative("foo.cpp");
   ASSERT_NO_ERROR(sys::fs::make_absolute("/root", Relative));
   Relative[5] = '/'; // Fix up windows paths.
   ASSERT_EQ("/root/foo.cpp", Relative);
 }
 
 TEST(Support, RelativePathIterator) {
-  SmallString<64> Path(StringRef("c/d/e/foo.txt"));
+  SmallString<64> Path("c/d/e/foo.txt"_sr);
   typedef SmallVector<StringRef, 4> PathComponents;
   PathComponents ExpectedPathComponents;
   PathComponents ActualPathComponents;
 
   StringRef(Path).split(ExpectedPathComponents, '/');
 
   for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
        ++I) {
     ActualPathComponents.push_back(*I);
   }
 
   ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
 
   for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
     EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
   }
 }
 
 TEST(Support, RelativePathDotIterator) {
-  SmallString<64> Path(StringRef(".c/.d/../."));
+  SmallString<64> Path(".c/.d/../."_sr);
   typedef SmallVector<StringRef, 4> PathComponents;
   PathComponents ExpectedPathComponents;
   PathComponents ActualPathComponents;
 
   StringRef(Path).split(ExpectedPathComponents, '/');
 
   for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
        ++I) {
     ActualPathComponents.push_back(*I);
   }
 
   ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
 
   for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
     EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
   }
 }
 
 TEST(Support, AbsolutePathIterator) {
-  SmallString<64> Path(StringRef("/c/d/e/foo.txt"));
+  SmallString<64> Path("/c/d/e/foo.txt"_sr);
   typedef SmallVector<StringRef, 4> PathComponents;
   PathComponents ExpectedPathComponents;
   PathComponents ActualPathComponents;
 
   StringRef(Path).split(ExpectedPathComponents, '/');
 
   // The root path will also be a component when iterating
   ExpectedPathComponents[0] = "/";
 
   for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
        ++I) {
     ActualPathComponents.push_back(*I);
   }
 
   ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
 
   for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
     EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
   }
 }
 
 TEST(Support, AbsolutePathDotIterator) {
-  SmallString<64> Path(StringRef("/.c/.d/../."));
+  SmallString<64> Path("/.c/.d/../."_sr);
   typedef SmallVector<StringRef, 4> PathComponents;
   PathComponents ExpectedPathComponents;
   PathComponents ActualPathComponents;
 
   StringRef(Path).split(ExpectedPathComponents, '/');
 
   // The root path will also be a component when iterating
   ExpectedPathComponents[0] = "/";
 
   for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
        ++I) {
     ActualPathComponents.push_back(*I);
   }
 
   ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
 
   for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
     EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
   }
 }
 
 #ifdef LLVM_ON_WIN32
 TEST(Support, AbsolutePathIteratorWin32) {
-  SmallString<64> Path(StringRef("c:\\c\\e\\foo.txt"));
+  SmallString<64> Path("c:\\c\\e\\foo.txt"_sr);
   typedef SmallVector<StringRef, 4> PathComponents;
   PathComponents ExpectedPathComponents;
   PathComponents ActualPathComponents;
 
   StringRef(Path).split(ExpectedPathComponents, "\\");
 
   // The root path (which comes after the drive name) will also be a component
   // when iterating.

unittests/Support/TargetParserTest.cpp

 //===----------- TargetParser.cpp - Target Parser -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/TargetParser.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace llvm;
+using namespace llvm::operators;
 
 namespace {
 static const unsigned kAArch64ArchExtKinds[] = {
 #define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) ID,
 #include "llvm/Support/AArch64TargetParser.def"
 #undef AARCH64_ARCH_EXT_NAME
 };
 
else
       EXPECT_LE(0U, ARM::getFPURestriction(FK));
 }
 
 TEST(TargetParserTest, ARMDefaultFPU) {
   for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
        AK < ARM::ArchKind::AK_LAST;
        AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
     EXPECT_EQ(kARMARCHNames[AK].DefaultFPU,
-              ARM::getDefaultFPU(StringRef("generic"), AK));
+              ARM::getDefaultFPU("generic"_sr, AK));
 
   for (const auto &ARMCPUName : kARMCPUNames)
     EXPECT_EQ(ARMCPUName.DefaultFPU, ARM::getDefaultFPU(ARMCPUName.Name, 0));
 }
 
 TEST(TargetParserTest, ARMDefaultExtensions) {
   for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
        AK < ARM::ArchKind::AK_LAST;
        AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
     EXPECT_EQ(kARMARCHNames[AK].ArchBaseExtensions,
-              ARM::getDefaultExtensions(StringRef("generic"), AK));
+              ARM::getDefaultExtensions("generic"_sr, AK));
 
   for (const auto &ARMCPUName : kARMCPUNames) {
     unsigned DefaultExt =
         kARMARCHNames[ARMCPUName.ID].ArchBaseExtensions | ARMCPUName.DefaultExt;
     EXPECT_EQ(DefaultExt, ARM::getDefaultExtensions(ARMCPUName.Name, 0));
   }
 }
 
for (unsigned i = 0; i < array_lengthof(ARMArch); i++)
     else
       EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i]));
 }
 
 TEST(TargetParserTest, AArch64DefaultFPU) {
   for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
        AK++)
     EXPECT_EQ(kAArch64ARCHNames[AK].DefaultFPU,
-              AArch64::getDefaultFPU(StringRef("generic"), AK));
+              AArch64::getDefaultFPU("generic"_sr, AK));
 
   for (const auto &AArch64CPUName : kAArch64CPUNames)
     EXPECT_EQ(AArch64CPUName.DefaultFPU,
               AArch64::getDefaultFPU(AArch64CPUName.Name,
                                      static_cast<unsigned>(AArch64CPUName.ID)));
 }
 
 TEST(TargetParserTest, AArch64DefaultExt) {
   for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
        AK++)
     EXPECT_EQ(kAArch64ARCHNames[AK].ArchBaseExtensions,
-              AArch64::getDefaultExtensions(StringRef("generic"), AK));
+              AArch64::getDefaultExtensions("generic"_sr, AK));
 
   for (const auto &AArch64CPUName : kAArch64CPUNames)
     EXPECT_EQ(
         AArch64CPUName.DefaultExt,
         AArch64::getDefaultExtensions(
             AArch64CPUName.Name, static_cast<unsigned>(AArch64CPUName.ID)));
 }
 

unittests/Support/YAMLIOTest.cpp

 //===- unittest/Support/YAMLIOTest.cpp ------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "gtest/gtest.h"
 
+using namespace llvm::operators;
 
 using llvm::yaml::Input;
 using llvm::yaml::Output;
 using llvm::yaml::IO;
 using llvm::yaml::MappingTraits;
 using llvm::yaml::MappingNormalization;
 using llvm::yaml::ScalarTraits;
 using llvm::yaml::Hex8;

 //
 // Test writing then reading back custom values
 //
 TEST(YAMLIO, TestReadWriteMyFlowSequence) {
   std::string intermediate;
   {
     NameAndNumbers map;
     map.name  = "hello";
-    map.strings.push_back(llvm::StringRef("one"));
-    map.strings.push_back(llvm::StringRef("two"));
+    map.strings.push_back("one"_sr);
+    map.strings.push_back("two"_sr);
     map.single.push_back(1);
     map.numbers.push_back(10);
     map.numbers.push_back(-30);
     map.numbers.push_back(1024);
 
     llvm::raw_string_ostream ostr(intermediate);
     Output yout(ostr);
     yout << map;

utils/FileCheck/FileCheck.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cctype>
 #include <map>
 #include <string>
 #include <system_error>
 #include <vector>
 using namespace llvm;
+using namespace llvm::operators;
 
 static cl::opt<std::string>
 CheckFilename(cl::Positional, cl::desc("<check-file>"), cl::Required);
 
 static cl::opt<std::string>
 InputFilename("input-file", cl::desc("File to check (defaults to stdin)"),
               cl::init("-"), cl::value_desc("filename"));
 
std::string Backref = std::string("\\") +
                         std::string(1, '0' + BackrefNum);
   RegExStr += Backref;
 }
 
 bool Pattern::EvaluateExpression(StringRef Expr, std::string &Value) const {
   // The only supported expression is @LINE([\+-]\d+)?
   if (!Expr.startswith("@LINE"))
     return false;
-  Expr = Expr.substr(StringRef("@LINE").size());
+  Expr = Expr.substr("@LINE"_sr.size());
   int Offset = 0;
   if (!Expr.empty()) {
     if (Expr[0] == '+')
       Expr = Expr.substr(1);
     else if (Expr[0] != '-')
       return false;
     if (Expr.getAsInteger(10, Offset))
       return false;