[llvm] Migrate {starts,ends}with_insensitive to {starts,ends}_with_insensitive (NFC)

[kazu]

Summary

This patch migrates uses of StringRef::{starts,ends}with_insensitive
to StringRef::{starts,ends}_with_insensitive so that we can use names
similar to those used in std::string_view. I'm planning to deprecate
StringRef::{starts,ends}with_insensitive once the migration is
complete across the code base.

[dblaikie]

Sounds good to me - thanks!

[dblaikie]

I should check - are these function names actually in std::string_view? It doesn't look like it, so renaming them doesn't help us get to the ability to switch to std::string_view, right?

Maybe it'd make more sense to make these non-member functions, so the StringRef API gets closer to string_view?

[MaskRay]

In D150426#4338475, @dblaikie wrote:

I should check - are these function names actually in std::string_view? It doesn't look like it, so renaming them doesn't help us get to the ability to switch to std::string_view, right?

Maybe it'd make more sense to make these non-member functions, so the StringRef API gets closer to string_view?

std::string_view::starts_with_insensitive doesn't exist. It (including startswith_insensitive) is a StringRef extension that occurs ~80 times in llvm-project.

(@aaron.ballman)

[kazu]

In D150426#4338495, @MaskRay wrote:

In D150426#4338475, @dblaikie wrote:

I should check - are these function names actually in std::string_view? It doesn't look like it, so renaming them doesn't help us get to the ability to switch to std::string_view, right?

Maybe it'd make more sense to make these non-member functions, so the StringRef API gets closer to string_view?

std::string_view::starts_with_insensitive doesn't exist. It (including startswith_insensitive) is a StringRef extension that occurs ~80 times in llvm-project.

(@aaron.ballman)

Yes, startswith_insensitive is a StringRef extension.

We should probably tackle StringRef::startswith and StringRef::endswith also, but I'd consult larger audience as they are used in a lot more places.

llvm/include/llvm/ADT/StringRef.h

bool consume_front(StringRef Prefix) {
 
       *this = substr(Prefix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given prefix, ignoring case,
     /// and removes that prefix.
     bool consume_front_insensitive(StringRef Prefix) {
-      if (!startswith_insensitive(Prefix))
+      if (!starts_with_insensitive(Prefix))
         return false;
 
       *this = substr(Prefix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given suffix and removes that
     /// suffix.
     bool consume_back(StringRef Suffix) {
       if (!ends_with(Suffix))
         return false;
 
       *this = substr(0, size() - Suffix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given suffix, ignoring case,
     /// and removes that suffix.
     bool consume_back_insensitive(StringRef Suffix) {
-      if (!endswith_insensitive(Suffix))
+      if (!ends_with_insensitive(Suffix))
         return false;
 
       *this = substr(0, size() - Suffix.size());
       return true;
     }
 
     /// Return a reference to the substring from [Start, End).
     ///

llvm/include/llvm/ADT/StringSwitch.h

public:
   StringSwitch &CaseLower(StringLiteral S, T Value) {
     if (!Result && Str.equals_insensitive(S))
       Result = std::move(Value);
 
     return *this;
   }
 
   StringSwitch &EndsWithLower(StringLiteral S, T Value) {
-    if (!Result && Str.endswith_insensitive(S))
+    if (!Result && Str.ends_with_insensitive(S))
       Result = Value;
 
     return *this;
   }
 
   StringSwitch &StartsWithLower(StringLiteral S, T Value) {
-    if (!Result && Str.startswith_insensitive(S))
+    if (!Result && Str.starts_with_insensitive(S))
       Result = std::move(Value);
 
     return *this;
   }
 
   StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, T Value) {
     return CaseLower(S0, Value).CaseLower(S1, Value);
   }

llvm/include/llvm/Support/FormatProviders.h

static std::optional<size_t> parseNumericPrecision(StringRef Str) {
     } else {
       assert(Prec < 100 && "Precision out of range");
       Result = std::min<size_t>(99u, Prec);
     }
     return Result;
   }
 
   static bool consumeHexStyle(StringRef &Str, HexPrintStyle &Style) {
-    if (!Str.startswith_insensitive("x"))
+    if (!Str.starts_with_insensitive("x"))
       return false;
 
     if (Str.consume_front("x-"))
       Style = HexPrintStyle::Lower;
     else if (Str.consume_front("X-"))
       Style = HexPrintStyle::Upper;
     else if (Str.consume_front("x+") || Str.consume_front("x"))
       Style = HexPrintStyle::PrefixLower;

llvm/lib/DebugInfo/PDB/Native/InputFile.cpp

 
 static bool isMyCode(const SymbolGroup &Group) {
   if (Group.getFile().isObj())
     return true;
 
   StringRef Name = Group.name();
   if (Name.startswith("Import:"))
     return false;
-  if (Name.endswith_insensitive(".dll"))
+  if (Name.ends_with_insensitive(".dll"))
     return false;
   if (Name.equals_insensitive("* linker *"))
     return false;
-  if (Name.startswith_insensitive("f:\\binaries\\Intermediate\\vctools"))
+  if (Name.starts_with_insensitive("f:\\binaries\\Intermediate\\vctools"))
     return false;
-  if (Name.startswith_insensitive("f:\\dd\\vctools\\crt"))
+  if (Name.starts_with_insensitive("f:\\dd\\vctools\\crt"))
     return false;
   return true;
 }
 
 bool llvm::pdb::shouldDumpSymbolGroup(uint32_t Idx, const SymbolGroup &Group,
                                       const FilterOptions &Filters) {
   if (Filters.JustMyCode && !isMyCode(Group))
     return false;
 
   // If the arg was not specified on the command line, always dump all modules.
   if (!Filters.DumpModi)
     return true;
 
   // Otherwise, only dump if this is the same module specified.
   return (Filters.DumpModi == Idx);
 }

llvm/lib/ExecutionEngine/Orc/LLJIT.cpp

Error setUpOrcPlatformManually(LLJIT &J) {
   J.setPlatformSupport(std::make_unique<ORCPlatformSupport>(J));
   return Error::success();
 }
 
 class LoadAndLinkDynLibrary {
 public:
   LoadAndLinkDynLibrary(LLJIT &J) : J(J) {}
   Error operator()(JITDylib &JD, StringRef DLLName) {
-    if (!DLLName.endswith_insensitive(".dll"))
+    if (!DLLName.ends_with_insensitive(".dll"))
       return make_error<StringError>("DLLName not ending with .dll",
                                      inconvertibleErrorCode());
     auto DLLNameStr = DLLName.str(); // Guarantees null-termination.
     auto DLLJD = J.loadPlatformDynamicLibrary(DLLNameStr.c_str());
     if (!DLLJD)
       return DLLJD.takeError();
     JD.addToLinkOrder(*DLLJD);
     return Error::success();

llvm/lib/Option/OptTable.cpp

 }
 
 /// \returns Matched size. 0 means no match.
 static unsigned matchOption(const OptTable::Info *I, StringRef Str,
                             bool IgnoreCase) {
   for (auto Prefix : I->Prefixes) {
     if (Str.startswith(Prefix)) {
       StringRef Rest = Str.substr(Prefix.size());
-      bool Matched = IgnoreCase ? Rest.startswith_insensitive(I->Name)
+      bool Matched = IgnoreCase ? Rest.starts_with_insensitive(I->Name)
                                 : Rest.startswith(I->Name);
       if (Matched)
         return Prefix.size() + StringRef(I->Name).size();
     }
   }
   return 0;
 }
 

llvm/lib/Support/StringRef.cpp

size_t StringRef::find(StringRef Str, size_t From) const {
   } while (Start < Stop);
 
   return npos;
 }
 
 size_t StringRef::find_insensitive(StringRef Str, size_t From) const {
   StringRef This = substr(From);
   while (This.size() >= Str.size()) {
-    if (This.startswith_insensitive(Str))
+    if (This.starts_with_insensitive(Str))
       return From;
     This = This.drop_front();
     ++From;
   }
   return npos;
 }
 
 size_t StringRef::rfind_insensitive(char C, size_t From) const {

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

 
 OperandMatchResultTy
 AArch64AsmParser::tryParseMatrixRegister(OperandVector &Operands) {
   const AsmToken &Tok = getTok();
   SMLoc S = getLoc();
 
   StringRef Name = Tok.getString();
 
-  if (Name.equals_insensitive("za") || Name.startswith_insensitive("za.")) {
+  if (Name.equals_insensitive("za") || Name.starts_with_insensitive("za.")) {
     Lex(); // eat "za[.(b|h|s|d)]"
     unsigned ElementWidth = 0;
     auto DotPosition = Name.find('.');
     if (DotPosition != StringRef::npos) {
       const auto &KindRes =
           parseVectorKind(Name.drop_front(DotPosition), RegKind::Matrix);
       if (!KindRes) {
         TokError(
bool AArch64AsmParser::parseSyspAlias(StringRef Name, SMLoc NameLoc,
   Operands.push_back(
       AArch64Operand::CreateToken("sysp", NameLoc, getContext()));
 
   const AsmToken &Tok = getTok();
   StringRef Op = Tok.getString();
   SMLoc S = Tok.getLoc();
 
   if (Mnemonic == "tlbip") {
-    bool HasnXSQualifier = Op.endswith_insensitive("nXS");
+    bool HasnXSQualifier = Op.ends_with_insensitive("nXS");
     if (HasnXSQualifier) {
       Op = Op.drop_back(3);
     }
     const AArch64TLBI::TLBI *TLBIorig = AArch64TLBI::lookupTLBIByName(Op);
     if (!TLBIorig)
       return TokError("invalid operand for TLBIP instruction");
     const AArch64TLBI::TLBI TLBI(
         TLBIorig->Name, TLBIorig->Encoding | (HasnXSQualifier ? (1 << 7) : 0),
auto ParseVector = [this](MCRegister &Reg, StringRef &Kind, SMLoc Loc,
 
     if (RegTok.is(AsmToken::Identifier) && ParseRes == MatchOperand_NoMatch &&
         RegTok.getString().equals_insensitive("zt0"))
       return MatchOperand_NoMatch;
 
     if (RegTok.isNot(AsmToken::Identifier) ||
         ParseRes == MatchOperand_ParseFail ||
         (ParseRes == MatchOperand_NoMatch && NoMatchIsError &&
-         !RegTok.getString().startswith_insensitive("za"))) {
+         !RegTok.getString().starts_with_insensitive("za"))) {
       Error(Loc, "vector register expected");
       return MatchOperand_ParseFail;
     }
 
     return MatchOperand_NoMatch;
   };
 
   int NumRegs = getNumRegsForRegKind(VectorKind);
if (!ExtensionString.empty())
     ExtensionString.split(RequestedExtensions, '+');
 
   ExpandCryptoAEK(*ArchInfo, RequestedExtensions);
 
   FeatureBitset Features = STI.getFeatureBits();
   for (auto Name : RequestedExtensions) {
     bool EnableFeature = true;
 
-    if (Name.startswith_insensitive("no")) {
+    if (Name.starts_with_insensitive("no")) {
       EnableFeature = false;
       Name = Name.substr(2);
     }
 
     for (const auto &Extension : ExtensionMap) {
       if (Extension.Name != Name)
         continue;
 
bool AArch64AsmParser::parseDirectiveArchExtension(SMLoc L) {
   SMLoc ExtLoc = getLoc();
 
   StringRef Name = getParser().parseStringToEndOfStatement().trim();
 
   if (parseEOL())
     return true;
 
   bool EnableFeature = true;
-  if (Name.startswith_insensitive("no")) {
+  if (Name.starts_with_insensitive("no")) {
     EnableFeature = false;
     Name = Name.substr(2);
   }
 
   MCSubtargetInfo &STI = copySTI();
   FeatureBitset Features = STI.getFeatureBits();
   for (const auto &Extension : ExtensionMap) {
     if (Extension.Name != Name)
bool AArch64AsmParser::parseDirectiveCPU(SMLoc L) {
   CurLoc = incrementLoc(CurLoc, CPU.size());
 
   for (auto Name : RequestedExtensions) {
     // Advance source location past '+'.
     CurLoc = incrementLoc(CurLoc, 1);
 
     bool EnableFeature = true;
 
-    if (Name.startswith_insensitive("no")) {
+    if (Name.starts_with_insensitive("no")) {
       EnableFeature = false;
       Name = Name.substr(2);
     }
 
     bool FoundExtension = false;
     for (const auto &Extension : ExtensionMap) {
       if (Extension.Name != Name)
         continue;

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

const FeatureBitset Features;
       // FIXME: Unsupported extensions.
       {ARM::AEK_OS, {}, {}},
       {ARM::AEK_IWMMXT, {}, {}},
       {ARM::AEK_IWMMXT2, {}, {}},
       {ARM::AEK_MAVERICK, {}, {}},
       {ARM::AEK_XSCALE, {}, {}},
   };
   bool EnableFeature = true;
-  if (Name.startswith_insensitive("no")) {
+  if (Name.starts_with_insensitive("no")) {
     EnableFeature = false;
     Name = Name.substr(2);
   }
   uint64_t FeatureKind = ARM::parseArchExt(Name);
   if (FeatureKind == ARM::AEK_INVALID)
     return Error(ExtLoc, "unknown architectural extension: " + Name);
 
   for (const auto &Extension : Extensions) {

llvm/lib/Target/MSP430/AsmParser/MSP430AsmParser.cpp

OperandMatchResultTy MSP430AsmParser::tryParseRegister(MCRegister &RegNo,
   }
 
   return MatchOperand_ParseFail;
 }
 
 bool MSP430AsmParser::parseJccInstruction(ParseInstructionInfo &Info,
                                           StringRef Name, SMLoc NameLoc,
                                           OperandVector &Operands) {
-  if (!Name.startswith_insensitive("j"))
+  if (!Name.starts_with_insensitive("j"))
     return true;
 
   auto CC = Name.drop_front().lower();
   unsigned CondCode;
   if (CC == "ne" || CC == "nz")
     CondCode = MSP430CC::COND_NE;
   else if (CC == "eq" || CC == "z")
     CondCode = MSP430CC::COND_E;
bool MSP430AsmParser::parseJccInstruction(ParseInstructionInfo &Info,
   getParser().Lex(); // Consume the EndOfStatement.
   return false;
 }
 
 bool MSP430AsmParser::ParseInstruction(ParseInstructionInfo &Info,
                                        StringRef Name, SMLoc NameLoc,
                                        OperandVector &Operands) {
   // Drop .w suffix
-  if (Name.endswith_insensitive(".w"))
+  if (Name.ends_with_insensitive(".w"))
     Name = Name.drop_back(2);
 
   if (!parseJccInstruction(Info, Name, NameLoc, Operands))
     return false;
 
   // First operand is instruction mnemonic
   Operands.push_back(MSP430Operand::CreateToken(Name, NameLoc));
 

llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp

if (Name.equals_insensitive("lr")) {
     RegNo = isPPC64() ? PPC::LR8 : PPC::LR;
     IntVal = 8;
   } else if (Name.equals_insensitive("ctr")) {
     RegNo = isPPC64() ? PPC::CTR8 : PPC::CTR;
     IntVal = 9;
   } else if (Name.equals_insensitive("vrsave")) {
     RegNo = PPC::VRSAVE;
     IntVal = 256;
-  } else if (Name.startswith_insensitive("r") &&
+  } else if (Name.starts_with_insensitive("r") &&
              !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
     RegNo = isPPC64() ? XRegs[IntVal] : RRegs[IntVal];
-  } else if (Name.startswith_insensitive("f") &&
+  } else if (Name.starts_with_insensitive("f") &&
              !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
     RegNo = FRegs[IntVal];
-  } else if (Name.startswith_insensitive("vs") &&
+  } else if (Name.starts_with_insensitive("vs") &&
              !Name.substr(2).getAsInteger(10, IntVal) && IntVal < 64) {
     RegNo = VSRegs[IntVal];
-  } else if (Name.startswith_insensitive("v") &&
+  } else if (Name.starts_with_insensitive("v") &&
              !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
     RegNo = VRegs[IntVal];
-  } else if (Name.startswith_insensitive("cr") &&
+  } else if (Name.starts_with_insensitive("cr") &&
              !Name.substr(2).getAsInteger(10, IntVal) && IntVal < 8) {
     RegNo = CRRegs[IntVal];
-  } else if (Name.startswith_insensitive("acc") &&
+  } else if (Name.starts_with_insensitive("acc") &&
              !Name.substr(3).getAsInteger(10, IntVal) && IntVal < 8) {
     RegNo = ACCRegs[IntVal];
-  } else if (Name.startswith_insensitive("wacc_hi") &&
+  } else if (Name.starts_with_insensitive("wacc_hi") &&
              !Name.substr(7).getAsInteger(10, IntVal) && IntVal < 8) {
     RegNo = ACCRegs[IntVal];
-  } else if (Name.startswith_insensitive("wacc") &&
+  } else if (Name.starts_with_insensitive("wacc") &&
              !Name.substr(4).getAsInteger(10, IntVal) && IntVal < 8) {
     RegNo = WACCRegs[IntVal];
-  } else if (Name.startswith_insensitive("dmrrowp") &&
+  } else if (Name.starts_with_insensitive("dmrrowp") &&
              !Name.substr(7).getAsInteger(10, IntVal) && IntVal < 32) {
     RegNo = DMRROWpRegs[IntVal];
-  } else if (Name.startswith_insensitive("dmrrow") &&
+  } else if (Name.starts_with_insensitive("dmrrow") &&
              !Name.substr(6).getAsInteger(10, IntVal) && IntVal < 64) {
     RegNo = DMRROWRegs[IntVal];
-  } else if (Name.startswith_insensitive("dmrp") &&
+  } else if (Name.starts_with_insensitive("dmrp") &&
              !Name.substr(4).getAsInteger(10, IntVal) && IntVal < 4) {
     RegNo = DMRROWpRegs[IntVal];
-  } else if (Name.startswith_insensitive("dmr") &&
+  } else if (Name.starts_with_insensitive("dmr") &&
              !Name.substr(3).getAsInteger(10, IntVal) && IntVal < 8) {
     RegNo = DMRRegs[IntVal];
   } else
     return true;
   getParser().Lex();
   return false;
 }
 

llvm/lib/WindowsDriver/MSVCPaths.cpp

for (StringRef PathEntry : PathEntries) {
         StringRef ExpectedPrefixes[] = {"",     "Host",  "bin", "",
                                         "MSVC", "Tools", "VC"};
 
         auto It = sys::path::rbegin(PathEntry);
         auto End = sys::path::rend(PathEntry);
         for (StringRef Prefix : ExpectedPrefixes) {
           if (It == End)
             goto NotAToolChain;
-          if (!It->startswith_insensitive(Prefix))
+          if (!It->starts_with_insensitive(Prefix))
             goto NotAToolChain;
           ++It;
         }
 
         // We've found a new toolchain!
         // Back up 3 times (/bin/Host/arch) to get the root path.
         StringRef ToolChainPath(PathEntry);
         for (int i = 0; i < 3; ++i)

llvm/tools/bugpoint/ToolRunner.cpp

 
 static bool IsARMArchitecture(std::vector<StringRef> Args) {
   for (size_t I = 0; I < Args.size(); ++I) {
     if (!Args[I].equals_insensitive("-arch"))
       continue;
     ++I;
     if (I == Args.size())
       break;
-    if (Args[I].startswith_insensitive("arm"))
+    if (Args[I].starts_with_insensitive("arm"))
       return true;
   }
 
   return false;
 }
 
 Expected<int> CC::ExecuteProgram(const std::string &ProgramFile,
                                  const std::vector<std::string> &Args,

llvm/tools/llvm-cov/llvm-cov.cpp

static int versionMain(int argc, const char *argv[]) {
   cl::PrintVersionMessage();
   return 0;
 }
 
 int main(int argc, const char **argv) {
   InitLLVM X(argc, argv);
 
   // If argv[0] is or ends with 'gcov', always be gcov compatible
-  if (sys::path::stem(argv[0]).endswith_insensitive("gcov"))
+  if (sys::path::stem(argv[0]).ends_with_insensitive("gcov"))
     return gcovMain(argc, argv);
 
   // Check if we are invoking a specific tool command.
   if (argc > 1) {
     typedef int (*MainFunction)(int, const char *[]);
     MainFunction Func = StringSwitch<MainFunction>(argv[1])
                             .Case("convert-for-testing", convertForTestingMain)
                             .Case("export", exportMain)

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

private:
   uint64_t DeltaAddr;
 };
 
 Expected<uint64_t> getSlabAllocSize(StringRef SizeString) {
   SizeString = SizeString.trim();
 
   uint64_t Units = 1024;
 
-  if (SizeString.endswith_insensitive("kb"))
+  if (SizeString.ends_with_insensitive("kb"))
     SizeString = SizeString.drop_back(2).rtrim();
-  else if (SizeString.endswith_insensitive("mb")) {
+  else if (SizeString.ends_with_insensitive("mb")) {
     Units = 1024 * 1024;
     SizeString = SizeString.drop_back(2).rtrim();
-  } else if (SizeString.endswith_insensitive("gb")) {
+  } else if (SizeString.ends_with_insensitive("gb")) {
     Units = 1024 * 1024 * 1024;
     SizeString = SizeString.drop_back(2).rtrim();
   }
 
   uint64_t SlabSize = 0;
   if (SizeString.getAsInteger(10, SlabSize))
     return make_error<StringError>("Invalid numeric format for slab size",
                                    inconvertibleErrorCode());
if (auto P =
             ELFNixPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str()))
       ES.setPlatform(std::move(*P));
     else {
       Err = P.takeError();
       return;
     }
   } else if (TT.isOSBinFormatCOFF() && !OrcRuntime.empty()) {
     auto LoadDynLibrary = [&, this](JITDylib &JD, StringRef DLLName) -> Error {
-      if (!DLLName.endswith_insensitive(".dll"))
+      if (!DLLName.ends_with_insensitive(".dll"))
         return make_error<StringError>("DLLName not ending with .dll",
                                        inconvertibleErrorCode());
       return loadAndLinkDynamicLibrary(JD, DLLName);
     };
 
     if (auto P = COFFPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str(),
                                       std::move(LoadDynLibrary))) 
       ES.setPlatform(std::move(*P));
auto AddArchive = [&](const char *Path, const LibraryLoad &LL)
     if (!G)
       return G.takeError();
 
     // Push additional dynamic libraries to search.
     // Note that this mechanism only happens in COFF.
     for (auto FileName : (*G)->getImportedDynamicLibraries()) {
       LibraryLoad NewLL;
       auto FileNameRef = StringRef(FileName);
-      if (!FileNameRef.endswith_insensitive(".dll"))
+      if (!FileNameRef.ends_with_insensitive(".dll"))
         return make_error<StringError>(
             "COFF Imported library not ending with dll extension?",
             inconvertibleErrorCode());
       NewLL.LibName = FileNameRef.drop_back(strlen(".dll")).str();
       NewLL.Position = LL.Position;
       NewLL.CandidateExtensions = DynLibExtensionsOnly;
       NewLL.Modifier = LibraryLoad::Standard;
       LibraryLoadQueue.push_front(std::move(NewLL));

llvm/tools/llvm-rc/ResourceFileWriter.cpp

static Error checkIntOrString(IntOrString Value, const Twine &FieldName) {
   return checkNumberFits<uint16_t>(Value.getInt(), FieldName);
 }
 
 static bool stripQuotes(StringRef &Str, bool &IsLongString) {
   if (!Str.contains('"'))
     return false;
 
   // Just take the contents of the string, checking if it's been marked long.
-  IsLongString = Str.startswith_insensitive("L");
+  IsLongString = Str.starts_with_insensitive("L");
   if (IsLongString)
     Str = Str.drop_front();
 
   bool StripSuccess = Str.consume_front("\"") && Str.consume_back("\"");
   (void)StripSuccess;
   assert(StripSuccess && "Strings should be enclosed in quotes.");
   return true;
 }