[clang] Return `std::string_view` from `TargetInfo::getClobbers()`

[Stoorx]

Summary

Change the return type of getClobbers function from const char*
to std::string_view. Update the function usages in CodeGen module.

The reasoning of these changes is to remove unsafe const char*
strings and prevent unnecessary allocations for constructing the
std::string in usages of getClobbers() function.

[Stoorx]

Rebase

[DavidSpickett]

Context not available.

Please update the diff with context, https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface.

I'm not sure what the benefit of this change is. While I did say less raw pointers = better, perhaps I'd make an exception for const char * for constant strings. In this case, no one is manipulating the string until (I assume) after it's converted to std::string, so we're not removing risky accesses in that way. If the API were returning a const char * that we then did a bunch of find first, split at, strlen, etc on, then this would make more sense.

https://llvm.org/docs/ProgrammersManual.html#passing-strings-the-stringref-and-twine-classes

Also this says you can implicitly construct from a string literal, so I am surprised you need the llvm::StringLiteral. Unless this is just a thing that asserts that it is in fact, a literal (I've not used this before myself).

Overall I applaud the effort but in this particular case it may not be needed.

[Stoorx]

In this case, no one is manipulating the string until (I assume) after it's converted to std::string, so we're not removing risky accesses in that way.

Maybe the solution is to return some kind of string (std::string or llvm::SmallString) by value or by const reference?

If the API were returning a const char * that we then did a bunch of find first, split at, strlen, etc on, then this would make more sense.

At least StringRef has the Length inside (we do not need to call strlen or someting) and according to documentation it can handle non-null terminated strings.

/// StringRef - Represent a constant reference to a string, i.e. a character
/// array and a length, which need not be null terminated.

Offtop: Is there any discussion platform where I can share some ideas? I have some of them how to refactor TargetInfo classes, but it's a major (and maybe breaking) change I have to discuss prior to implement.

[Stoorx]

Rebase & upload with context

[DavidSpickett]

You need to clearly state the "why" of the change in the commit message. Sometimes it seems obvious to the author but a reviewer has to assume and may assume incorrectly.

In this case, I guess that since the result of the function only has its length checked then is added to another string, you would avoid a heap allocation for the new std::string temporary by using StringRef.

You could also do this by making a StringRef from the const char* and checking its length. That does leave a small ambiguity as to whether returning nullptr and empty string is the same thing. Which it is, but it's not clear just from the prototype of the function. So changing getClobbers to return StringRef resolves both issues.

But equally, you might have had a completely different goal. Tell me if I am right :)

Offtop: Is there any discussion platform where I can share some ideas? I have some of them how to refactor TargetInfo classes, but it's a major (and maybe breaking) change I have to discuss prior to implement.

An RFC on discourse is the usual way. If you can supply some work in progress patches or a tree on github then even better (and prevent you from proposing things you later find to be impossible, not that I have ever done that of course :) ).

[Stoorx]

I've looked through usages of getClobbers again, and found that in each case the result if the function is casted to std::string.

clang/lib/CodeGen/CGBuiltin.cpp
clang/lib/CodeGen/CGStmt.cpp

std::string Constraints = "=r,*Z,~{memory}";
  std::string MachineClobbers =
      static_cast<std::string>(CGF.getTarget().getClobbers());
  if (!MachineClobbers.empty()) {
    Constraints += ',';
    Constraints += MachineClobbers;
  }

I think we can 'make two deals with one shot' if we would:

• Make std::string_view as a return type of getClobbers (by value, since the std::string_view is 'TriviallyCopyable')
• (Maybe) Make private static field of std::string type for actual clobber value (or std::string_view type since it can be constexpr-constructed)
• Return the value of this field from getClobbers
• Change type of MachineClobbers (in usages, see example above) variable to std::string_view since it actually used for read-only access. (We do not need to construct std::string and destruct it almost immediately)

As a result we get:

• More robust usage of getClobbers (a bit ridiculous but...)
• Zero unnecessary allocations

(Also: I've discovered that llvm::StringRef is exact the same thing as std::string_view. I think of it so much :^) )

[DavidSpickett]

string_view is a good call, especially as this is not doing anything fancy with it, and we have recently been allowed to use it.

(Maybe) Make private static field of std::string type for actual clobber value (or std::string_view type since it can be constexpr-constructed)

This I don't see the need for. If the string_views reference constant strings doesn't that amount to the same thing?

const std::string_view getClobbers() const override {
    return "";
  }

This makes a string view out of a pointer to a const string, but I guess it's up to the compiler how far it can optimise that.

You may be correct but it seems like a small optimisation.

[Stoorx]

Refactoring according the discussion

[Stoorx]

I did not set const qualifier for return type because std::string_view is constant by design. Or should I mark it const explicitly?

[DavidSpickett]

I did not set const qualifier for return type because std::string_view is constant by design. Or should I mark it const explicitly?

I'm new to string_view but everything I see backs up that it is a constant view on the data as you say. I'm not sure what making it itself const would do, not worth looking into here.

Please update the commit message (here and locally, in case you happen to be using arc, which prefers one and I forget which one). It should include the reasoning for the change, as we've discussed here.

clang/lib/CodeGen/CGBuiltin.cpp

942

You dropped a =, please make sure it compiles before updating the review.

[DavidSpickett]

Build issues will also show up in the "Build Status" here.

[Stoorx]

Fix, Rebase & retitle

[DavidSpickett]

If you have commit access already, wait until the pre-commit builds finish and check there isn't anything failing there.

If you don't, I can commit this for you as I did before. I'll do that on Monday.

clang/include/clang/Basic/TargetInfo.h

public:
 
   /// Replace some escaped characters with another string based on
   /// target-specific rules
   virtual std::optional<std::string> handleAsmEscapedChar(char C) const {
     return std::nullopt;
   }
 
   /// Returns a string of target-specific clobbers, in LLVM format.
-  virtual const char *getClobbers() const = 0;
+  virtual std::string_view getClobbers() const = 0;
 
   /// Returns true if NaN encoding is IEEE 754-2008.
   /// Only MIPS allows a different encoding.
   virtual bool isNan2008() const {
     return true;
   }
 
   /// Returns the target triple of the primary target.

clang/lib/Basic/Targets/AArch64.h

std::string convertConstraint(const char *&Constraint) const override {
     return R;
   }
 
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &Info) const override;
   bool
   validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
                              std::string &SuggestedModifier) const override;
-  const char *getClobbers() const override;
+  std::string_view getClobbers() const override;
 
   StringRef getConstraintRegister(StringRef Constraint,
                                   StringRef Expression) const override {
     return Expression;
   }
 
   int getEHDataRegisterNumber(unsigned RegNo) const override;
 

clang/lib/Basic/Targets/AArch64.cpp

default:
 
       SuggestedModifier = "w";
       return false;
     }
   }
   }
 }
 
-const char *AArch64TargetInfo::getClobbers() const { return ""; }
+std::string_view AArch64TargetInfo::getClobbers() const { return ""; }
 
 int AArch64TargetInfo::getEHDataRegisterNumber(unsigned RegNo) const {
   if (RegNo == 0)
     return 0;
   if (RegNo == 1)
     return 1;
   return -1;
 }

clang/lib/Basic/Targets/AMDGPU.h

public:
 
   uint64_t getMaxPointerWidth() const override {
     return getTriple().getArch() == llvm::Triple::amdgcn ? 64 : 32;
   }
 
   bool hasBFloat16Type() const override { return isAMDGCN(getTriple()); }
   const char *getBFloat16Mangling() const override { return "u6__bf16"; };
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override;
 
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
     return std::nullopt;
   }
 
   /// Accepted register names: (n, m is unsigned integer, n < m)

clang/lib/Basic/Targets/ARC.h

public:
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     return std::nullopt;
   }
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::VoidPtrBuiltinVaList;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override {
     static const char *const GCCRegNames[] = {
         "r0",  "r1",  "r2",  "r3",  "r4",  "r5",     "r6",  "r7",
         "r8",  "r9",  "r10", "r11", "r12", "r13",    "r14", "r15",
         "r16", "r17", "r18", "r19", "r20", "r21",    "r22", "r23",
         "r24", "r25", "gp",  "sp",  "fp",  "ilink1", "r30", "blink"};
     return llvm::ArrayRef(GCCRegNames);

clang/lib/Basic/Targets/ARM.h

public:
   ArrayRef<const char *> getGCCRegNames() const override;
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &Info) const override;
   std::string convertConstraint(const char *&Constraint) const override;
   bool
   validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
                              std::string &SuggestedModifier) const override;
-  const char *getClobbers() const override;
+  std::string_view getClobbers() const override;
 
   StringRef getConstraintRegister(StringRef Constraint,
                                   StringRef Expression) const override {
     return Expression;
   }
 
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override;
 

clang/lib/Basic/Targets/ARM.cpp

case 'q':
       // A register of size 32 cannot fit a vector type.
       return false;
     }
   }
   }
 
   return true;
 }
-const char *ARMTargetInfo::getClobbers() const {
+std::string_view ARMTargetInfo::getClobbers() const {
   // FIXME: Is this really right?
   return "";
 }
 
 TargetInfo::CallingConvCheckResult
 ARMTargetInfo::checkCallingConvention(CallingConv CC) const {
   switch (CC) {
   case CC_AAPCS:

clang/lib/Basic/Targets/AVR.h

public:
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     return std::nullopt;
   }
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::VoidPtrBuiltinVaList;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override {
     static const char *const GCCRegNames[] = {
         "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",  "r8",  "r9",
         "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19",
         "r20", "r21", "r22", "r23", "r24", "r25", "X",   "Y",   "Z",   "SP"};
     return llvm::ArrayRef(GCCRegNames);
   }

clang/lib/Basic/Targets/BPF.h

void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
                          bool Enabled) const override {
     Features[Name] = Enabled;
   }
   bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override;
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::VoidPtrBuiltinVaList;
   }
 
   bool isValidGCCRegisterName(StringRef Name) const override { return true; }
   ArrayRef<const char *> getGCCRegNames() const override {
     return std::nullopt;

clang/lib/Basic/Targets/CSKY.h

public:
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return VoidPtrBuiltinVaList;
   }
 
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &info) const override;
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
   bool hasFeature(StringRef Feature) const override;
   bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override;
 
   /// Whether target allows to overalign ABI-specified preferred alignment

clang/lib/Basic/Targets/DirectX.h

public:
   bool hasFeature(StringRef Feature) const override {
     return Feature == "directx";
   }
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     return std::nullopt;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override {
     return std::nullopt;
   }
 
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &info) const override {
     return true;

clang/lib/Basic/Targets/Hexagon.h

if (getTriple().isMusl())
       return TargetInfo::HexagonBuiltinVaList;
     return TargetInfo::CharPtrBuiltinVaList;
   }
 
   ArrayRef<const char *> getGCCRegNames() const override;
 
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   static const char *getHexagonCPUSuffix(StringRef Name);
 
   bool isValidCPUName(StringRef Name) const override {
     return getHexagonCPUSuffix(Name);
   }
 
   void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;

clang/lib/Basic/Targets/Lanai.h

ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     return std::nullopt;
   }
 
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &info) const override {
     return false;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   bool hasBitIntType() const override { return true; }
 };
 } // namespace targets
 } // namespace clang
 
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_LANAI_H

clang/lib/Basic/Targets/Le64.h

void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::PNaClABIBuiltinVaList;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override {
     return std::nullopt;
   }
 
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
     return std::nullopt;
   }

clang/lib/Basic/Targets/LoongArch.h

void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::VoidPtrBuiltinVaList;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override;
 
   int getEHDataRegisterNumber(unsigned RegNo) const override {
     if (RegNo == 0)
       return 4;
     if (RegNo == 1)
       return 5;

clang/lib/Basic/Targets/M68k.h

public:
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
   bool hasFeature(StringRef Feature) const override;
   ArrayRef<const char *> getGCCRegNames() const override;
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
   std::string convertConstraint(const char *&Constraint) const override;
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &info) const override;
   std::optional<std::string> handleAsmEscapedChar(char EscChar) const override;
-  const char *getClobbers() const override;
+  std::string_view getClobbers() const override;
   BuiltinVaListKind getBuiltinVaListKind() const override;
   bool setCPU(const std::string &Name) override;
 };
 
 } // namespace targets
 } // namespace clang
 
 #endif

clang/lib/Basic/Targets/M68k.cpp

 std::string M68kTargetInfo::convertConstraint(const char *&Constraint) const {
   if (*Constraint == 'C')
     // Two-character constraint; add "^" hint for later parsing
     return std::string("^") + std::string(Constraint++, 2);
 
   return std::string(1, *Constraint);
 }
 
-const char *M68kTargetInfo::getClobbers() const {
+std::string_view M68kTargetInfo::getClobbers() const {
   // FIXME: Is this really right?
   return "";
 }
 
 TargetInfo::BuiltinVaListKind M68kTargetInfo::getBuiltinVaListKind() const {
   return TargetInfo::VoidPtrBuiltinVaList;
 }
 
 } // namespace targets
 } // namespace clang

clang/lib/Basic/Targets/MSP430.h

bool validateAsmConstraint(const char *&Name,
     case 'L': // constant -1^20 .. 1^19
     case 'M': // constant 1-4:
       return true;
     }
     // No target constraints for now.
     return false;
   }
 
-  const char *getClobbers() const override {
+  std::string_view getClobbers() const override {
     // FIXME: Is this really right?
     return "";
   }
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     // FIXME: implement
     return TargetInfo::CharPtrBuiltinVaList;
   }
 };
 
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_MSP430_H

clang/lib/Basic/Targets/Mips.h

case 'Z': // Two-character constraint; add "^" hint for later parsing.
         Constraint++;
         return R;
       }
       break;
     }
     return TargetInfo::convertConstraint(Constraint);
   }
 
-  const char *getClobbers() const override {
+  std::string_view getClobbers() const override {
     // In GCC, $1 is not widely used in generated code (it's used only in a few
     // specific situations), so there is no real need for users to add it to
     // the clobbers list if they want to use it in their inline assembly code.
     //
     // In LLVM, $1 is treated as a normal GPR and is always allocatable during
     // code generation, so using it in inline assembly without adding it to the
     // clobbers list can cause conflicts between the inline assembly code and
     // the surrounding generated code.

clang/lib/Basic/Targets/NVPTX.h

bool validateAsmConstraint(const char *&Name,
     case 'l':
     case 'f':
     case 'd':
       Info.setAllowsRegister();
       return true;
     }
   }
 
-  const char *getClobbers() const override {
+  std::string_view getClobbers() const override {
     // FIXME: Is this really right?
     return "";
   }
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     // FIXME: implement
     return TargetInfo::CharPtrBuiltinVaList;
   }

clang/lib/Basic/Targets/PNaCl.h

public:
 
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
 
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &Info) const override {
     return false;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   bool hasBitIntType() const override { return true; }
 };
 
 // We attempt to use PNaCl (le32) frontend and Mips32EL backend.
 class LLVM_LIBRARY_VISIBILITY NaClMips32TargetInfo : public MipsTargetInfo {
 public:
   NaClMips32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

clang/lib/Basic/Targets/PPC.h

case 'w':
       Constraint++;
       break;
     default:
       return TargetInfo::convertConstraint(Constraint);
     }
     return R;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
   int getEHDataRegisterNumber(unsigned RegNo) const override {
     if (RegNo == 0)
       return 3;
     if (RegNo == 1)
       return 4;
     return -1;
   }
 

clang/lib/Basic/Targets/RISCV.h

void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::VoidPtrBuiltinVaList;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   StringRef getConstraintRegister(StringRef Constraint,
                                   StringRef Expression) const override {
     return Expression;
   }
 
   ArrayRef<const char *> getGCCRegNames() const override;
 

clang/lib/Basic/Targets/SPIR.h

public:
   // SPIR supports the half type and the only llvm intrinsic allowed in SPIR is
   // memcpy as per section 3 of the SPIR spec.
   bool useFP16ConversionIntrinsics() const override { return false; }
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     return std::nullopt;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override {
     return std::nullopt;
   }
 
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &info) const override {
     return true;

clang/lib/Basic/Targets/Sparc.h

bool validateAsmConstraint(const char *&Name,
 
     case 'f':
     case 'e':
       info.setAllowsRegister();
       return true;
     }
     return false;
   }
-  const char *getClobbers() const override {
+  std::string_view getClobbers() const override {
     // FIXME: Implement!
     return "";
   }
 
   // No Sparc V7 for now, the backend doesn't support it anyway.
   enum CPUKind {
     CK_GENERIC,
     CK_V8,

clang/lib/Basic/Targets/SystemZ.h

case 'Z':
       }
       break;
     default:
       break;
     }
     return TargetInfo::convertConstraint(Constraint);
   }
 
-  const char *getClobbers() const override {
+  std::string_view getClobbers() const override {
     // FIXME: Is this really right?
     return "";
   }
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::SystemZBuiltinVaList;
   }
 

clang/lib/Basic/Targets/TCE.h

void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
   bool hasFeature(StringRef Feature) const override { return Feature == "tce"; }
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     return std::nullopt;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::VoidPtrBuiltinVaList;
   }
 
   ArrayRef<const char *> getGCCRegNames() const override {
     return std::nullopt;
   }

clang/lib/Basic/Targets/VE.h

CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     switch (CC) {
     default:
       return CCCR_Warning;
     case CC_C:
       return CCCR_OK;
     }
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override {
     static const char *const GCCRegNames[] = {
         // Regular registers
         "sx0",  "sx1",  "sx2",  "sx3",  "sx4",  "sx5",  "sx6",  "sx7",
         "sx8",  "sx9",  "sx10", "sx11", "sx12", "sx13", "sx14", "sx15",
         "sx16", "sx17", "sx18", "sx19", "sx20", "sx21", "sx22", "sx23",
         "sx24", "sx25", "sx26", "sx27", "sx28", "sx29", "sx30", "sx31",

clang/lib/Basic/Targets/WebAssembly.h

ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const final {
     return std::nullopt;
   }
 
   bool validateAsmConstraint(const char *&Name,
                              TargetInfo::ConstraintInfo &Info) const final {
     return false;
   }
 
-  const char *getClobbers() const final { return ""; }
+  std::string_view getClobbers() const final { return ""; }
 
   bool isCLZForZeroUndef() const final { return false; }
 
   bool hasInt128Type() const final { return true; }
 
   IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const final {
     // WebAssembly prefers long long for explicitly 64-bit integers.
     return BitWidth == 64 ? (IsSigned ? SignedLongLong : UnsignedLongLong)

clang/lib/Basic/Targets/X86.h

if (CPU == llvm::X86::CK_None || CPU >= llvm::X86::CK_PentiumPro)
       return true;
     return TargetInfo::checkCFProtectionBranchSupported(Diags);
   };
 
   virtual bool validateOperandSize(const llvm::StringMap<bool> &FeatureMap,
                                    StringRef Constraint, unsigned Size) const;
 
   std::string convertConstraint(const char *&Constraint) const override;
-  const char *getClobbers() const override {
+  std::string_view getClobbers() const override {
     return "~{dirflag},~{fpsr},~{flags}";
   }
 
   StringRef getConstraintRegister(StringRef Constraint,
                                   StringRef Expression) const override {
     StringRef::iterator I, E;
     for (I = Constraint.begin(), E = Constraint.end(); I != E; ++I) {
       if (isalpha(*I) || *I == '@')

clang/lib/Basic/Targets/XCore.h

void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::VoidPtrBuiltinVaList;
   }
 
-  const char *getClobbers() const override { return ""; }
+  std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override {
     static const char *const GCCRegNames[] = {
         "r0", "r1", "r2",  "r3",  "r4", "r5", "r6", "r7",
         "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
     };
     return llvm::ArrayRef(GCCRegNames);
   }

clang/lib/CodeGen/CGBuiltin.cpp

if (BT.Interlocking != BitTest::Unlocked)
     AsmOS << "lock ";
   AsmOS << "bt";
   if (Action)
     AsmOS << Action;
   AsmOS << SizeSuffix << " $2, ($1)";
 
   // Build the constraints. FIXME: We should support immediates when possible.
   std::string Constraints = "={@ccc},r,r,~{cc},~{memory}";
-  std::string MachineClobbers = CGF.getTarget().getClobbers();
+  std::string_view MachineClobbers = CGF.getTarget().getClobbers();
   if (!MachineClobbers.empty()) {
     Constraints += ',';
     Constraints += MachineClobbers;
   }
   llvm::IntegerType *IntType = llvm::IntegerType::get(
       CGF.getLLVMContext(),
       CGF.getContext().getTypeSize(E->getArg(1)->getType()));
   llvm::Type *IntPtrType = IntType->getPointerTo();
case clang::PPC::BI__builtin_ppc_lbarx:
     break;
   default:
     llvm_unreachable("Expected only PowerPC load reserve intrinsics");
   }
 
   AsmOS << "$0, ${1:y}";
 
   std::string Constraints = "=r,*Z,~{memory}";
-  std::string MachineClobbers = CGF.getTarget().getClobbers();
+  std::string_view MachineClobbers = CGF.getTarget().getClobbers();
   if (!MachineClobbers.empty()) {
     Constraints += ',';
     Constraints += MachineClobbers;
   }
 
   llvm::Type *IntPtrType = RetType->getPointerTo();
   llvm::FunctionType *FTy =
       llvm::FunctionType::get(RetType, {IntPtrType}, false);

clang/lib/CodeGen/CGStmt.cpp

for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) {
     Constraints += Clobber;
     Constraints += '}';
   }
 
   assert(!(HasUnwindClobber && IsGCCAsmGoto) &&
          "unwind clobber can't be used with asm goto");
 
   // Add machine specific clobbers
-  std::string MachineClobbers = getTarget().getClobbers();
+  std::string_view MachineClobbers = getTarget().getClobbers();
   if (!MachineClobbers.empty()) {
     if (!Constraints.empty())
       Constraints += ',';
     Constraints += MachineClobbers;
   }
 
   llvm::Type *ResultType;
   if (ResultRegTypes.empty())