NFC: Replace `const std::string&` with StringRef in TargetRegistry APIs.

[ondrasej]

Gentle ping. If you can't do the review, please suggest another reviewer.

Thanks!

[aaron.ballman]

LGTM, though please add "NFC" to the commit message subject when you land the changes so it's clear there's no functional changes happening (hence, no need for tests).

[aaron.ballman]

I forgot to ask -- do you need me to commit on your behalf? If so, what name and email address would you like me to use for patch attribution?

[ondrasej]

Rebased to a more recent revision, and amended the commit description as requested.

[ondrasej]

In D147592#4341777, @aaron.ballman wrote:

I forgot to ask -- do you need me to commit on your behalf? If so, what name and email address would you like me to use for patch attribution?

Please do, I don't have commit rights.

Thanks for the review!

llvm/include/llvm/MC/TargetRegistry.h

struct TargetRegistry {
 
   static iterator_range<iterator> targets();
 
   /// lookupTarget - Lookup a target based on a target triple.
   ///
   /// \param Triple - The triple to use for finding a target.
   /// \param Error - On failure, an error string describing why no target was
   /// found.
-  static const Target *lookupTarget(const std::string &Triple,
-                                    std::string &Error);
+  static const Target *lookupTarget(StringRef Triple, std::string &Error);
 
   /// lookupTarget - Lookup a target based on an architecture name
   /// and a target triple.  If the architecture name is non-empty,
   /// then the lookup is done by architecture.  Otherwise, the target
   /// triple is used.
   ///
   /// \param ArchName - The architecture to use for finding a target.
   /// \param TheTriple - The triple to use for finding a target.  The
   /// triple is updated with canonical architecture name if a lookup
   /// by architecture is done.
   /// \param Error - On failure, an error string describing why no target was
   /// found.
-  static const Target *lookupTarget(const std::string &ArchName,
-                                    Triple &TheTriple, std::string &Error);
+  static const Target *lookupTarget(StringRef ArchName, Triple &TheTriple,
+                                    std::string &Error);
 
   /// @}
   /// @name Target Registration
   /// @{
 
   /// RegisterTarget - Register the given target. Attempts to register a
   /// target which has already been registered will be ignored.
   ///

llvm/lib/MC/TargetRegistry.cpp

 
 // Clients are responsible for avoid race conditions in registration.
 static Target *FirstTarget = nullptr;
 
 iterator_range<TargetRegistry::iterator> TargetRegistry::targets() {
   return make_range(iterator(FirstTarget), iterator());
 }
 
-const Target *TargetRegistry::lookupTarget(const std::string &ArchName,
+const Target *TargetRegistry::lookupTarget(StringRef ArchName,
                                            Triple &TheTriple,
                                            std::string &Error) {
   // Allocate target machine.  First, check whether the user has explicitly
   // specified an architecture to compile for. If so we have to look it up by
   // name, because it might be a backend that has no mapping to a target triple.
   const Target *TheTarget = nullptr;
   if (!ArchName.empty()) {
     auto I = find_if(targets(),
                      [&](const Target &T) { return ArchName == T.getName(); });
 
     if (I == targets().end()) {
-      Error = "invalid target '" + ArchName + "'.\n";
+      Error = ("invalid target '" + ArchName + "'.\n").str();
       return nullptr;
     }
 
     TheTarget = &*I;
 
     // Adjust the triple to match (if known), otherwise stick with the
     // given triple.
     Triple::ArchType Type = Triple::getArchTypeForLLVMName(ArchName);
if (!TheTarget) {
             + "', see --version and --triple.\n";
       return nullptr;
     }
   }
 
   return TheTarget;
 }
 
-const Target *TargetRegistry::lookupTarget(const std::string &TT,
-                                           std::string &Error) {
+const Target *TargetRegistry::lookupTarget(StringRef TT, std::string &Error) {
   // Provide special warning when no targets are initialized.
   if (targets().begin() == targets().end()) {
     Error = "Unable to find target for this triple (no targets are registered)";
     return nullptr;
   }
   Triple::ArchType Arch = Triple(TT).getArch();
   auto ArchMatch = [&](const Target &T) { return T.ArchMatchFn(Arch); };
   auto I = find_if(targets(), ArchMatch);
 
   if (I == targets().end()) {
-    Error = "No available targets are compatible with triple \"" + TT + "\"";
+    Error = ("No available targets are compatible with triple \"" + TT + "\"")
+                .str();
     return nullptr;
   }
 
   auto J = std::find_if(std::next(I), targets().end(), ArchMatch);
   if (J != targets().end()) {
     Error = std::string("Cannot choose between targets \"") + I->Name +
             "\" and \"" + J->Name + "\"";
     return nullptr;