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

882

Does this operator need it's own namespace?

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1221 ↗

(On Diff #76984)

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?

86–88

same.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1221 ↗

(On Diff #76984)

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 ↗

(On Diff #76984)

Why not just return "";?

lib/IR/Value.cpp

197 ↗

(On Diff #76984)

same.

lib/MC/MCAsmStreamer.cpp

350 ↗

(On Diff #76984)

Same in this context.

[malcolm.parsons]

include/llvm/ADT/StringRef.h

74

No.

86–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 ↗

(On Diff #76984)

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) {}
 
     /// 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.
   LLVM_NODISCARD
   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; };
+
+  inline 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

include/llvm/Support/CommandLine.h

 class OptionCategory {
 private:
   StringRef const Name;
   StringRef const Description;
   void registerCategory();
 
 public:
   OptionCategory(StringRef const Name,
-                 StringRef const Description = "")
+                 StringRef const Description = StringRef())
       : Name(Name), Description(Description) {
     registerCategory();
   }
   StringRef getName() const { return Name; }
   StringRef getDescription() const { return Description; }
 };
 
 // The general Option Category (used as default category).
 extern OptionCategory GeneralCategory;
 
 //===----------------------------------------------------------------------===//
 // SubCommand class
 //
 class SubCommand {
 private:
-  StringRef Name = "";
-  StringRef Description = "";
+  StringRef Name;
+  StringRef Description;
 
 protected:
   void registerSubCommand();
   void unregisterSubCommand();
 
 public:
   SubCommand(StringRef Name, StringRef Description = "")
       : Name(Name), Description(Description) {
public:
   void setCategory(OptionCategory &C) { Category = &C; }
   void addSubCommand(SubCommand &S) { Subs.insert(&S); }
 
 protected:
   explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
                   enum OptionHidden Hidden)
       : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
         HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0), Position(0),
-        AdditionalVals(0), ArgStr(""), HelpStr(""), ValueStr(""),
-        Category(&GeneralCategory), FullyInitialized(false) {}
+        AdditionalVals(0), Category(&GeneralCategory), FullyInitialized(false) {
+  }
 
   inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
 
 public:
   // addArgument - Register this argument with the commandline system.
   //
   void addArgument();
 

 // This represents a single enum value, using "int" as the underlying type.
 struct OptionEnumValue {
   StringRef Name;
   int Value;
   StringRef Description;
 };
 
 #define clEnumVal(ENUMVAL, DESC)                                               \
-  llvm::cl::OptionEnumValue { #ENUMVAL, int(ENUMVAL), DESC }
+  llvm::cl::OptionEnumValue { #ENUMVAL##_sr, int(ENUMVAL), DESC##_sr }
 #define clEnumValN(ENUMVAL, FLAGNAME, DESC)                                    \
-  llvm::cl::OptionEnumValue { FLAGNAME, int(ENUMVAL), DESC }
+  llvm::cl::OptionEnumValue { FLAGNAME##_sr, int(ENUMVAL), DESC##_sr }
 
 // values - For custom data types, allow specifying a group of values together
 // as the values that go into the mapping that the option handler uses.
 //
 class ValuesClass {
   // Use a vector instead of a map, because the lists should be short,
   // the overhead is less, and most importantly, it keeps them in the order
   // inserted so we can print our option out nicely.

lib/IR/DiagnosticInfo.cpp

 };
 
 static PassRemarksOpt PassRemarksOptLoc;
 static PassRemarksOpt PassRemarksMissedOptLoc;
 static PassRemarksOpt PassRemarksAnalysisOptLoc;
 
 // -pass-remarks
 //    Command line flag to enable emitOptimizationRemark()
-static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>
-PassRemarks("pass-remarks", cl::value_desc("pattern"),
-            cl::desc("Enable optimization remarks from passes whose name match "
-                     "the given regular expression"),
-            cl::Hidden, cl::location(PassRemarksOptLoc), cl::ValueRequired,
-            cl::ZeroOrMore);
+static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarks(
+    "pass-remarks"_sr, cl::value_desc("pattern"_sr),
+             "the given regular expression"_sr),
 
 // -pass-remarks-missed
 //    Command line flag to enable emitOptimizationRemarkMissed()
 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarksMissed(
-    "pass-remarks-missed", cl::value_desc("pattern"),
+    "pass-remarks-missed"_sr, cl::value_desc("pattern"_sr),
     cl::desc("Enable missed optimization remarks from passes whose name match "
-             "the given regular expression"),
+             "the given regular expression"_sr),
     cl::Hidden, cl::location(PassRemarksMissedOptLoc), cl::ValueRequired,
     cl::ZeroOrMore);
 
 // -pass-remarks-analysis
 //    Command line flag to enable emitOptimizationRemarkAnalysis()
 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>
     PassRemarksAnalysis(
-    "pass-remarks-analysis", cl::value_desc("pattern"),
+        "pass-remarks-analysis"_sr, cl::value_desc("pattern"_sr),
         cl::desc(
             "Enable optimization analysis remarks from passes whose name match "
-        "the given regular expression"),
+            "the given regular expression"_sr),
         cl::Hidden, cl::location(PassRemarksAnalysisOptLoc), cl::ValueRequired,
         cl::ZeroOrMore);
 }
 
 int llvm::getNextAvailablePluginDiagnosticKind() {
   static std::atomic<int> PluginKindID(DK_FirstPluginKind);
   return ++PluginKindID;
 }
 
 const char *OptimizationRemarkAnalysis::AlwaysPrint = "";

lib/IR/Dominators.cpp

 using namespace llvm;
 
 // Always verify dominfo if expensive checking is enabled.
 #ifdef EXPENSIVE_CHECKS
 static bool VerifyDomInfo = true;
 #else
 static bool VerifyDomInfo = false;
 #endif
-static cl::opt<bool,true>
-VerifyDomInfoX("verify-dom-info", cl::location(VerifyDomInfo),
-               cl::desc("Verify dominator info (time consuming)"));
+static cl::opt<bool, true>
+    VerifyDomInfoX("verify-dom-info"_sr, cl::location(VerifyDomInfo),
+                   cl::desc("Verify dominator info (time consuming)"_sr));
 
 bool BasicBlockEdge::isSingleEdge() const {
   const TerminatorInst *TI = Start->getTerminator();
   unsigned NumEdgesToEnd = 0;
   for (unsigned int i = 0, n = TI->getNumSuccessors(); i < n; ++i) {
     if (TI->getSuccessor(i) == End)
       ++NumEdgesToEnd;
     if (NumEdgesToEnd >= 2)

lib/IR/LegacyPassManager.cpp

 
 namespace {
 // Different debug levels that can be enabled...
 enum PassDebugLevel {
   Disabled, Arguments, Structure, Executions, Details
 };
 }
 
-static cl::opt<enum PassDebugLevel>
-PassDebugging("debug-pass", cl::Hidden,
-                  cl::desc("Print PassManager debugging information"),
-                  cl::values(
-  clEnumVal(Disabled  , "disable debug output"),
-  clEnumVal(Arguments , "print pass arguments to pass to 'opt'"),
-  clEnumVal(Structure , "print pass structure before run()"),
+static cl::opt<enum PassDebugLevel> PassDebugging(
+    "debug-pass"_sr, cl::Hidden,
+    cl::desc("Print PassManager debugging information"_sr),
+    cl::values(clEnumVal(Disabled, "disable debug output"),
+               clEnumVal(Arguments, "print pass arguments to pass to 'opt'"),
+               clEnumVal(Structure, "print pass structure before run()"),
                clEnumVal(Executions, "print pass name before it is executed"),
-  clEnumVal(Details   , "print pass details when it is executed")));
+               clEnumVal(Details, "print pass details when it is executed")));
 
 namespace {
 typedef llvm::cl::list<const llvm::PassInfo *, bool, PassNameParser>
 PassOptionList;
 }
 
 // Print IR out before/after specified passes.
 static PassOptionList
-PrintBefore("print-before",
-            llvm::cl::desc("Print IR before specified passes"),
+    PrintBefore("print-before"_sr,
+                llvm::cl::desc("Print IR before specified passes"_sr),
                 cl::Hidden);
 
 static PassOptionList
-PrintAfter("print-after",
-           llvm::cl::desc("Print IR after specified passes"),
+    PrintAfter("print-after"_sr,
+               llvm::cl::desc("Print IR after specified passes"_sr),
                cl::Hidden);
 
 static cl::opt<bool>
-PrintBeforeAll("print-before-all",
-               llvm::cl::desc("Print IR before each pass"),
+    PrintBeforeAll("print-before-all"_sr,
+                   llvm::cl::desc("Print IR before each pass"_sr),
                    cl::init(false));
 static cl::opt<bool>
-PrintAfterAll("print-after-all",
-              llvm::cl::desc("Print IR after each pass"),
+    PrintAfterAll("print-after-all"_sr,
+                  llvm::cl::desc("Print IR after each pass"_sr),
                   cl::init(false));
 
 static cl::list<std::string>
-    PrintFuncsList("filter-print-funcs", cl::value_desc("function names"),
+    PrintFuncsList("filter-print-funcs"_sr, cl::value_desc("function names"_sr),
                    cl::desc("Only print IR for functions whose name "
                             "match this for all print-[before|after][-all] "
-                            "options"),
+                            "options"_sr),
                    cl::CommaSeparated);
 
 /// This is a helper to determine whether to print IR before or
 /// after a pass.
 
 static bool ShouldPrintBeforeOrAfterPass(const PassInfo *PI,
                                          PassOptionList &PassesToPrint) {
   for (auto *PassInf : PassesToPrint) {

 bool PassManager::run(Module &M) {
   return PM->run(M);
 }
 
 //===----------------------------------------------------------------------===//
 // TimingInfo implementation
 
 bool llvm::TimePassesIsEnabled = false;
-static cl::opt<bool,true>
-EnableTiming("time-passes", cl::location(TimePassesIsEnabled),
-            cl::desc("Time each pass, printing elapsed time for each on exit"));
+static cl::opt<bool, true> EnableTiming(
+    "time-passes"_sr, cl::location(TimePassesIsEnabled),
+    cl::desc("Time each pass, printing elapsed time for each on exit"_sr));
 
 // createTheTimeInfo - This method either initializes the TheTimeInfo pointer to
 // a non-null value (if the -time-passes option is enabled) or it leaves it
 // null.  It may be called multiple times.
 void TimingInfo::createTheTimeInfo() {
   if (!TimePassesIsEnabled || TheTimeInfo) return;
 
   // Constructed the first time this is called, iff -time-passes is enabled.

lib/IR/OptBisect.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/OptBisect.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-static cl::opt<int> OptBisectLimit("opt-bisect-limit", cl::Hidden,
-                                   cl::init(INT_MAX), cl::Optional,
-                                   cl::desc("Maximum optimization to perform"));
+static cl::opt<int>
+    OptBisectLimit("opt-bisect-limit"_sr, cl::Hidden, cl::init(INT_MAX),
+                   cl::Optional,
+                   cl::desc("Maximum optimization to perform"_sr));
 
 OptBisect::OptBisect() {
   BisectEnabled = OptBisectLimit != INT_MAX;
 }
 
 static void printPassMessage(const StringRef &Name, int PassNum,
                              StringRef TargetDesc, bool Running) {
   StringRef Status = Running ? "" : "NOT ";

lib/IR/Verifier.cpp

 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
 
 using namespace llvm;
 
-static cl::opt<bool> VerifyDebugInfo("verify-debug-info", cl::init(true));
+static cl::opt<bool> VerifyDebugInfo("verify-debug-info"_sr, cl::init(true));
 
 namespace {
 
 struct VerifierSupport {
   raw_ostream *OS;
   const Module &M;
   ModuleSlotTracker MST;
   const DataLayout &DL;

lib/MC/MCDwarf.cpp

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

lib/MC/MCParser/AsmParser.cpp

 ///   ::= ( .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/Support/CommandLine.cpp

 
 void Option::setArgStr(StringRef S) {
   if (FullyInitialized)
     GlobalParser->updateArgStr(this, S);
   ArgStr = S;
 }
 
 // Initialise the general option category.
-OptionCategory llvm::cl::GeneralCategory("General options");
+OptionCategory llvm::cl::GeneralCategory("General options"_sr);
 
 void OptionCategory::registerCategory() {
   GlobalParser->registerCategory(this);
 }
 
 // A special subcommand representing no subcommand
 ManagedStatic<SubCommand> llvm::cl::TopLevelSubCommand;
 

 // Declare HelpPrinter wrappers that will decide whether or not to invoke
 // a categorizing help printer
 static HelpPrinterWrapper WrappedNormalPrinter(UncategorizedNormalPrinter,
                                                CategorizedNormalPrinter);
 static HelpPrinterWrapper WrappedHiddenPrinter(UncategorizedHiddenPrinter,
                                                CategorizedHiddenPrinter);
 
 // Define a category for generic options that all tools should have.
-static cl::OptionCategory GenericCategory("Generic Options");
+static cl::OptionCategory GenericCategory("Generic Options"_sr);
 
 // Define uncategorized help printers.
 // -help-list is hidden by default because if Option categories are being used
 // then -help behaves the same as -help-list.
 static cl::opt<HelpPrinter, true, parser<bool>> HLOp(
-    "help-list",
-    cl::desc("Display list of available options (-help-list-hidden for more)"),
+    "help-list"_sr,
+    cl::desc(
+        "Display list of available options (-help-list-hidden for more)"_sr),
     cl::location(UncategorizedNormalPrinter), cl::Hidden, cl::ValueDisallowed,
     cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
-static cl::opt<HelpPrinter, true, parser<bool>>
-    HLHOp("help-list-hidden", cl::desc("Display list of all available options"),
-          cl::location(UncategorizedHiddenPrinter), cl::Hidden,
-          cl::ValueDisallowed, cl::cat(GenericCategory),
-          cl::sub(*AllSubCommands));
+static cl::opt<HelpPrinter, true, parser<bool>> HLHOp(
+    "help-list-hidden"_sr, cl::desc("Display list of all available options"_sr),
+    cl::location(UncategorizedHiddenPrinter), cl::Hidden, cl::ValueDisallowed,
+    cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
 // Define uncategorized/categorized help printers. These printers change their
 // behaviour at runtime depending on whether one or more Option categories have
 // been declared.
 static cl::opt<HelpPrinterWrapper, true, parser<bool>>
-    HOp("help", cl::desc("Display available options (-help-hidden for more)"),
+    HOp("help"_sr,
+        cl::desc("Display available options (-help-hidden for more)"_sr),
         cl::location(WrappedNormalPrinter), cl::ValueDisallowed,
         cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
 static cl::opt<HelpPrinterWrapper, true, parser<bool>>
-    HHOp("help-hidden", cl::desc("Display all available options"),
+    HHOp("help-hidden"_sr, cl::desc("Display all available options"_sr),
          cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed,
          cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
 static cl::opt<bool> PrintOptions(
-    "print-options",
-    cl::desc("Print non-default options after command line parsing"),
+    "print-options"_sr,
+    cl::desc("Print non-default options after command line parsing"_sr),
     cl::Hidden, cl::init(false), cl::cat(GenericCategory),
     cl::sub(*AllSubCommands));
 
 static cl::opt<bool> PrintAllOptions(
-    "print-all-options",
-    cl::desc("Print all option values after command line parsing"), cl::Hidden,
-    cl::init(false), cl::cat(GenericCategory), cl::sub(*AllSubCommands));
+    "print-all-options"_sr,
+    cl::desc("Print all option values after command line parsing"_sr),
+    cl::Hidden, cl::init(false), cl::cat(GenericCategory),
+    cl::sub(*AllSubCommands));
 
 void HelpPrinterWrapper::operator=(bool Value) {
   if (!Value)
     return;
 
   // Decide which printer to invoke. If more than one option category is
   // registered then it is useful to show the categorized help instead of
   // uncategorized help.
#endif
   }
 };
 } // End anonymous namespace
 
 // Define the --version option that prints out the LLVM version for the tool
 static VersionPrinter VersionPrinterInstance;
 
 static cl::opt<VersionPrinter, true, parser<bool>>
-    VersOp("version", cl::desc("Display the version of this program"),
+    VersOp("version"_sr, cl::desc("Display the version of this program"_sr),
            cl::location(VersionPrinterInstance), cl::ValueDisallowed,
            cl::cat(GenericCategory));
 
 // Utility function for printing the help message.
 void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
   // This looks weird, but it actually prints the help message. The Printers are
   // types of HelpPrinter and the help gets printed when its operator= is
   // invoked. That's because the "normal" usages of the help printer is to be

lib/Support/Debug.cpp

 
 } // namespace llvm
 
 // All Debug.h functionality is a no-op in NDEBUG mode.
 #ifndef NDEBUG
 
 // -debug - Command line option to enable the DEBUG statements in the passes.
 // This flag may only be enabled in debug builds.
-static cl::opt<bool, true>
-Debug("debug", cl::desc("Enable debug output"), cl::Hidden,
-      cl::location(DebugFlag));
+static cl::opt<bool, true> Debug("debug"_sr, cl::desc("Enable debug output"_sr),
+                                 cl::Hidden, cl::location(DebugFlag));
 
 // -debug-buffer-size - Buffer the last N characters of debug output
 //until program termination.
 static cl::opt<unsigned>
-DebugBufferSize("debug-buffer-size",
+    DebugBufferSize("debug-buffer-size"_sr,
                     cl::desc("Buffer the last N characters of debug output "
                              "until program termination. "
-                         "[default 0 -- immediate print-out]"),
-                cl::Hidden,
-                cl::init(0));
+                             "[default 0 -- immediate print-out]"_sr),
+                    cl::Hidden, cl::init(0));
 
 namespace {
 
 struct DebugOnlyOpt {
   void operator=(const std::string &Val) const {
     if (Val.empty())
       return;
     DebugFlag = true;
     SmallVector<StringRef,8> dbgTypes;
     StringRef(Val).split(dbgTypes, ',', -1, false);
     for (auto dbgType : dbgTypes)
       CurrentDebugType->push_back(dbgType);
   }
 };
 
 }
 
 static DebugOnlyOpt DebugOnlyOptLoc;
 
-static cl::opt<DebugOnlyOpt, true, cl::parser<std::string> >
-DebugOnly("debug-only", cl::desc("Enable a specific type of debug output (comma separated list of types)"),
-          cl::Hidden, cl::ZeroOrMore, cl::value_desc("debug string"),
-          cl::location(DebugOnlyOptLoc), cl::ValueRequired);
+static cl::opt<DebugOnlyOpt, true, cl::parser<std::string>> DebugOnly(
+    "debug-only"_sr,
+    cl::desc(
+        "Enable a specific type of debug output (comma separated list of types)"_sr),
+    cl::Hidden, cl::ZeroOrMore, cl::value_desc("debug string"_sr),
 // Signal handlers - dump debug output on termination.
 static void debug_user_sig_handler(void *Cookie) {
   // This is a bit sneaky.  Since this is under #ifndef NDEBUG, we
   // know that debug mode is enabled and dbgs() really is a
   // circular_raw_ostream.  If NDEBUG is defined, then dbgs() ==
   // errs() but this will never be invoked.
   llvm::circular_raw_ostream &dbgout =
       static_cast<circular_raw_ostream &>(llvm::dbgs());

lib/Support/RandomNumberGenerator.cpp

 
 #define DEBUG_TYPE "rng"
 
 // Tracking BUG: 19665
 // http://llvm.org/bugs/show_bug.cgi?id=19665
 //
 // Do not change to cl::opt<uint64_t> since this silently breaks argument parsing.
 static cl::opt<unsigned long long>
-Seed("rng-seed", cl::value_desc("seed"),
-     cl::desc("Seed for the random number generator"), cl::init(0));
+    Seed("rng-seed"_sr, cl::value_desc("seed"_sr),
+         cl::desc("Seed for the random number generator"_sr), cl::init(0));
 
 RandomNumberGenerator::RandomNumberGenerator(StringRef Salt) {
   DEBUG(
     if (Seed == 0)
       dbgs() << "Warning! Using unseeded random number generator.\n"
   );
 
   // Combine seed and salts using std::seed_seq.

lib/Support/Timer.cpp

 static ManagedStatic<std::string> LibSupportInfoOutputFilename;
 static std::string &getLibSupportInfoOutputFilename() {
   return *LibSupportInfoOutputFilename;
 }
 
 static ManagedStatic<sys::SmartMutex<true> > TimerLock;
 
 namespace {
-  static cl::opt<bool>
-  TrackSpace("track-memory", cl::desc("Enable -time-passes memory "
-                                      "tracking (this may be slow)"),
+static cl::opt<bool> TrackSpace("track-memory"_sr,
+                                cl::desc("Enable -time-passes memory "
+                                         "tracking (this may be slow)"_sr),
                                 cl::Hidden);
 
-  static cl::opt<std::string, true>
-  InfoOutputFilename("info-output-file", cl::value_desc("filename"),
-                     cl::desc("File to append -stats and -timer output to"),
-                   cl::Hidden, cl::location(getLibSupportInfoOutputFilename()));
+static cl::opt<std::string, true> InfoOutputFilename(
+    "info-output-file"_sr, cl::value_desc("filename"_sr),
+    cl::desc("File to append -stats and -timer output to"_sr), cl::Hidden,
+    cl::location(getLibSupportInfoOutputFilename()));
 }
 
 std::unique_ptr<raw_fd_ostream> llvm::CreateInfoOutputFile() {
   const std::string &OutputFilename = getLibSupportInfoOutputFilename();
   if (OutputFilename.empty())
     return llvm::make_unique<raw_fd_ostream>(2, false); // stderr.
   if (OutputFilename == "-")
     return llvm::make_unique<raw_fd_ostream>(1, false); // stdout.

lib/Target/AMDGPU/Utils/AMDKernelCodeTUtils.cpp

 #include <llvm/MC/MCParser/MCAsmLexer.h>
 #include <llvm/MC/MCParser/MCAsmParser.h>
 #include <llvm/Support/raw_ostream.h>
 
 using namespace llvm;
 
 static ArrayRef<StringRef> get_amd_kernel_code_t_FldNames() {
   static StringRef const Table[] = {
-    "", // not found placeholder
-#define RECORD(name, altName, print, parse) #name
+    ""_sr, // not found placeholder
+#define RECORD(name, altName, print, parse) #name##_sr
 #include "AMDKernelCodeTInfo.h"
 #undef RECORD
   };
   return makeArrayRef(Table);
 }
 
 static ArrayRef<StringRef> get_amd_kernel_code_t_FldAltNames() {
   static StringRef const Table[] = {
-    "", // not found placeholder
-#define RECORD(name, altName, print, parse) #altName
+    ""_sr, // not found placeholder
+#define RECORD(name, altName, print, parse) #altName##_sr
 #include "AMDKernelCodeTInfo.h"
 #undef RECORD
   };
   return makeArrayRef(Table);
 }
 
 static StringMap<int> createIndexMap(const ArrayRef<StringRef> &names,
                                      const ArrayRef<StringRef> &altNames) {

lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp

 #include "HexagonGenInstrInfo.inc"
 
 #define GET_SUBTARGETINFO_MC_DESC
 #include "HexagonGenSubtargetInfo.inc"
 
 #define GET_REGINFO_MC_DESC
 #include "HexagonGenRegisterInfo.inc"
 
-cl::opt<bool> llvm::HexagonDisableCompound
-  ("mno-compound",
-   cl::desc("Disable looking for compound instructions for Hexagon"));
+cl::opt<bool> llvm::HexagonDisableCompound(
+    "mno-compound"_sr,
+    cl::desc("Disable looking for compound instructions for Hexagon"_sr));
 
-cl::opt<bool> llvm::HexagonDisableDuplex
-  ("mno-pairing",
-   cl::desc("Disable looking for duplex instructions for Hexagon"));
+cl::opt<bool> llvm::HexagonDisableDuplex(
+    "mno-pairing"_sr,
+    cl::desc("Disable looking for duplex instructions for Hexagon"_sr));
 
-static cl::opt<bool> HexagonV4ArchVariant("mv4", cl::Hidden, cl::init(false),
-  cl::desc("Build for Hexagon V4"));
+static cl::opt<bool> HexagonV4ArchVariant("mv4"_sr, cl::Hidden, cl::init(false),
+                                          cl::desc("Build for Hexagon V4"_sr));
 
-static cl::opt<bool> HexagonV5ArchVariant("mv5", cl::Hidden, cl::init(false),
-  cl::desc("Build for Hexagon V5"));
+static cl::opt<bool> HexagonV5ArchVariant("mv5"_sr, cl::Hidden, cl::init(false),
+                                          cl::desc("Build for Hexagon V5"_sr));
 
-static cl::opt<bool> HexagonV55ArchVariant("mv55", cl::Hidden, cl::init(false),
-  cl::desc("Build for Hexagon V55"));
+static cl::opt<bool>
+    HexagonV55ArchVariant("mv55"_sr, cl::Hidden, cl::init(false),
+                          cl::desc("Build for Hexagon V55"_sr));
 
-static cl::opt<bool> HexagonV60ArchVariant("mv60", cl::Hidden, cl::init(false),
-  cl::desc("Build for Hexagon V60"));
+static cl::opt<bool>
+    HexagonV60ArchVariant("mv60"_sr, cl::Hidden, cl::init(false),
+                          cl::desc("Build for Hexagon V60"_sr));
 
-
-static StringRef DefaultArch = "hexagonv60";
+static StringRef DefaultArch = "hexagonv60"_sr;
 
 static StringRef HexagonGetArchVariant() {
   if (HexagonV4ArchVariant)
     return "hexagonv4";
   if (HexagonV5ArchVariant)
     return "hexagonv5";
   if (HexagonV55ArchVariant)
     return "hexagonv55";

lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp

struct CompareInsn {
   bool operator() (const InsnMatchEntry &LHS, const InsnMatchEntry &RHS) {
     return LHS.Format < RHS.Format;
   }
 };
 
 // Table initializing information for parsing the .insn directive.
 static struct InsnMatchEntry InsnMatchTable[] = {
   /* Format, Opcode, NumOperands, OperandKinds */
-  { "e", SystemZ::InsnE, 1,
+  { "e"_sr, SystemZ::InsnE, 1,
     { MCK_U16Imm } },
-  { "ri", SystemZ::InsnRI, 3,
+  { "ri"_sr, SystemZ::InsnRI, 3,
     { MCK_U32Imm, MCK_AnyReg, MCK_S16Imm } },
-  { "rie", SystemZ::InsnRIE, 4,
+  { "rie"_sr, SystemZ::InsnRIE, 4,
     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_PCRel16 } },
-  { "ril", SystemZ::InsnRIL, 3,
+  { "ril"_sr, SystemZ::InsnRIL, 3,
     { MCK_U48Imm, MCK_AnyReg, MCK_PCRel32 } },
-  { "rilu", SystemZ::InsnRILU, 3,
+  { "rilu"_sr, SystemZ::InsnRILU, 3,
     { MCK_U48Imm, MCK_AnyReg, MCK_U32Imm } },
-  { "ris", SystemZ::InsnRIS, 5,
+  { "ris"_sr, SystemZ::InsnRIS, 5,
     { MCK_U48Imm, MCK_AnyReg, MCK_S8Imm, MCK_U4Imm, MCK_BDAddr64Disp12 } },
-  { "rr", SystemZ::InsnRR, 3,
+  { "rr"_sr, SystemZ::InsnRR, 3,
     { MCK_U16Imm, MCK_AnyReg, MCK_AnyReg } },
-  { "rre", SystemZ::InsnRRE, 3,
+  { "rre"_sr, SystemZ::InsnRRE, 3,
     { MCK_U32Imm, MCK_AnyReg, MCK_AnyReg } },
-  { "rrf", SystemZ::InsnRRF, 5,
+  { "rrf"_sr, SystemZ::InsnRRF, 5,
     { MCK_U32Imm, MCK_AnyReg, MCK_AnyReg, MCK_AnyReg, MCK_U4Imm } },
-  { "rrs", SystemZ::InsnRRS, 5,
+  { "rrs"_sr, SystemZ::InsnRRS, 5,
     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_U4Imm, MCK_BDAddr64Disp12 } },
-  { "rs", SystemZ::InsnRS, 4,
+  { "rs"_sr, SystemZ::InsnRS, 4,
     { MCK_U32Imm, MCK_AnyReg, MCK_AnyReg, MCK_BDAddr64Disp12 } },
-  { "rse", SystemZ::InsnRSE, 4,
+  { "rse"_sr, SystemZ::InsnRSE, 4,
     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_BDAddr64Disp12 } },
-  { "rsi", SystemZ::InsnRSI, 4,
+  { "rsi"_sr, SystemZ::InsnRSI, 4,
     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_PCRel16 } },
-  { "rsy", SystemZ::InsnRSY, 4,
+  { "rsy"_sr, SystemZ::InsnRSY, 4,
     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_BDAddr64Disp20 } },
-  { "rx", SystemZ::InsnRX, 3,
+  { "rx"_sr, SystemZ::InsnRX, 3,
     { MCK_U32Imm, MCK_AnyReg, MCK_BDXAddr64Disp12 } },
-  { "rxe", SystemZ::InsnRXE, 3,
+  { "rxe"_sr, SystemZ::InsnRXE, 3,
     { MCK_U48Imm, MCK_AnyReg, MCK_BDXAddr64Disp12 } },
-  { "rxf", SystemZ::InsnRXF, 4,
+  { "rxf"_sr, SystemZ::InsnRXF, 4,
     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_BDXAddr64Disp12 } },
-  { "rxy", SystemZ::InsnRXY, 3,
+  { "rxy"_sr, SystemZ::InsnRXY, 3,
     { MCK_U48Imm, MCK_AnyReg, MCK_BDXAddr64Disp20 } },
-  { "s", SystemZ::InsnS, 2,
+  { "s"_sr, SystemZ::InsnS, 2,
     { MCK_U32Imm, MCK_BDAddr64Disp12 } },
-  { "si", SystemZ::InsnSI, 3,
+  { "si"_sr, SystemZ::InsnSI, 3,
     { MCK_U32Imm, MCK_BDAddr64Disp12, MCK_S8Imm } },
-  { "sil", SystemZ::InsnSIL, 3,
+  { "sil"_sr, SystemZ::InsnSIL, 3,
     { MCK_U48Imm, MCK_BDAddr64Disp12, MCK_U16Imm } },
-  { "siy", SystemZ::InsnSIY, 3,
+  { "siy"_sr, SystemZ::InsnSIY, 3,
     { MCK_U48Imm, MCK_BDAddr64Disp20, MCK_U8Imm } },
-  { "ss", SystemZ::InsnSS, 4,
+  { "ss"_sr, SystemZ::InsnSS, 4,
     { MCK_U48Imm, MCK_BDXAddr64Disp12, MCK_BDAddr64Disp12, MCK_AnyReg } },
-  { "sse", SystemZ::InsnSSE, 3,
+  { "sse"_sr, SystemZ::InsnSSE, 3,
     { MCK_U48Imm, MCK_BDAddr64Disp12, MCK_BDAddr64Disp12 } },
-  { "ssf", SystemZ::InsnSSF, 4,
+  { "ssf"_sr, SystemZ::InsnSSF, 4,
     { MCK_U48Imm, MCK_BDAddr64Disp12, MCK_BDAddr64Disp12, MCK_AnyReg } }
 };
 
 void SystemZOperand::print(raw_ostream &OS) const {
   llvm_unreachable("Not implemented");
 }
 
 // Parse one register of the form %<prefix><number>.

tools/llvm-as/llvm-as.cpp

 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/SystemUtils.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include <memory>
 using namespace llvm;
 
 static cl::opt<std::string> InputFilename(cl::Positional,
-                                          cl::desc("<input .llvm file>"),
-                                          cl::init("-"));
+                                          cl::desc("<input .llvm file>"_sr),
+                                          cl::init("-"_sr));
 
-static cl::opt<std::string> OutputFilename("o",
-                                           cl::desc("Override output filename"),
-                                           cl::value_desc("filename"));
+static cl::opt<std::string>
+    OutputFilename("o"_sr, cl::desc("Override output filename"_sr),
+                   cl::value_desc("filename"_sr));
 
-static cl::opt<bool> Force("f", cl::desc("Enable binary output on terminals"));
+static cl::opt<bool> Force("f"_sr,
+                           cl::desc("Enable binary output on terminals"_sr));
 
-static cl::opt<bool> DisableOutput("disable-output", cl::desc("Disable output"),
+static cl::opt<bool> DisableOutput("disable-output"_sr,
+                                   cl::desc("Disable output"_sr),
                                    cl::init(false));
 
-static cl::opt<bool> EmitModuleHash("module-hash", cl::desc("Emit module hash"),
+static cl::opt<bool> EmitModuleHash("module-hash"_sr,
+                                    cl::desc("Emit module hash"_sr),
                                     cl::init(false));
 
-static cl::opt<bool> DumpAsm("d", cl::desc("Print assembly as parsed"),
+static cl::opt<bool> DumpAsm("d"_sr, cl::desc("Print assembly as parsed"_sr),
                              cl::Hidden);
 
-static cl::opt<bool>
-    DisableVerify("disable-verify", cl::Hidden,
-                  cl::desc("Do not run verifier on input LLVM (dangerous!)"));
+static cl::opt<bool> DisableVerify(
+    "disable-verify"_sr, cl::Hidden,
+    cl::desc("Do not run verifier on input LLVM (dangerous!)"_sr));
 
 static cl::opt<bool> PreserveBitcodeUseListOrder(
-    "preserve-bc-uselistorder",
-    cl::desc("Preserve use-list order when writing LLVM bitcode."),
+    "preserve-bc-uselistorder"_sr,
+    cl::desc("Preserve use-list order when writing LLVM bitcode."_sr),
     cl::init(true), cl::Hidden);
 
 static void WriteOutputFile(const Module *M) {
   // Infer the output filename if needed.
   if (OutputFilename.empty()) {
     if (InputFilename == "-") {
       OutputFilename = "-";
     } else {

unittests/ADT/APIntTest.cpp

 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/StringRefTest.cpp

 
 
 namespace {
 TEST(StringRefTest, Construction) {
   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, EmptyInitializerList) {
   StringRef S = {};
   EXPECT_TRUE(S.empty());
 
   S = {};
   EXPECT_TRUE(S.empty());

unittests/ADT/StringSwitchTest.cpp

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/Bitcode/BitstreamWriterTest.cpp

 using namespace llvm;
 
 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");
   }

unittests/Support/ConvertUTFTest.cpp

EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
       "\xf3\xa0\x84\x80"));
 
   //
   // First possible sequence of a certain length
   //
 
   // U+0000 NULL
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
-      ConvertUTFResultContainer(conversionOK).withScalars(0x0000),
-      StringRef("\x00", 1)));
+      ConvertUTFResultContainer(conversionOK).withScalars(0x0000), "\x00"_sr));
 
   // U+0080 PADDING CHARACTER
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
       ConvertUTFResultContainer(conversionOK).withScalars(0x0080),
       "\xc2\x80"));
 
   // U+0800 SAMARITAN LETTER ALAF
   EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
       "\xf8\x80\x80\x80\xaf"));
   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)));
+      ConvertUTFResultContainer(conversionOK).withScalars(0x0000), "\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),

utils/TableGen/IntrinsicEmitter.cpp

void IntrinsicEmitter::EmitTargetInfo(const CodeGenIntrinsicTable &Ints,
   OS << "#ifdef GET_INTRINSIC_TARGET_DATA\n";
   OS << "struct IntrinsicTargetInfo {\n"
      << "  StringRef Name;\n"
      << "  size_t Offset;\n"
      << "  size_t Count;\n"
      << "};\n";
   OS << "static const IntrinsicTargetInfo TargetInfos[] = {\n";
   for (auto Target : Ints.Targets)
-    OS << "  {\"" << Target.Name << "\", " << Target.Offset << ", "
+    OS << "  {\"" << Target.Name << "\"_sr, " << Target.Offset << ", "
        << Target.Count << "},\n";
   OS << "};\n";
   OS << "#endif\n\n";
 }
 
 void IntrinsicEmitter::EmitIntrinsicToNameTable(
     const CodeGenIntrinsicTable &Ints, raw_ostream &OS) {
   OS << "// Intrinsic ID to name table\n";