[ADT] Rename StringRef case insensitive methods for clarity

[mstorsjo]

Summary

Rename functions with the xx_lower() names to xx_insensitive().
This was requested during the review of D104218.

Test names and variables in llvm/unittests/ADT/StringRefTest.cpp
that refer to "lower" are renamed to "insensitive" correspondingly.

Unused function aliases with the former method names are left
in place (without any deprecation attributes) for transition purposes.

All references within the monorepo will be changed (with essentially
mechanical changes), and then the old names will be removed in a
later commit.

Also remove the superfluous method names at the start of doxygen
comments, for the methods that are touched here. (There are more
occurrances of this left in other methods though.)

[dexonsmith]

Given how large this is, would it be reasonable to split this up a bit more?

What I might do if this were my patch: get a review of the API change + the manual changes in one patch (assuming there aren't many manual changes), then land the remaining mechanical changes in chunks, perhaps vaguely by component, likely using post-commit review. The benefit of committing by chunks is that if there is some problem that comes up (even mechanical changes fail) there's more granularity for bisection (and less churn on revert). WDYT?

Also: is there a reference to this API in the ProgrammersManual? (I honestly don't know, but if there is, please be sure to update it as well.)

[MaskRay]

llvm/include/llvm/ADT/StringRef.h

192

https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments

"Don’t duplicate function or class name at the beginning of the comment."

[mstorsjo]

In D104819#2837421, @dexonsmith wrote:

Given how large this is, would it be reasonable to split this up a bit more?

What I might do if this were my patch: get a review of the API change + the manual changes in one patch (assuming there aren't many manual changes), then land the remaining mechanical changes in chunks, perhaps vaguely by component, likely using post-commit review. The benefit of committing by chunks is that if there is some problem that comes up (even mechanical changes fail) there's more granularity for bisection (and less churn on revert). WDYT?

That sounds like a good plan to me, thanks for the suggestion!

Also: is there a reference to this API in the ProgrammersManual? (I honestly don't know, but if there is, please be sure to update it as well.)

I don't think so, at least grepping for _lower didn't hit anything in llvm/docs (and manually browsing it now, the section on StringRef doesn't mention those methods).

llvm/include/llvm/ADT/StringRef.h

192

Thanks, I'll fix those for the methods I'm renaming here, but I'll refrain from touching the other methods in this patch.

[mstorsjo]

Reduced this patch only to updating of the StringRef class itself and its unit test, removing the mechanical changes. Removed superfluous method name duplication in doxygen comments.

[dexonsmith]

LGTM, once @MaskRay is happy. I have a couple of minor comments inline too.

(I also see that there are some clang-format suggestions in the unit tests; not sure any of them are actually improvements so maybe you left those out intentionally? Just be sure to clang-format when you do the mechanical changes in the follow up patches.)

llvm/include/llvm/ADT/StringRef.h

198

You could probably drop the LLVM_NODISCARD from the soon-to-be-deleted _lower variants, but maybe it's not worth fussing with (up to you).

llvm/lib/Support/StringRef.cpp

37–38

You can drop these duplicate doxygen comments entirely from the .cpp file.

[lattner]

Thank you!

[mstorsjo]

In D104819#2839263, @dexonsmith wrote:

LGTM, once @MaskRay is happy. I have a couple of minor comments inline too.

(I also see that there are some clang-format suggestions in the unit tests; not sure any of them are actually improvements so maybe you left those out intentionally?

Yeah those seem to be intentionally vertically aligned that way, no big opinion either way

Just be sure to clang-format when you do the mechanical changes in the follow up patches.)

Hmm, those would have to be manually reviewed, but I guess I can try to do that (discarding changes where the surrounding code isn't too well formatted now already so it does more extensive reformattings other than for the renaming).

llvm/lib/Support/StringRef.cpp

37–38

Sure, yeah doxygen in implementation files make little sense anyway.

[dexonsmith]

In D104819#2839315, @mstorsjo wrote:

In D104819#2839263, @dexonsmith wrote:

Just be sure to clang-format when you do the mechanical changes in the follow up patches.)

Hmm, those would have to be manually reviewed, but I guess I can try to do that (discarding changes where the surrounding code isn't too well formatted now already so it does more extensive reformattings other than for the renaming).

Sounds good. (I'm generally in favour of erring on the side of trusting clang-format, especially for large refactorings like this; I wouldn't spend too much time analyzing whether it's an improvement...)

clang-tools-extra/clang-tidy/ClangTidyCheck.cpp

llvm::Optional<int64_t> ClangTidyCheck::OptionsView::getEnumInt(
   if (Iter == CheckOptions.end())
     return None;
 
   StringRef Value = Iter->getValue().Value;
   StringRef Closest;
   unsigned EditDistance = 3;
   for (const auto &NameAndEnum : Mapping) {
     if (IgnoreCase) {
-      if (Value.equals_lower(NameAndEnum.second))
+      if (Value.equals_insensitive(NameAndEnum.second))
         return NameAndEnum.first;
     } else if (Value.equals(NameAndEnum.second)) {
       return NameAndEnum.first;
-    } else if (Value.equals_lower(NameAndEnum.second)) {
+    } else if (Value.equals_insensitive(NameAndEnum.second)) {
       Closest = NameAndEnum.second;
       EditDistance = 0;
       continue;
     }
     unsigned Distance =
         Value.edit_distance(NameAndEnum.second, true, EditDistance);
     if (Distance < EditDistance) {
       EditDistance = Distance;

clang-tools-extra/clang-tidy/altera/KernelNameRestrictionCheck.cpp

void KernelNameRestrictionPPCallbacks::InclusionDirective(
     CharSourceRange, const FileEntry *, StringRef, StringRef, const Module *,
     SrcMgr::CharacteristicKind) {
   IncludeDirective ID = {HashLoc, FileName};
   IncludeDirectives.push_back(std::move(ID));
 }
 
 bool KernelNameRestrictionPPCallbacks::fileNameIsRestricted(
     StringRef FileName) {
-  return FileName.equals_lower("kernel.cl") ||
-         FileName.equals_lower("verilog.cl") ||
-         FileName.equals_lower("vhdl.cl");
+  return FileName.equals_insensitive("kernel.cl") ||
+         FileName.equals_insensitive("verilog.cl") ||
+         FileName.equals_insensitive("vhdl.cl");
 }
 
 void KernelNameRestrictionPPCallbacks::EndOfMainFile() {
 
   // Check main file for restricted names.
   const FileEntry *Entry = SM.getFileEntryForID(SM.getMainFileID());
   StringRef FileName = llvm::sys::path::filename(Entry->getName());
   if (fileNameIsRestricted(FileName))

clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp

static bool isLikelyTypo(llvm::ArrayRef<ParmVarDecl *> Params,
   return true;
 }
 
 static bool sameName(StringRef InComment, StringRef InDecl, bool StrictMode) {
   if (StrictMode)
     return InComment == InDecl;
   InComment = InComment.trim('_');
   InDecl = InDecl.trim('_');
-  // FIXME: compare_lower only works for ASCII.
-  return InComment.compare_lower(InDecl) == 0;
+  // FIXME: compare_insensitive only works for ASCII.
+  return InComment.compare_insensitive(InDecl) == 0;
 }
 
 static bool looksLikeExpectMethod(const CXXMethodDecl *Expect) {
   return Expect != nullptr && Expect->getLocation().isMacroID() &&
          Expect->getNameInfo().getName().isIdentifier() &&
          Expect->getName().startswith("gmock_");
 }
 static bool areMockAndExpectMethods(const CXXMethodDecl *Mock,

clang-tools-extra/clang-tidy/cppcoreguidelines/PreferMemberInitializerCheck.cpp

void PreferMemberInitializerCheck::check(
 
   const CXXRecordDecl *Class = Ctor->getParent();
   bool FirstToCtorInits = true;
 
   for (const Stmt *S : Body->body()) {
     if (S->getBeginLoc().isMacroID()) {
       StringRef MacroName = Lexer::getImmediateMacroName(
           S->getBeginLoc(), *Result.SourceManager, getLangOpts());
-      if (MacroName.contains_lower("assert"))
+      if (MacroName.contains_insensitive("assert"))
         return;
     }
     if (isControlStatement(S))
       return;
 
     if (isNoReturnCallStatement(S))
       return;
 

clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp

void StaticAssertCheck::check(const MatchFinder::MatchResult &Result) {
   if (IsAlwaysFalse && (!CastExpr || CastExpr->getType()->isPointerType())) {
     SourceLocation FalseLiteralLoc =
         SM.getImmediateSpellingLoc(IsAlwaysFalse->getExprLoc());
     if (!FalseLiteralLoc.isMacroID())
       return;
 
     StringRef FalseMacroName =
         Lexer::getImmediateMacroName(FalseLiteralLoc, SM, Opts);
-    if (FalseMacroName.compare_lower("false") == 0 ||
-        FalseMacroName.compare_lower("null") == 0)
+    if (FalseMacroName.compare_insensitive("false") == 0 ||
+        FalseMacroName.compare_insensitive("null") == 0)
       return;
   }
 
   SourceLocation AssertLoc = SM.getImmediateMacroCallerLoc(AssertExpansionLoc);
 
   SmallVector<FixItHint, 4> FixItHints;
   SourceLocation LastParenLoc;
   if (AssertLoc.isValid() && !AssertLoc.isMacroID() &&

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

bool checkIfFixItHintIsApplicable(
   return true;
 }
 
 bool nameMatch(StringRef L, StringRef R, bool Strict) {
   if (Strict)
     return L.empty() || R.empty() || L == R;
   // We allow two names if one is a prefix/suffix of the other, ignoring case.
   // Important special case: this is true if either parameter has no name!
-  return L.startswith_lower(R) || R.startswith_lower(L) ||
-         L.endswith_lower(R) || R.endswith_lower(L);
+  return L.startswith_insensitive(R) || R.startswith_insensitive(L) ||
+         L.endswith_insensitive(R) || R.endswith_insensitive(L);
 }
 
 DifferingParamsContainer
 findDifferingParamsInDeclaration(const FunctionDecl *ParameterSourceDeclaration,
                                  const FunctionDecl *OtherDeclaration,
                                  const FunctionDecl *OriginalDeclaration,
                                  bool Strict) {
   DifferingParamsContainer DifferingParams;

clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

 getNewSuffix(llvm::StringRef OldSuffix,
              const std::vector<std::string> &NewSuffixes) {
   // If there is no config, just uppercase the entirety of the suffix.
   if (NewSuffixes.empty())
     return OldSuffix.upper();
   // Else, find matching suffix, case-*insensitive*ly.
   auto NewSuffix = llvm::find_if(
       NewSuffixes, [OldSuffix](const std::string &PotentialNewSuffix) {
-        return OldSuffix.equals_lower(PotentialNewSuffix);
+        return OldSuffix.equals_insensitive(PotentialNewSuffix);
       });
   // Have a match, return it.
   if (NewSuffix != NewSuffixes.end())
     return *NewSuffix;
   // Nope, I guess we have to keep it as-is.
   return llvm::None;
 }
 

clang-tools-extra/clangd/CodeComplete.cpp

private:
   }
 
   llvm::Optional<float> fuzzyScore(const CompletionCandidate &C) {
     // Macros can be very spammy, so we only support prefix completion.
     if (((C.SemaResult &&
           C.SemaResult->Kind == CodeCompletionResult::RK_Macro) ||
          (C.IndexResult &&
           C.IndexResult->SymInfo.Kind == index::SymbolKind::Macro)) &&
-        !C.Name.startswith_lower(Filter->pattern()))
+        !C.Name.startswith_insensitive(Filter->pattern()))
       return None;
     return Filter->match(C.Name);
   }
 
   CodeCompletion::Scores
   evaluateCompletion(const SymbolQualitySignals &Quality,
                      const SymbolRelevanceSignals &Relevance) {
     using RM = CodeCompleteOptions::CodeCompletionRankingModel;

clang-tools-extra/clangd/CompileCommands.cpp

enum DriverMode : unsigned char {
   DM_CC1 = 4, // When invoked as 'clang -cc1' or after '-Xclang'
   DM_All = 7
 };
 
 // Examine args list to determine if we're in GCC, CL-compatible, or cc1 mode.
 DriverMode getDriverMode(const std::vector<std::string> &Args) {
   DriverMode Mode = DM_GCC;
   llvm::StringRef Argv0 = Args.front();
-  if (Argv0.endswith_lower(".exe"))
+  if (Argv0.endswith_insensitive(".exe"))
     Argv0 = Argv0.drop_back(strlen(".exe"));
-  if (Argv0.endswith_lower("cl"))
+  if (Argv0.endswith_insensitive("cl"))
     Mode = DM_CL;
   for (const llvm::StringRef Arg : Args) {
     if (Arg == "--driver-mode=cl") {
       Mode = DM_CL;
       break;
     }
     if (Arg == "-cc1") {
       Mode = DM_CC1;

clang-tools-extra/clangd/ConfigYAML.cpp

Dict.handle("External", [&](Node &N) {
       F.External.emplace(std::move(External));
       F.External->Range = N.getSourceRange();
     });
     Dict.parse(N);
   }
 
   void parse(Fragment::IndexBlock::ExternalBlock &F,
              Located<std::string> ExternalVal) {
-    if (!llvm::StringRef(*ExternalVal).equals_lower("none")) {
+    if (!llvm::StringRef(*ExternalVal).equals_insensitive("none")) {
       error("Only scalar value supported for External is 'None'",
             ExternalVal.Range);
       return;
     }
     F.IsNone = true;
     F.IsNone.Range = ExternalVal.Range;
   }
 

clang-tools-extra/clangd/HeaderSourceSwitch.cpp

llvm::StringRef SourceExtensions[] = {".cpp", ".c", ".cc", ".cxx",
                                         ".c++", ".m", ".mm"};
   llvm::StringRef HeaderExtensions[] = {".h", ".hh", ".hpp", ".hxx", ".inc"};
 
   llvm::StringRef PathExt = llvm::sys::path::extension(OriginalFile);
 
   // Lookup in a list of known extensions.
   auto SourceIter =
       llvm::find_if(SourceExtensions, [&PathExt](PathRef SourceExt) {
-        return SourceExt.equals_lower(PathExt);
+        return SourceExt.equals_insensitive(PathExt);
       });
   bool IsSource = SourceIter != std::end(SourceExtensions);
 
   auto HeaderIter =
       llvm::find_if(HeaderExtensions, [&PathExt](PathRef HeaderExt) {
-        return HeaderExt.equals_lower(PathExt);
+        return HeaderExt.equals_insensitive(PathExt);
       });
   bool IsHeader = HeaderIter != std::end(HeaderExtensions);
 
   // We can only switch between the known extensions.
   if (!IsSource && !IsHeader)
     return None;
 
   // Array to lookup extensions for the switch. An opposite of where original

clang-tools-extra/clangd/InlayHints.cpp

void processCall(SourceLocation Anchor, const FunctionDecl *Callee,
     }
   }
 
   static bool isSetter(const FunctionDecl *Callee, const NameVec &ParamNames) {
     if (ParamNames.size() != 1)
       return false;
 
     StringRef Name = getSimpleName(*Callee);
-    if (!Name.startswith_lower("set"))
+    if (!Name.startswith_insensitive("set"))
       return false;
 
     // In addition to checking that the function has one parameter and its
     // name starts with "set", also check that the part after "set" matches
     // the name of the parameter (ignoring case). The idea here is that if
     // the parameter name differs, it may contain extra information that
     // may be useful to show in a hint, as in:
     //   void setTimeout(int timeoutMillis);
     // This currently doesn't handle cases where params use snake_case
     // and functions don't, e.g.
     //   void setExceptionHandler(EHFunc exception_handler);
-    // We could improve this by replacing `equals_lower` with some
+    // We could improve this by replacing `equals_insensitive` with some
     // `sloppy_equals` which ignores case and also skips underscores.
     StringRef WhatItIsSetting = Name.substr(3).ltrim("_");
-    return WhatItIsSetting.equals_lower(ParamNames[0]);
+    return WhatItIsSetting.equals_insensitive(ParamNames[0]);
   }
 
   bool shouldHint(const Expr *Arg, StringRef ParamName) {
     if (ParamName.empty())
       return false;
 
     // If the argument expression is a single name and it matches the
     // parameter name exactly, omit the hint.

clang-tools-extra/clangd/Quality.cpp

if (ScopeDistance == FileDistance::Unreachable)
     return 0.6f;
   return std::max(0.65, 2.0 * std::pow(0.6, ScopeDistance / 2.0));
 }
 
 static llvm::Optional<llvm::StringRef>
 wordMatching(llvm::StringRef Name, const llvm::StringSet<> *ContextWords) {
   if (ContextWords)
     for (const auto &Word : ContextWords->keys())
-      if (Name.contains_lower(Word))
+      if (Name.contains_insensitive(Word))
         return Word;
   return llvm::None;
 }
 
 SymbolRelevanceSignals::DerivedSignals
 SymbolRelevanceSignals::calculateDerivedSignals() const {
   DerivedSignals Derived;
   Derived.NameMatchesContext = wordMatching(Name, ContextWords).hasValue();
evaluateDecisionForest(const SymbolQualitySignals &Quality,
   E.setNumReferences(Quality.References);
   E.setSymbolCategory(Quality.Category);
 
   SymbolRelevanceSignals::DerivedSignals Derived =
       Relevance.calculateDerivedSignals();
   int NumMatch = 0;
   if (Relevance.ContextWords) {
     for (const auto &Word : Relevance.ContextWords->keys()) {
-      if (Relevance.Name.contains_lower(Word)) {
+      if (Relevance.Name.contains_insensitive(Word)) {
         ++NumMatch;
       }
     }
   }
   E.setIsNameInContext(NumMatch > 0);
   E.setNumNameInContext(NumMatch);
   E.setFractionNameInContext(
       Relevance.ContextWords && !Relevance.ContextWords->empty()

clang-tools-extra/clangd/index/SymbolCollector.cpp

private:
   // Is Line an #error directive mentioning includes?
   static bool isErrorAboutInclude(llvm::StringRef Line) {
     Line = Line.ltrim();
     if (!Line.consume_front("#"))
       return false;
     Line = Line.ltrim();
     if (!Line.startswith("error"))
       return false;
-    return Line.contains_lower("includ"); // Matches "include" or "including".
+    return Line.contains_insensitive("includ"); // Matches "include" or "including".
   }
 
   // Heuristically headers that only want to be included via an umbrella.
   static bool isDontIncludeMeHeader(llvm::StringRef Content) {
     llvm::StringRef Line;
     // Only sniff up to 100 lines or 10KB.
     Content = Content.take_front(100 * 100);
     for (unsigned I = 0; I < 100 && !Content.empty(); ++I) {

clang-tools-extra/clangd/support/Path.cpp

 //===--- Path.cpp -------------------------------------------*- C++-*------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/Path.h"
 #include "llvm/Support/Path.h"
 namespace clang {
 namespace clangd {
 
 #ifdef CLANGD_PATH_CASE_INSENSITIVE
 std::string maybeCaseFoldPath(PathRef Path) { return Path.lower(); }
-bool pathEqual(PathRef A, PathRef B) { return A.equals_lower(B); }
+bool pathEqual(PathRef A, PathRef B) { return A.equals_insensitive(B); }
 #else  // NOT CLANGD_PATH_CASE_INSENSITIVE
 std::string maybeCaseFoldPath(PathRef Path) { return Path.str(); }
 bool pathEqual(PathRef A, PathRef B) { return A == B; }
 #endif // CLANGD_PATH_CASE_INSENSITIVE
 
 PathRef absoluteParent(PathRef Path) {
   assert(llvm::sys::path::is_absolute(Path));
 #if defined(_WIN32)

clang-tools-extra/modularize/ModularizeUtilities.cpp

 // If the file extension is .h, .inc, or missing, it's
 // assumed to be a header.
 // \param FileName The file name.  Must not be a directory.
 // \returns true if it has a header extension or no extension.
 bool ModularizeUtilities::isHeader(StringRef FileName) {
   StringRef Extension = llvm::sys::path::extension(FileName);
   if (Extension.size() == 0)
     return true;
-  if (Extension.equals_lower(".h"))
+  if (Extension.equals_insensitive(".h"))
     return true;
-  if (Extension.equals_lower(".inc"))
+  if (Extension.equals_insensitive(".inc"))
     return true;
   return false;
 }
 
 // Get directory path component from file path.
 // \returns the component of the given path, which will be
 // relative if the given path is relative, absolute if the
 // given path is absolute, or "." if the path has no leading

clang/lib/ASTMatchers/Dynamic/Marshallers.cpp

 
 static llvm::Optional<std::string>
 getBestGuess(llvm::StringRef Search, llvm::ArrayRef<llvm::StringRef> Allowed,
              llvm::StringRef DropPrefix = "", unsigned MaxEditDistance = 3) {
   if (MaxEditDistance != ~0U)
     ++MaxEditDistance;
   llvm::StringRef Res;
   for (const llvm::StringRef &Item : Allowed) {
-    if (Item.equals_lower(Search)) {
+    if (Item.equals_insensitive(Search)) {
       assert(!Item.equals(Search) && "This should be handled earlier on.");
       MaxEditDistance = 1;
       Res = Item;
       continue;
     }
     unsigned Distance = Item.edit_distance(Search);
     if (Distance < MaxEditDistance) {
       MaxEditDistance = Distance;
       Res = Item;
     }
   }
   if (!Res.empty())
     return Res.str();
   if (!DropPrefix.empty()) {
     --MaxEditDistance; // Treat dropping the prefix as 1 edit
     for (const llvm::StringRef &Item : Allowed) {
       auto NoPrefix = Item;
       if (!NoPrefix.consume_front(DropPrefix))
         continue;
-      if (NoPrefix.equals_lower(Search)) {
+      if (NoPrefix.equals_insensitive(Search)) {
         if (NoPrefix.equals(Search))
           return Item.str();
         MaxEditDistance = 1;
         Res = Item;
         continue;
       }
       unsigned Distance = NoPrefix.edit_distance(Search);
       if (Distance < MaxEditDistance) {

clang/lib/Analysis/CalledOnceCheck.cpp

 /// Check whether the given expression mentions any of conventional names.
 bool mentionsAnyOfConventionalNames(const Expr *E) {
   NamesCollector::NameCollection MentionedNames = NamesCollector::collect(E);
 
   return llvm::any_of(MentionedNames, [](llvm::StringRef ConditionName) {
     return llvm::any_of(
         CONVENTIONAL_CONDITIONS,
         [ConditionName](const llvm::StringLiteral &Conventional) {
-          return ConditionName.contains_lower(Conventional);
+          return ConditionName.contains_insensitive(Conventional);
         });
   });
 }
 
 /// Clarification is a simple pair of a reason why parameter is not called
 /// on every path and a statement to blame.
 struct Clarification {
   NeverCalledReason Reason;

clang/lib/Analysis/RetainSummaryManager.cpp

static bool hasRCAnnotation(const Decl *D, StringRef rcAnnotation) {
   for (const auto *Ann : D->specific_attrs<AnnotateAttr>()) {
     if (Ann->getAnnotation() == rcAnnotation)
       return true;
   }
   return false;
 }
 
 static bool isRetain(const FunctionDecl *FD, StringRef FName) {
-  return FName.startswith_lower("retain") || FName.endswith_lower("retain");
+  return FName.startswith_insensitive("retain") || FName.endswith_insensitive("retain");
 }
 
 static bool isRelease(const FunctionDecl *FD, StringRef FName) {
-  return FName.startswith_lower("release") || FName.endswith_lower("release");
+  return FName.startswith_insensitive("release") || FName.endswith_insensitive("release");
 }
 
 static bool isAutorelease(const FunctionDecl *FD, StringRef FName) {
-  return FName.startswith_lower("autorelease") ||
-         FName.endswith_lower("autorelease");
+  return FName.startswith_insensitive("autorelease") ||
+         FName.endswith_insensitive("autorelease");
 }
 
 static bool isMakeCollectable(StringRef FName) {
-  return FName.contains_lower("MakeCollectable");
+  return FName.contains_insensitive("MakeCollectable");
 }
 
 /// A function is OSObject related if it is declared on a subclass
 /// of OSObject, or any of the parameters is a subclass of an OSObject.
 static bool isOSObjectRelated(const CXXMethodDecl *MD) {
   if (isOSObjectSubclass(MD->getParent()))
     return true;
 
RetainSummaryManager::getStandardMethodSummary(const ObjCMethodDecl *MD,
 
   // If one of the arguments in the selector has the keyword 'delegate' we
   // should stop tracking the reference count for the receiver.  This is
   // because the reference count is quite possibly handled by a delegate
   // method.
   if (S.isKeywordSelector()) {
     for (unsigned i = 0, e = S.getNumArgs(); i != e; ++i) {
       StringRef Slot = S.getNameForSlot(i);
-      if (Slot.substr(Slot.size() - 8).equals_lower("delegate")) {
+      if (Slot.substr(Slot.size() - 8).equals_insensitive("delegate")) {
         if (ResultEff == ObjCInitRetE)
           ResultEff = RetEffect::MakeNoRetHard();
         else
           ReceiverEff = ArgEffect(StopTrackingHard, ObjKind::ObjC);
       }
     }
   }
 

clang/lib/Basic/FileManager.cpp

if (DirName.size() > 1 &&
       DirName != llvm::sys::path::root_path(DirName) &&
       llvm::sys::path::is_separator(DirName.back()))
     DirName = DirName.substr(0, DirName.size()-1);
 #ifdef _WIN32
   // Fixing a problem with "clang C:test.c" on Windows.
   // Stat("C:") does not recognize "C:" as a valid directory
   std::string DirNameStr;
   if (DirName.size() > 1 && DirName.back() == ':' &&
-      DirName.equals_lower(llvm::sys::path::root_name(DirName))) {
+      DirName.equals_insensitive(llvm::sys::path::root_name(DirName))) {
     DirNameStr = DirName.str() + '.';
     DirName = DirNameStr;
   }
 #endif
 
   ++NumDirLookups;
 
   // See if there was already an entry in the map.  Note that the map

clang/lib/CodeGen/TargetInfo.cpp

 
 static std::string qualifyWindowsLibrary(llvm::StringRef Lib) {
   // If the argument does not end in .lib, automatically add the suffix.
   // If the argument contains a space, enclose it in quotes.
   // This matches the behavior of MSVC.
   bool Quote = (Lib.find(' ') != StringRef::npos);
   std::string ArgStr = Quote ? "\"" : "";
   ArgStr += Lib;
-  if (!Lib.endswith_lower(".lib") && !Lib.endswith_lower(".a"))
+  if (!Lib.endswith_insensitive(".lib") && !Lib.endswith_insensitive(".a"))
     ArgStr += ".lib";
   ArgStr += Quote ? "\"" : "";
   return ArgStr;
 }
 
 class WinX86_32TargetCodeGenInfo : public X86_32TargetCodeGenInfo {
 public:
   WinX86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT,

clang/lib/Driver/Driver.cpp

if (A && Target.isMIPS()) {
     }
   }
 
   // If target is RISC-V adjust the target triple according to
   // provided architecture name
   A = Args.getLastArg(options::OPT_march_EQ);
   if (A && Target.isRISCV()) {
     StringRef ArchName = A->getValue();
-    if (ArchName.startswith_lower("rv32"))
+    if (ArchName.startswith_insensitive("rv32"))
       Target.setArch(llvm::Triple::riscv32);
-    else if (ArchName.startswith_lower("rv64"))
+    else if (ArchName.startswith_insensitive("rv64"))
       Target.setArch(llvm::Triple::riscv64);
   }
 
   return Target;
 }
 
 // Parse the LTO options and record the type of LTO compilation
 // based on which -f(no-)?lto(=.*)? or -f(no-)?offload-lto(=.*)?
for (StringRef S : DiagnosticIDs::getDiagnosticFlags())
         SuggestedCompletions.push_back(std::string(S));
   }
 
   // Sort the autocomplete candidates so that shells print them out in a
   // deterministic order. We could sort in any way, but we chose
   // case-insensitive sorting for consistency with the -help option
   // which prints out options in the case-insensitive alphabetical order.
   llvm::sort(SuggestedCompletions, [](StringRef A, StringRef B) {
-    if (int X = A.compare_lower(B))
+    if (int X = A.compare_insensitive(B))
       return X < 0;
     return A.compare(B) > 0;
   });
 
   llvm::outs() << llvm::join(SuggestedCompletions, "\n") << '\n';
 }
 
 bool Driver::HandleImmediateArgs(const Compilation &C) {
void Driver::handleArguments(Compilation &C, DerivedArgList &Args,
 
   Arg *FinalPhaseArg;
   phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
 
   if (FinalPhase == phases::Link) {
     if (Args.hasArg(options::OPT_emit_llvm))
       Diag(clang::diag::err_drv_emit_llvm_link);
     if (IsCLMode() && LTOMode != LTOK_None &&
-        !Args.getLastArgValue(options::OPT_fuse_ld_EQ).equals_lower("lld"))
+        !Args.getLastArgValue(options::OPT_fuse_ld_EQ).equals_insensitive("lld"))
       Diag(clang::diag::err_drv_lto_without_lld);
   }
 
   if (FinalPhase == phases::Preprocess || Args.hasArg(options::OPT__SLASH_Y_)) {
     // If only preprocessing or /Y- is used, all pch handling is disabled.
     // Rather than check for it everywhere, just remove clang-cl pch-related
     // flags here.
     Args.eraseArg(options::OPT__SLASH_Fp);
case llvm::Triple::Win32:
         break;
       case llvm::Triple::Itanium:
         TC = std::make_unique<toolchains::CrossWindowsToolChain>(*this, Target,
                                                                   Args);
         break;
       case llvm::Triple::MSVC:
       case llvm::Triple::UnknownEnvironment:
         if (Args.getLastArgValue(options::OPT_fuse_ld_EQ)
-                .startswith_lower("bfd"))
+                .startswith_insensitive("bfd"))
           TC = std::make_unique<toolchains::CrossWindowsToolChain>(
               *this, Target, Args);
         else
           TC =
               std::make_unique<toolchains::MSVCToolChain>(*this, Target, Args);
         break;
       }
       break;

clang/lib/Driver/ToolChains/Arch/RISCV.cpp

StringRef riscv::getRISCVABI(const ArgList &Args, const llvm::Triple &Triple) {
   //
   // rv32g | rv32*d -> ilp32d
   // rv32e -> ilp32e
   // rv32* -> ilp32
   // rv64g | rv64*d -> lp64d
   // rv64* -> lp64
   StringRef MArch = getRISCVArch(Args, Triple);
 
-  if (MArch.startswith_lower("rv32")) {
+  if (MArch.startswith_insensitive("rv32")) {
     // FIXME: parse `March` to find `D` extension properly
-    if (MArch.substr(4).contains_lower("d") || MArch.startswith_lower("rv32g"))
+    if (MArch.substr(4).contains_insensitive("d") || MArch.startswith_insensitive("rv32g"))
       return "ilp32d";
-    else if (MArch.startswith_lower("rv32e"))
+    else if (MArch.startswith_insensitive("rv32e"))
       return "ilp32e";
     else
       return "ilp32";
-  } else if (MArch.startswith_lower("rv64")) {
+  } else if (MArch.startswith_insensitive("rv64")) {
     // FIXME: parse `March` to find `D` extension properly
-    if (MArch.substr(4).contains_lower("d") || MArch.startswith_lower("rv64g"))
+    if (MArch.substr(4).contains_insensitive("d") || MArch.startswith_insensitive("rv64g"))
       return "lp64d";
     else
       return "lp64";
   }
 
   // 3. Choose a default based on the triple
   //
   // We deviate from GCC's defaults here:
StringRef riscv::getRISCVArch(const llvm::opt::ArgList &Args,
   // 3. Choose a default based on `-mabi=`
   //
   // ilp32e -> rv32e
   // ilp32 | ilp32f | ilp32d -> rv32imafdc
   // lp64 | lp64f | lp64d -> rv64imafdc
   if (const Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
     StringRef MABI = A->getValue();
 
-    if (MABI.equals_lower("ilp32e"))
+    if (MABI.equals_insensitive("ilp32e"))
       return "rv32e";
-    else if (MABI.startswith_lower("ilp32"))
+    else if (MABI.startswith_insensitive("ilp32"))
       return "rv32imafdc";
-    else if (MABI.startswith_lower("lp64"))
+    else if (MABI.startswith_insensitive("lp64"))
       return "rv64imafdc";
   }
 
   // 4. Choose a default based on the triple
   //
   // We deviate from GCC's defaults here:
   // - On `riscv{XLEN}-unknown-elf` we default to `rv{XLEN}imac`
   // - On all other OSs we use `rv{XLEN}imafdc` (equivalent to `rv{XLEN}gc`)

clang/lib/Driver/ToolChains/Clang.cpp

static void SetRISCVSmallDataLimit(const ToolChain &TC, const ArgList &Args,
   if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
                       options::OPT_fPIC)) {
     // Not support linker relaxation for PIC.
     SmallDataLimit = "0";
     if (Args.hasArg(options::OPT_G)) {
       D.Diag(diag::warn_drv_unsupported_sdata);
     }
   } else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
-                 .equals_lower("large") &&
+                 .equals_insensitive("large") &&
              (Triple.getArch() == llvm::Triple::riscv64)) {
     // Not support linker relaxation for RV64 with large code model.
     SmallDataLimit = "0";
     if (Args.hasArg(options::OPT_G)) {
       D.Diag(diag::warn_drv_unsupported_sdata);
     }
   } else if (Arg *A = Args.getLastArg(options::OPT_G)) {
     SmallDataLimit = A->getValue();

   // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
   if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
     D.Diag(diag::err_drv_clang_unsupported)
         << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
 
   // -finput_charset=UTF-8 is default. Reject others
   if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
     StringRef value = inputCharset->getValue();
-    if (!value.equals_lower("utf-8"))
+    if (!value.equals_insensitive("utf-8"))
       D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
                                           << value;
   }
 
   // -fexec_charset=UTF-8 is default. Reject others
   if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
     StringRef value = execCharset->getValue();
-    if (!value.equals_lower("utf-8"))
+    if (!value.equals_insensitive("utf-8"))
       D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
                                           << value;
   }
 
   RenderDiagnosticsOptions(D, Args, CmdArgs);
 
   // -fno-asm-blocks is default.
   if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
     CmdArgs.push_back("-fdiagnostics-format");
     CmdArgs.push_back("msvc");
   }
 
   if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
     StringRef GuardArgs = A->getValue();
     // The only valid options are "cf", "cf,nochecks", "cf-", "ehcont" and
     // "ehcont-".
-    if (GuardArgs.equals_lower("cf")) {
+    if (GuardArgs.equals_insensitive("cf")) {
       // Emit CFG instrumentation and the table of address-taken functions.
       CmdArgs.push_back("-cfguard");
-    } else if (GuardArgs.equals_lower("cf,nochecks")) {
+    } else if (GuardArgs.equals_insensitive("cf,nochecks")) {
       // Emit only the table of address-taken functions.
       CmdArgs.push_back("-cfguard-no-checks");
-    } else if (GuardArgs.equals_lower("ehcont")) {
+    } else if (GuardArgs.equals_insensitive("ehcont")) {
       // Emit EH continuation table.
       CmdArgs.push_back("-ehcontguard");
-    } else if (GuardArgs.equals_lower("cf-") ||
-               GuardArgs.equals_lower("ehcont-")) {
+    } else if (GuardArgs.equals_insensitive("cf-") ||
+               GuardArgs.equals_insensitive("ehcont-")) {
       // Do nothing, but we might want to emit a security warning in future.
     } else {
       D.Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;
     }
   }
 }
 
 const char *Clang::getBaseInputName(const ArgList &Args,

clang/lib/Driver/ToolChains/Fuchsia.cpp

void fuchsia::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 
   CmdArgs.push_back("-z");
   CmdArgs.push_back("max-page-size=4096");
 
   CmdArgs.push_back("-z");
   CmdArgs.push_back("now");
 
   const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
-  if (llvm::sys::path::filename(Exec).equals_lower("ld.lld") ||
-      llvm::sys::path::stem(Exec).equals_lower("ld.lld")) {
+  if (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") ||
+      llvm::sys::path::stem(Exec).equals_insensitive("ld.lld")) {
     CmdArgs.push_back("-z");
     CmdArgs.push_back("rodynamic");
     CmdArgs.push_back("-z");
     CmdArgs.push_back("separate-loadable-segments");
     CmdArgs.push_back("--pack-dyn-relocs=relr");
   }
 
   if (!D.SysRoot.empty())

clang/lib/Driver/ToolChains/Gnu.cpp

 
 // Switch CPU names not recognized by GNU assembler to a close CPU that it does
 // recognize, instead of a lower march from being picked in the absence of a cpu
 // flag.
 static void normalizeCPUNamesForAssembler(const ArgList &Args,
                                           ArgStringList &CmdArgs) {
   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
     StringRef CPUArg(A->getValue());
-    if (CPUArg.equals_lower("krait"))
+    if (CPUArg.equals_insensitive("krait"))
       CmdArgs.push_back("-mcpu=cortex-a15");
-    else if(CPUArg.equals_lower("kryo"))
+    else if(CPUArg.equals_insensitive("kryo"))
       CmdArgs.push_back("-mcpu=cortex-a57");
     else
       Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
   }
 }
 
 void tools::gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,

clang/lib/Driver/ToolChains/Hexagon.cpp

return llvm::StringSwitch<StringRef>(Cpu)
       .Case("v65", "64b")
       .Default("128b");
 }
 
 static void handleHVXWarnings(const Driver &D, const ArgList &Args) {
   // Handle the unsupported values passed to mhvx-length.
   if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) {
     StringRef Val = A->getValue();
-    if (!Val.equals_lower("64b") && !Val.equals_lower("128b"))
+    if (!Val.equals_insensitive("64b") && !Val.equals_insensitive("128b"))
       D.Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Val;
   }
 }
 
 // Handle hvx target features explicitly.
 static void handleHVXTargetFeatures(const Driver &D, const ArgList &Args,
                                     std::vector<StringRef> &Features,
constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
   bool IsStatic = Args.hasArg(options::OPT_static);
   bool IsShared = Args.hasArg(options::OPT_shared);
   bool IsPIE = Args.hasArg(options::OPT_pie);
   bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
   bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
   bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
   bool UseG0 = false;
   const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
-  bool UseLLD = (llvm::sys::path::filename(Exec).equals_lower("ld.lld") ||
-                 llvm::sys::path::stem(Exec).equals_lower("ld.lld"));
+  bool UseLLD = (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") ||
+                 llvm::sys::path::stem(Exec).equals_insensitive("ld.lld"));
   bool UseShared = IsShared && !IsStatic;
   StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
 
   //----------------------------------------------------------------------------
   // Silence warnings for various options
   //----------------------------------------------------------------------------
   Args.ClaimAllArgs(options::OPT_g_Group);
   Args.ClaimAllArgs(options::OPT_emit_llvm);

clang/lib/Driver/ToolChains/MSVC.cpp

for (llvm::StringRef PathEntry : PathEntries) {
       // has a cl.exe. So let's check for link.exe too.
       ExeTestPath = PathEntry;
       llvm::sys::path::append(ExeTestPath, "link.exe");
       if (!VFS.exists(ExeTestPath))
         continue;
 
       // whatever/VC/bin --> old toolchain, VC dir is toolchain dir.
       llvm::StringRef TestPath = PathEntry;
-      bool IsBin = llvm::sys::path::filename(TestPath).equals_lower("bin");
+      bool IsBin = llvm::sys::path::filename(TestPath).equals_insensitive("bin");
       if (!IsBin) {
         // Strip any architecture subdir like "amd64".
         TestPath = llvm::sys::path::parent_path(TestPath);
-        IsBin = llvm::sys::path::filename(TestPath).equals_lower("bin");
+        IsBin = llvm::sys::path::filename(TestPath).equals_insensitive("bin");
       }
       if (IsBin) {
         llvm::StringRef ParentPath = llvm::sys::path::parent_path(TestPath);
         llvm::StringRef ParentFilename = llvm::sys::path::filename(ParentPath);
-        if (ParentFilename.equals_lower("VC")) {
+        if (ParentFilename.equals_insensitive("VC")) {
           Path = std::string(ParentPath);
           VSLayout = MSVCToolChain::ToolsetLayout::OlderVS;
           return true;
         }
-        if (ParentFilename.equals_lower("x86ret") ||
-            ParentFilename.equals_lower("x86chk") ||
-            ParentFilename.equals_lower("amd64ret") ||
-            ParentFilename.equals_lower("amd64chk")) {
+        if (ParentFilename.equals_insensitive("x86ret") ||
+            ParentFilename.equals_insensitive("x86chk") ||
+            ParentFilename.equals_insensitive("amd64ret") ||
+            ParentFilename.equals_insensitive("amd64chk")) {
           Path = std::string(ParentPath);
           VSLayout = MSVCToolChain::ToolsetLayout::DevDivInternal;
           return true;
         }
 
       } else {
         // This could be a new (>=VS2017) toolchain. If it is, we should find
         // path components with these prefixes when walking backwards through
         // the path.
         // Note: empty strings match anything.
         llvm::StringRef ExpectedPrefixes[] = {"",     "Host",  "bin", "",
                                               "MSVC", "Tools", "VC"};
 
         auto It = llvm::sys::path::rbegin(PathEntry);
         auto End = llvm::sys::path::rend(PathEntry);
         for (llvm::StringRef Prefix : ExpectedPrefixes) {
           if (It == End)
             goto NotAToolChain;
-          if (!It->startswith_lower(Prefix))
+          if (!It->startswith_insensitive(Prefix))
             goto NotAToolChain;
           ++It;
         }
 
         // We've found a new toolchain!
         // Back up 3 times (/bin/Host/arch) to get the root path.
         llvm::StringRef ToolChainPath(PathEntry);
         for (int i = 0; i < 3; ++i)
if (TC.getSanitizerArgs().needsAsanRt()) {
     }
   }
 
   Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
 
   // Control Flow Guard checks
   if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
     StringRef GuardArgs = A->getValue();
-    if (GuardArgs.equals_lower("cf") || GuardArgs.equals_lower("cf,nochecks")) {
+    if (GuardArgs.equals_insensitive("cf") || GuardArgs.equals_insensitive("cf,nochecks")) {
       // MSVC doesn't yet support the "nochecks" modifier.
       CmdArgs.push_back("-guard:cf");
-    } else if (GuardArgs.equals_lower("cf-")) {
+    } else if (GuardArgs.equals_insensitive("cf-")) {
       CmdArgs.push_back("-guard:cf-");
-    } else if (GuardArgs.equals_lower("ehcont")) {
+    } else if (GuardArgs.equals_insensitive("ehcont")) {
       CmdArgs.push_back("-guard:ehcont");
-    } else if (GuardArgs.equals_lower("ehcont-")) {
+    } else if (GuardArgs.equals_insensitive("ehcont-")) {
       CmdArgs.push_back("-guard:ehcont-");
     }
   }
 
   if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
                    options::OPT_fno_openmp, false)) {
     CmdArgs.push_back("-nodefaultlib:vcomp.lib");
     CmdArgs.push_back("-nodefaultlib:vcompd.lib");
void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   // We need to special case some linker paths.  In the case of lld, we need to
   // translate 'lld' into 'lld-link', and in the case of the regular msvc
   // linker, we need to use a special search algorithm.
   llvm::SmallString<128> linkPath;
   StringRef Linker
     = Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER);
   if (Linker.empty())
     Linker = "link";
-  if (Linker.equals_lower("lld"))
+  if (Linker.equals_insensitive("lld"))
     Linker = "lld-link";
 
-  if (Linker.equals_lower("link")) {
+  if (Linker.equals_insensitive("link")) {
     // If we're using the MSVC linker, it's not sufficient to just use link
     // from the program PATH, because other environments like GnuWin32 install
     // their own link.exe which may come first.
     linkPath = FindVisualStudioExecutable(TC, "link.exe");
 
     if (!TC.FoundMSVCInstall() && !canExecute(TC.getVFS(), linkPath)) {
       llvm::SmallString<128> ClPath;
       ClPath = TC.GetProgramPath("cl.exe");
if (TC.getIsVS2017OrNewer() &&
 
       Environment.reserve(EnvCount);
 
       // Now loop over each string in the block and copy them into the
       // environment vector, adjusting the PATH variable as needed when we
       // find it.
       for (const char *Cursor = EnvBlock.data(); *Cursor != '\0';) {
         llvm::StringRef EnvVar(Cursor);
-        if (EnvVar.startswith_lower("path=")) {
+        if (EnvVar.startswith_insensitive("path=")) {
           using SubDirectoryType = toolchains::MSVCToolChain::SubDirectoryType;
           constexpr size_t PrefixLen = 5; // strlen("path=")
           Environment.push_back(Args.MakeArgString(
               EnvVar.substr(0, PrefixLen) +
               TC.getSubDirectoryPath(SubDirectoryType::Bin) +
               llvm::Twine(llvm::sys::EnvPathSeparator) +
               TC.getSubDirectoryPath(SubDirectoryType::Bin, "", HostArch) +
               (EnvVar.size() > PrefixLen

clang/lib/Driver/ToolChains/MinGW.cpp

toolchains::MinGW::MinGW(const Driver &D, const llvm::Triple &Triple,
   getFilePaths().push_back(
       (Base + Arch + llvm::sys::path::get_separator() + "lib").str());
   getFilePaths().push_back(Base + "lib");
   // openSUSE
   getFilePaths().push_back(Base + Arch + "/sys-root/mingw/lib");
 
   NativeLLVMSupport =
       Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER)
-          .equals_lower("lld");
+          .equals_insensitive("lld");
 }
 
 bool toolchains::MinGW::IsIntegratedAssemblerDefault() const { return true; }
 
 Tool *toolchains::MinGW::getTool(Action::ActionClass AC) const {
   switch (AC) {
   case Action::PreprocessJobClass:
     if (!Preprocessor)

clang/lib/Format/Format.cpp

FormatStyle getNoStyle() {
   NoStyle.DisableFormat = true;
   NoStyle.SortIncludes = FormatStyle::SI_Never;
   NoStyle.SortUsingDeclarations = false;
   return NoStyle;
 }
 
 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
                         FormatStyle *Style) {
-  if (Name.equals_lower("llvm")) {
+  if (Name.equals_insensitive("llvm")) {
     *Style = getLLVMStyle(Language);
-  } else if (Name.equals_lower("chromium")) {
+  } else if (Name.equals_insensitive("chromium")) {
     *Style = getChromiumStyle(Language);
-  } else if (Name.equals_lower("mozilla")) {
+  } else if (Name.equals_insensitive("mozilla")) {
     *Style = getMozillaStyle();
-  } else if (Name.equals_lower("google")) {
+  } else if (Name.equals_insensitive("google")) {
     *Style = getGoogleStyle(Language);
-  } else if (Name.equals_lower("webkit")) {
+  } else if (Name.equals_insensitive("webkit")) {
     *Style = getWebKitStyle();
-  } else if (Name.equals_lower("gnu")) {
+  } else if (Name.equals_insensitive("gnu")) {
     *Style = getGNUStyle();
-  } else if (Name.equals_lower("microsoft")) {
+  } else if (Name.equals_insensitive("microsoft")) {
     *Style = getMicrosoftStyle(Language);
-  } else if (Name.equals_lower("none")) {
+  } else if (Name.equals_insensitive("none")) {
     *Style = getNoStyle();
-  } else if (Name.equals_lower("inheritparentconfig")) {
+  } else if (Name.equals_insensitive("inheritparentconfig")) {
     Style->InheritsParentConfig = true;
   } else {
     return false;
   }
 
   Style->Language = Language;
   return true;
 }
const char *StyleOptionHelpDescription =
     "directory for stdin).\n"
     "Use -style=\"{key: value, ...}\" to set specific\n"
     "parameters, e.g.:\n"
     "  -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
 
 static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
   if (FileName.endswith(".java"))
     return FormatStyle::LK_Java;
-  if (FileName.endswith_lower(".js") || FileName.endswith_lower(".mjs") ||
-      FileName.endswith_lower(".ts"))
+  if (FileName.endswith_insensitive(".js") || FileName.endswith_insensitive(".mjs") ||
+      FileName.endswith_insensitive(".ts"))
     return FormatStyle::LK_JavaScript; // (module) JavaScript or TypeScript.
   if (FileName.endswith(".m") || FileName.endswith(".mm"))
     return FormatStyle::LK_ObjC;
-  if (FileName.endswith_lower(".proto") ||
-      FileName.endswith_lower(".protodevel"))
+  if (FileName.endswith_insensitive(".proto") ||
+      FileName.endswith_insensitive(".protodevel"))
     return FormatStyle::LK_Proto;
-  if (FileName.endswith_lower(".textpb") ||
-      FileName.endswith_lower(".pb.txt") ||
-      FileName.endswith_lower(".textproto") ||
-      FileName.endswith_lower(".asciipb"))
+  if (FileName.endswith_insensitive(".textpb") ||
+      FileName.endswith_insensitive(".pb.txt") ||
+      FileName.endswith_insensitive(".textproto") ||
+      FileName.endswith_insensitive(".asciipb"))
     return FormatStyle::LK_TextProto;
-  if (FileName.endswith_lower(".td"))
+  if (FileName.endswith_insensitive(".td"))
     return FormatStyle::LK_TableGen;
-  if (FileName.endswith_lower(".cs"))
+  if (FileName.endswith_insensitive(".cs"))
     return FormatStyle::LK_CSharp;
   return FormatStyle::LK_Cpp;
 }
 
 FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code) {
   const auto GuessedLanguage = getLanguageByFileName(FileName);
   if (GuessedLanguage == FormatStyle::LK_Cpp) {
     auto Extension = llvm::sys::path::extension(FileName);
if (Style.InheritsParentConfig)
           llvm::MemoryBuffer::getMemBuffer(StyleName, Source, false));
     else
       return Style;
   }
 
   // If the style inherits the parent configuration it is a command line
   // configuration, which wants to inherit, so we have to skip the check of the
   // StyleName.
-  if (!Style.InheritsParentConfig && !StyleName.equals_lower("file")) {
+  if (!Style.InheritsParentConfig && !StyleName.equals_insensitive("file")) {
     if (!getPredefinedStyle(StyleName, Style.Language, &Style))
       return make_string_error("Invalid value for -style");
     if (!Style.InheritsParentConfig)
       return Style;
   }
 
   // Reset possible inheritance
   Style.InheritsParentConfig = false;
if (!ChildFormatTextToApply.empty()) {
     static_cast<void>(Ec);
   }
 
   return FallbackStyle;
 }
 
 } // namespace format
 } // namespace clang
 No newline at end of file

clang/lib/Format/SortJavaScriptImports.cpp

bool operator<(const JsModuleReference &LHS, const JsModuleReference &RHS) {
   if (LHS.Category == JsModuleReference::ReferenceCategory::SIDE_EFFECT)
     // Side effect imports might be ordering sensitive. Consider them equal so
     // that they maintain their relative order in the stable sort below.
     // This retains transitivity because LHS.Category == RHS.Category here.
     return false;
   // Empty URLs sort *last* (for export {...};).
   if (LHS.URL.empty() != RHS.URL.empty())
     return LHS.URL.empty() < RHS.URL.empty();
-  if (int Res = LHS.URL.compare_lower(RHS.URL))
+  if (int Res = LHS.URL.compare_insensitive(RHS.URL))
     return Res < 0;
   // '*' imports (with prefix) sort before {a, b, ...} imports.
   if (LHS.Prefix.empty() != RHS.Prefix.empty())
     return LHS.Prefix.empty() < RHS.Prefix.empty();
   if (LHS.Prefix != RHS.Prefix)
     return LHS.Prefix > RHS.Prefix;
   return false;
 }
if (Reference.FormattingOff) {
           getSourceText(Reference.Range.getBegin(), Reference.Range.getEnd());
       return;
     }
     // Sort the individual symbols within the import.
     // E.g. `import {b, a} from 'x';` -> `import {a, b} from 'x';`
     SmallVector<JsImportedSymbol, 1> Symbols = Reference.Symbols;
     llvm::stable_sort(
         Symbols, [&](const JsImportedSymbol &LHS, const JsImportedSymbol &RHS) {
-          return LHS.Symbol.compare_lower(RHS.Symbol) < 0;
+          return LHS.Symbol.compare_insensitive(RHS.Symbol) < 0;
         });
     if (!Reference.SymbolsMerged && Symbols == Reference.Symbols) {
       // Symbols didn't change, just emit the entire module reference.
       StringRef ReferenceStmt = getSourceText(Reference.Range);
       Buffer += ReferenceStmt;
       return;
     }
     // Stitch together the module reference start...

clang/lib/Format/UsingDeclarationsSorter.cpp

for (size_t I = 0, E = std::min(SizeA, SizeB); I < E; ++I) {
     if (I + 1 == SizeA) {
       // I is the last index of NamesA and NamesA[I] is a non-namespace name.
 
       // Non-namespace names come before all namespace names.
       if (SizeB > SizeA)
         return -1;
 
       // Two names within a group compare case-insensitively.
-      return NamesA[I].compare_lower(NamesB[I]);
+      return NamesA[I].compare_insensitive(NamesB[I]);
     }
 
     // I is the last index of NamesB and NamesB[I] is a non-namespace name.
     // Non-namespace names come before all namespace names.
     if (I + 1 == SizeB)
       return 1;
 
     // Two namespaces names within a group compare case-insensitively.
-    int C = NamesA[I].compare_lower(NamesB[I]);
+    int C = NamesA[I].compare_insensitive(NamesB[I]);
     if (C != 0)
       return C;
   }
   return 0;
 }
 
 struct UsingDeclaration {
   const AnnotatedLine *Line;

clang/lib/Frontend/CompilerInvocation.cpp

if (!VerParts.first.startswith("0") &&
       Diags.Report(diag::err_drv_invalid_value)
           << A->getAsString(Args) << A->getValue();
     }
   }
 
   if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
     StringRef SignScope = A->getValue();
 
-    if (SignScope.equals_lower("none"))
+    if (SignScope.equals_insensitive("none"))
       Opts.setSignReturnAddressScope(
           LangOptions::SignReturnAddressScopeKind::None);
-    else if (SignScope.equals_lower("all"))
+    else if (SignScope.equals_insensitive("all"))
       Opts.setSignReturnAddressScope(
           LangOptions::SignReturnAddressScopeKind::All);
-    else if (SignScope.equals_lower("non-leaf"))
+    else if (SignScope.equals_insensitive("non-leaf"))
       Opts.setSignReturnAddressScope(
           LangOptions::SignReturnAddressScopeKind::NonLeaf);
     else
       Diags.Report(diag::err_drv_invalid_value)
           << A->getAsString(Args) << SignScope;
 
     if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
       StringRef SignKey = A->getValue();
       if (!SignScope.empty() && !SignKey.empty()) {
-        if (SignKey.equals_lower("a_key"))
+        if (SignKey.equals_insensitive("a_key"))
           Opts.setSignReturnAddressKey(
               LangOptions::SignReturnAddressKeyKind::AKey);
-        else if (SignKey.equals_lower("b_key"))
+        else if (SignKey.equals_insensitive("b_key"))
           Opts.setSignReturnAddressKey(
               LangOptions::SignReturnAddressKeyKind::BKey);
         else
           Diags.Report(diag::err_drv_invalid_value)
               << A->getAsString(Args) << SignKey;
       }
     }
   }

clang/lib/Lex/HeaderMap.cpp

StringRef HeaderMapImpl::lookupFilename(StringRef Filename,
   for (unsigned Bucket = HashHMapKey(Filename);; ++Bucket) {
     HMapBucket B = getBucket(Bucket & (NumBuckets-1));
     if (B.Key == HMAP_EmptyBucketKey) return StringRef(); // Hash miss.
 
     // See if the key matches.  If not, probe on.
     Optional<StringRef> Key = getString(B.Key);
     if (LLVM_UNLIKELY(!Key))
       continue;
-    if (!Filename.equals_lower(*Key))
+    if (!Filename.equals_insensitive(*Key))
       continue;
 
     // If so, we have a match in the hash table.  Construct the destination
     // path.
     Optional<StringRef> Prefix = getString(B.Prefix);
     Optional<StringRef> Suffix = getString(B.Suffix);
 
     DestPath.clear();

clang/lib/Lex/PPDirectives.cpp

 // Return true if we want to issue a diagnostic by default if we
 // encounter this name in a #include with the wrong case. For now,
 // this includes the standard C and C++ headers, Posix headers,
 // and Boost headers. Improper case for these #includes is a
 // potential portability issue.
 static bool warnByDefaultOnWrongCase(StringRef Include) {
   // If the first component of the path is "boost", treat this like a standard header
   // for the purposes of diagnostics.
-  if (::llvm::sys::path::begin(Include)->equals_lower("boost"))
+  if (::llvm::sys::path::begin(Include)->equals_insensitive("boost"))
     return true;
 
   // "condition_variable" is the longest standard header name at 18 characters.
   // If the include file name is longer than that, it can't be a standard header.
   static const size_t MaxStdHeaderNameLen = 18u;
   if (Include.size() > MaxStdHeaderNameLen)
     return false;
 
if ("." == Component) {
       ++Cnt;
     } else if (Cnt) {
       --Cnt;
     } else if (RealPathComponentIter != RealPathComponentEnd) {
       if (Component != *RealPathComponentIter) {
         // If these path components differ by more than just case, then we
         // may be looking at symlinked paths. Bail on this diagnostic to avoid
         // noisy false positives.
-        SuggestReplacement = RealPathComponentIter->equals_lower(Component);
+        SuggestReplacement = RealPathComponentIter->equals_insensitive(Component);
         if (!SuggestReplacement)
           break;
         Component = *RealPathComponentIter;
       }
       ++RealPathComponentIter;
     }
   }
   return SuggestReplacement;

clang/lib/Lex/PPMacroExpansion.cpp

return (Arch.getSubArch() == llvm::Triple::NoSubArch ||
          Arch.getArch() == TT.getArch();
 }
 
 /// Implements the __is_target_vendor builtin macro.
 static bool isTargetVendor(const TargetInfo &TI, const IdentifierInfo *II) {
   StringRef VendorName = TI.getTriple().getVendorName();
   if (VendorName.empty())
     VendorName = "unknown";
-  return VendorName.equals_lower(II->getName());
+  return VendorName.equals_insensitive(II->getName());
 }
 
 /// Implements the __is_target_os builtin macro.
 static bool isTargetOS(const TargetInfo &TI, const IdentifierInfo *II) {
   std::string OSName =
       (llvm::Twine("unknown-unknown-") + II->getName().lower()).str();
   llvm::Triple OS(OSName);
   if (OS.getOS() == llvm::Triple::Darwin) {

clang/lib/Sema/CodeCompleteConsumer.cpp

StringRef CodeCompletionResult::getOrderedName(std::string &Saved) const {
   return Saved;
 }
 
 bool clang::operator<(const CodeCompletionResult &X,
                       const CodeCompletionResult &Y) {
   std::string XSaved, YSaved;
   StringRef XStr = X.getOrderedName(XSaved);
   StringRef YStr = Y.getOrderedName(YSaved);
-  int cmp = XStr.compare_lower(YStr);
+  int cmp = XStr.compare_insensitive(YStr);
   if (cmp)
     return cmp < 0;
 
   // If case-insensitive comparison fails, try case-sensitive comparison.
   return XStr.compare(YStr) < 0;
 }

clang/lib/Sema/SemaChecking.cpp

bool Sema::SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
   // valid here but if the string is of one the forms described in ACLE then we
   // can check that the supplied fields are integers and within the valid
   // ranges.
   if (Fields.size() > 1) {
     bool FiveFields = Fields.size() == 5;
 
     bool ValidString = true;
     if (IsARMBuiltin) {
-      ValidString &= Fields[0].startswith_lower("cp") ||
-                     Fields[0].startswith_lower("p");
+      ValidString &= Fields[0].startswith_insensitive("cp") ||
+                     Fields[0].startswith_insensitive("p");
       if (ValidString)
         Fields[0] =
-          Fields[0].drop_front(Fields[0].startswith_lower("cp") ? 2 : 1);
+          Fields[0].drop_front(Fields[0].startswith_insensitive("cp") ? 2 : 1);
 
-      ValidString &= Fields[2].startswith_lower("c");
+      ValidString &= Fields[2].startswith_insensitive("c");
       if (ValidString)
         Fields[2] = Fields[2].drop_front(1);
 
       if (FiveFields) {
-        ValidString &= Fields[3].startswith_lower("c");
+        ValidString &= Fields[3].startswith_insensitive("c");
         if (ValidString)
           Fields[3] = Fields[3].drop_front(1);
       }
     }
 
     SmallVector<int, 5> Ranges;
     if (FiveFields)
       Ranges.append({IsAArch64Builtin ? 1 : 15, 7, 15, 15, 7});

clang/lib/Sema/SemaCodeComplete.cpp

for (auto It = FS.dir_begin(Dir, EC);
           break;
 
         AddCompletion(Filename, /*IsDirectory=*/true);
         break;
       case llvm::sys::fs::file_type::regular_file:
         // Only files that really look like headers. (Except in system dirs).
         if (!IsSystem) {
           // Header extensions from Types.def, which we can't depend on here.
-          if (!(Filename.endswith_lower(".h") ||
-                Filename.endswith_lower(".hh") ||
-                Filename.endswith_lower(".hpp") ||
-                Filename.endswith_lower(".inc")))
+          if (!(Filename.endswith_insensitive(".h") ||
+                Filename.endswith_insensitive(".hh") ||
+                Filename.endswith_insensitive(".hpp") ||
+                Filename.endswith_insensitive(".inc")))
             break;
         }
         AddCompletion(Filename, /*IsDirectory=*/false);
         break;
       default:
         break;
       }
     }

clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp

if (canComputeResult) {
       if (s1Term != StringRef::npos)
         LeftStrRef = LeftStrRef.substr(0, s1Term);
 
       size_t s2Term = RightStrRef.find('\0');
       if (s2Term != StringRef::npos)
         RightStrRef = RightStrRef.substr(0, s2Term);
 
       // Use StringRef's comparison methods to compute the actual result.
-      int compareRes = IgnoreCase ? LeftStrRef.compare_lower(RightStrRef)
+      int compareRes = IgnoreCase ? LeftStrRef.compare_insensitive(RightStrRef)
                                   : LeftStrRef.compare(RightStrRef);
 
       // The strcmp function returns an integer greater than, equal to, or less
       // than zero, [c11, p7.24.4.2].
       if (compareRes == 0) {
         resultVal = svalBuilder.makeIntVal(compareRes, CE->getType());
       }
       else {

clang/lib/StaticAnalyzer/Checkers/ContainerModeling.cpp

 }
 
 namespace {
 
 bool isBeginCall(const FunctionDecl *Func) {
   const auto *IdInfo = Func->getIdentifier();
   if (!IdInfo)
     return false;
-  return IdInfo->getName().endswith_lower("begin");
+  return IdInfo->getName().endswith_insensitive("begin");
 }
 
 bool isEndCall(const FunctionDecl *Func) {
   const auto *IdInfo = Func->getIdentifier();
   if (!IdInfo)
     return false;
-  return IdInfo->getName().endswith_lower("end");
+  return IdInfo->getName().endswith_insensitive("end");
 }
 
 const CXXRecordDecl *getCXXRecordDecl(ProgramStateRef State,
                                       const MemRegion *Reg) {
   auto TI = getDynamicTypeInfo(State, Reg);
   if (!TI.isValid())
     return nullptr;
 

clang/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp

if (const auto* ND = dyn_cast<NamedDecl>(D)) {
     std::string DeclName = ND->getNameAsString();
     if (StringRef(DeclName).startswith("test"))
       return true;
   }
   if (const auto *OD = dyn_cast<ObjCMethodDecl>(D)) {
     if (const auto *CD = dyn_cast<ObjCContainerDecl>(OD->getParent())) {
       std::string ContainerName = CD->getNameAsString();
       StringRef CN(ContainerName);
-      if (CN.contains_lower("test") || CN.contains_lower("mock"))
+      if (CN.contains_insensitive("test") || CN.contains_insensitive("mock"))
         return true;
     }
   }
   return false;
 }
 
 static auto findGCDAntiPatternWithSemaphore() -> decltype(compoundStmt()) {
 

clang/lib/StaticAnalyzer/Checkers/Iterator.cpp

bool isIteratorType(const QualType &Type) {
   return isIterator(CRD);
 }
 
 bool isIterator(const CXXRecordDecl *CRD) {
   if (!CRD)
     return false;
 
   const auto Name = CRD->getName();
-  if (!(Name.endswith_lower("iterator") || Name.endswith_lower("iter") ||
-        Name.endswith_lower("it")))
+  if (!(Name.endswith_insensitive("iterator") || Name.endswith_insensitive("iter") ||
+        Name.endswith_insensitive("it")))
     return false;
 
   bool HasCopyCtor = false, HasCopyAssign = true, HasDtor = false,
        HasPreIncrOp = false, HasPostIncrOp = false, HasDerefOp = false;
   for (const auto *Method : CRD->methods()) {
     if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Method)) {
       if (Ctor->isCopyConstructor()) {
         HasCopyCtor = !Ctor->isDeleted() && Ctor->getAccess() == AS_public;

clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp

static SymbolRef findFailedReallocSymbol(ProgramStateRef currState,
   }
 
   return nullptr;
 }
 
 static bool isReferenceCountingPointerDestructor(const CXXDestructorDecl *DD) {
   if (const IdentifierInfo *II = DD->getParent()->getIdentifier()) {
     StringRef N = II->getName();
-    if (N.contains_lower("ptr") || N.contains_lower("pointer")) {
-      if (N.contains_lower("ref") || N.contains_lower("cnt") ||
-          N.contains_lower("intrusive") || N.contains_lower("shared")) {
+    if (N.contains_insensitive("ptr") || N.contains_insensitive("pointer")) {
+      if (N.contains_insensitive("ref") || N.contains_insensitive("cnt") ||
+          N.contains_insensitive("intrusive") || N.contains_insensitive("shared")) {
         return true;
       }
     }
   }
   return false;
 }
 
 PathDiagnosticPieceRef MallocBugVisitor::VisitNode(const ExplodedNode *N,

clang/lib/Tooling/Inclusions/HeaderIncludes.cpp

bool IncludeCategoryManager::isMainHeader(StringRef IncludeName) const {
   //  1) foo.h => foo.cc
   //  2) foo.h => foo.cu.cc
   //  3) foo.proto.h => foo.proto.cc
   //
   // non-main-header examples:
   //  1) foo.h => bar.cc
   //  2) foo.proto.h => foo.cc
   StringRef Matching;
-  if (MatchingFileStem.startswith_lower(HeaderStem))
+  if (MatchingFileStem.startswith_insensitive(HeaderStem))
     Matching = MatchingFileStem; // example 1), 2)
-  else if (FileStem.equals_lower(HeaderStem))
+  else if (FileStem.equals_insensitive(HeaderStem))
     Matching = FileStem; // example 3)
   if (!Matching.empty()) {
     llvm::Regex MainIncludeRegex(HeaderStem.str() + Style.IncludeIsMainRegex,
                                  llvm::Regex::IgnoreCase);
     if (MainIncludeRegex.match(Matching))
       return true;
   }
   return false;

clang/lib/Tooling/InterpolatingCompilationDatabase.cpp

static bool checkIsCLMode(ArrayRef<std::string> CmdLine) {
     // First look for --driver-mode.
     for (StringRef S : llvm::reverse(CmdLine)) {
       if (S.consume_front("--driver-mode="))
         return S == "cl";
     }
 
     // Otherwise just check the clang executable file name.
     return !CmdLine.empty() &&
-           llvm::sys::path::stem(CmdLine.front()).endswith_lower("cl");
+           llvm::sys::path::stem(CmdLine.front()).endswith_insensitive("cl");
   }
 
   // Map the language from the --std flag to that of the -x flag.
   static types::ID toType(Language Lang) {
     switch (Lang) {
     case Language::C:
       return types::TY_C;
     case Language::CXX:

clang/tools/clang-refactor/TestSupport.cpp

for (Lex.LexFromRawLexer(Tok); Tok.isNot(tok::eof);
     if (Tok.isNot(tok::comment))
       continue;
     StringRef Comment =
         Source.substr(Tok.getLocation().getRawEncoding(), Tok.getLength());
     SmallVector<StringRef, 4> Matches;
     // Try to detect mistyped 'range:' comments to ensure tests don't miss
     // anything.
     auto DetectMistypedCommand = [&]() -> bool {
-      if (Comment.contains_lower("range") && Comment.contains("=") &&
-          !Comment.contains_lower("run") && !Comment.contains("CHECK")) {
+      if (Comment.contains_insensitive("range") && Comment.contains("=") &&
+          !Comment.contains_insensitive("run") && !Comment.contains("CHECK")) {
         llvm::errs() << "error: suspicious comment '" << Comment
                      << "' that "
                         "resembles the range command found\n";
         llvm::errs() << "note: please reword if this isn't a range command\n";
       }
       return false;
     };
     // Allow CHECK: comments to contain range= commands.

clang/tools/clang-scan-deps/ClangScanDeps.cpp

AdjustingCompilations->appendArgumentsAdjuster(
       [&ResourceDirCache](const tooling::CommandLineArguments &Args,
                           StringRef FileName) {
         std::string LastO = "";
         bool HasResourceDir = false;
         bool ClangCLMode = false;
         auto FlagsEnd = llvm::find(Args, "--");
         if (FlagsEnd != Args.begin()) {
           ClangCLMode =
-              llvm::sys::path::stem(Args[0]).contains_lower("clang-cl") ||
+              llvm::sys::path::stem(Args[0]).contains_insensitive("clang-cl") ||
               llvm::is_contained(Args, "--driver-mode=cl");
 
           // Reverse scan, starting at the end or at the element before "--".
           auto R = llvm::make_reverse_iterator(FlagsEnd);
           for (auto I = R, E = Args.rend(); I != E; ++I) {
             StringRef Arg = *I;
             if (ClangCLMode) {
               // Ignore arguments that are preceded by "-Xclang".

clang/tools/driver/driver.cpp

TheDriver.CCPrintProcessStats =
                   TheDriver.CCPrintStatReportFilename);
 }
 
 static void FixupDiagPrefixExeName(TextDiagnosticPrinter *DiagClient,
                                    const std::string &Path) {
   // If the clang binary happens to be named cl.exe for compatibility reasons,
   // use clang-cl.exe as the prefix to avoid confusion between clang and MSVC.
   StringRef ExeBasename(llvm::sys::path::stem(Path));
-  if (ExeBasename.equals_lower("cl"))
+  if (ExeBasename.equals_insensitive("cl"))
     ExeBasename = "clang-cl";
   DiagClient->setPrefix(std::string(ExeBasename));
 }
 
 // This lets us create the DiagnosticsEngine with a properly-filled-out
 // DiagnosticOptions instance.
 static DiagnosticOptions *
 CreateAndPopulateDiagOpts(ArrayRef<const char *> argv, bool &UseNewCC1Process) {

clang/tools/libclang/CIndexCodeCompletion.cpp

bool operator()(const CXCompletionResult &XR,
 
       SmallString<256> XBuffer;
       StringRef XText = GetTypedName(X, XBuffer);
       SmallString<256> YBuffer;
       StringRef YText = GetTypedName(Y, YBuffer);
       
       if (XText.empty() || YText.empty())
         return !XText.empty();
             
-      int result = XText.compare_lower(YText);
+      int result = XText.compare_insensitive(YText);
       if (result < 0)
         return true;
       if (result > 0)
         return false;
       
       result = XText.compare(YText);
       return result < 0;
     }
   };
 }
 
 void clang_sortCodeCompletionResults(CXCompletionResult *Results,
                                      unsigned NumResults) {
   std::stable_sort(Results, Results + NumResults, OrderCompletionResults());
 }

clang/unittests/Tooling/CompilationDatabaseTest.cpp

TEST(JSONCompilationDatabase, ArgumentsPreferredOverCommand) {
    EXPECT_EQ(Directory, FoundCommand.Directory) << ErrorMessage;
    EXPECT_EQ(1u, FoundCommand.CommandLine.size()) << ErrorMessage;
    EXPECT_EQ(Arguments, FoundCommand.CommandLine[0]) << ErrorMessage;
 }
 
 struct FakeComparator : public PathComparator {
   ~FakeComparator() override {}
   bool equivalent(StringRef FileA, StringRef FileB) const override {
-    return FileA.equals_lower(FileB);
+    return FileA.equals_insensitive(FileB);
   }
 };
 
 class FileMatchTrieTest : public ::testing::Test {
 protected:
   FileMatchTrieTest() : Trie(new FakeComparator()) {}
 
   StringRef find(StringRef Path) {

lld/COFF/DebugTypes.cpp

Error UseTypeServerSource::mergeDebugT(TypeMerger *m) {
   // Reuse the type index map of the type server.
   tpiMap = (*tsSrc)->tpiMap;
   ipiMap = (*tsSrc)->ipiMap;
   return Error::success();
 }
 
 static bool equalsPath(StringRef path1, StringRef path2) {
 #if defined(_WIN32)
-  return path1.equals_lower(path2);
+  return path1.equals_insensitive(path2);
 #else
   return path1.equals(path2);
 #endif
 }
 
 // Find by name an OBJ provided on the command line
 static PrecompSource *findObjByName(StringRef fileNameOnly) {
   SmallString<128> currentPath;

lld/COFF/Driver.cpp

case file_magic::coff_import_library:
     break;
   case file_magic::pdb:
     symtab->addFile(make<PDBInputFile>(mbref));
     break;
   case file_magic::coff_cl_gl_object:
     error(filename + ": is not a native COFF file. Recompile without /GL");
     break;
   case file_magic::pecoff_executable:
-    if (filename.endswith_lower(".dll")) {
+    if (filename.endswith_insensitive(".dll")) {
       error(filename + ": bad file type. Did you specify a DLL instead of an "
                        "import library?");
       break;
     }
     LLVM_FALLTHROUGH;
   default:
     error(mbref.getBufferIdentifier() + ": unknown file type");
     break;
Optional<StringRef> LinkerDriver::findFile(StringRef filename) {
   StringRef path = doFindFile(filename);
 
   if (Optional<sys::fs::UniqueID> id = getUniqueID(path)) {
     bool seen = !visitedFiles.insert(*id).second;
     if (seen)
       return None;
   }
 
-  if (path.endswith_lower(".lib"))
+  if (path.endswith_insensitive(".lib"))
     visitedLibs.insert(std::string(sys::path::filename(path)));
   return path;
 }
 
 // MinGW specific. If an embedded directive specified to link to
 // foo.lib, but it isn't found, try libfoo.a instead.
 StringRef LinkerDriver::doFindLibMinGW(StringRef filename) {
   if (filename.contains('/') || filename.contains('\\'))
if ((firstMark = altPath.find('%', cursor)) == StringRef::npos ||
       buf.append(altPath.substr(cursor));
       break;
     }
 
     // Found a full fragment. Append text in front of first %, and interpret
     // text between first and second % as variable name.
     buf.append(altPath.substr(cursor, firstMark - cursor));
     StringRef var = altPath.substr(firstMark, secondMark - firstMark + 1);
-    if (var.equals_lower("%_pdb%"))
+    if (var.equals_insensitive("%_pdb%"))
       buf.append(pdbBasename);
-    else if (var.equals_lower("%_ext%"))
+    else if (var.equals_insensitive("%_ext%"))
       buf.append(binaryExtension);
     else {
       warn("only %_PDB% and %_EXT% supported in /pdbaltpath:, keeping " +
            var + " as literal");
       buf.append(var);
     }
 
     cursor = secondMark + 1;
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   InitializeAllTargetInfos();
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
   InitializeAllAsmPrinters();
 
   // If the first command line argument is "/lib", link.exe acts like lib.exe.
   // We call our own implementation of lib.exe that understands bitcode files.
-  if (argsArr.size() > 1 && (StringRef(argsArr[1]).equals_lower("/lib") ||
-                             StringRef(argsArr[1]).equals_lower("-lib"))) {
+  if (argsArr.size() > 1 && (StringRef(argsArr[1]).equals_insensitive("/lib") ||
+                             StringRef(argsArr[1]).equals_insensitive("-lib"))) {
     if (llvm::libDriverMain(argsArr.slice(1)) != 0)
       fatal("lib failed");
     return;
   }
 
   // Parse command line options.
   ArgParser parser;
   opt::InputArgList args = parser.parse(argsArr);

lld/COFF/DriverUtils.cpp

void parseVersion(StringRef arg, uint32_t *major, uint32_t *minor) {
   if (!s2.empty() && s2.getAsInteger(10, *minor))
     fatal("invalid number: " + s2);
 }
 
 void parseGuard(StringRef fullArg) {
   SmallVector<StringRef, 1> splitArgs;
   fullArg.split(splitArgs, ",");
   for (StringRef arg : splitArgs) {
-    if (arg.equals_lower("no"))
+    if (arg.equals_insensitive("no"))
       config->guardCF = GuardCFLevel::Off;
-    else if (arg.equals_lower("nolongjmp"))
+    else if (arg.equals_insensitive("nolongjmp"))
       config->guardCF &= ~GuardCFLevel::LongJmp;
-    else if (arg.equals_lower("noehcont"))
+    else if (arg.equals_insensitive("noehcont"))
       config->guardCF &= ~GuardCFLevel::EHCont;
-    else if (arg.equals_lower("cf"))
+    else if (arg.equals_insensitive("cf"))
       config->guardCF = GuardCFLevel::CF;
-    else if (arg.equals_lower("longjmp"))
+    else if (arg.equals_insensitive("longjmp"))
       config->guardCF |= GuardCFLevel::CF | GuardCFLevel::LongJmp;
-    else if (arg.equals_lower("ehcont"))
+    else if (arg.equals_insensitive("ehcont"))
       config->guardCF |= GuardCFLevel::CF | GuardCFLevel::EHCont;
     else
       fatal("invalid argument to /guard: " + arg);
   }
 }
 
 // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
 void parseSubsystem(StringRef arg, WindowsSubsystem *sys, uint32_t *major,
void parseFunctionPadMin(llvm::opt::Arg *a, llvm::COFF::MachineTypes machine) {
   } else {
     error("/functionpadmin: invalid argument for this machine: " + arg);
   }
 }
 
 // Parses a string in the form of "EMBED[,=<integer>]|NO".
 // Results are directly written to Config.
 void parseManifest(StringRef arg) {
-  if (arg.equals_lower("no")) {
+  if (arg.equals_insensitive("no")) {
     config->manifest = Configuration::No;
     return;
   }
-  if (!arg.startswith_lower("embed"))
+  if (!arg.startswith_insensitive("embed"))
     fatal("invalid option " + arg);
   config->manifest = Configuration::Embed;
   arg = arg.substr(strlen("embed"));
   if (arg.empty())
     return;
-  if (!arg.startswith_lower(",id="))
+  if (!arg.startswith_insensitive(",id="))
     fatal("invalid option " + arg);
   arg = arg.substr(strlen(",id="));
   if (arg.getAsInteger(0, config->manifestID))
     fatal("invalid option " + arg);
 }
 
 // Parses a string in the form of "level=<string>|uiAccess=<string>|NO".
 // Results are directly written to Config.
 void parseManifestUAC(StringRef arg) {
-  if (arg.equals_lower("no")) {
+  if (arg.equals_insensitive("no")) {
     config->manifestUAC = false;
     return;
   }
   for (;;) {
     arg = arg.ltrim();
     if (arg.empty())
       return;
-    if (arg.startswith_lower("level=")) {
+    if (arg.startswith_insensitive("level=")) {
       arg = arg.substr(strlen("level="));
       std::tie(config->manifestLevel, arg) = arg.split(" ");
       continue;
     }
-    if (arg.startswith_lower("uiaccess=")) {
+    if (arg.startswith_insensitive("uiaccess=")) {
       arg = arg.substr(strlen("uiaccess="));
       std::tie(config->manifestUIAccess, arg) = arg.split(" ");
       continue;
     }
     fatal("invalid option " + arg);
   }
 }
 
 // Parses a string in the form of "cd|net[,(cd|net)]*"
 // Results are directly written to Config.
 void parseSwaprun(StringRef arg) {
   do {
     StringRef swaprun, newArg;
     std::tie(swaprun, newArg) = arg.split(',');
-    if (swaprun.equals_lower("cd"))
+    if (swaprun.equals_insensitive("cd"))
       config->swaprunCD = true;
-    else if (swaprun.equals_lower("net"))
+    else if (swaprun.equals_insensitive("net"))
       config->swaprunNet = true;
     else if (swaprun.empty())
       error("/swaprun: missing argument");
     else
       error("/swaprun: invalid argument: " + swaprun);
     // To catch trailing commas, e.g. `/spawrun:cd,`
     if (newArg.empty() && arg.endswith(","))
       error("/swaprun: missing argument");
if (e.name.contains('=')) {
     if (e.name.empty())
       goto err;
   }
 
   // If "<name>=<internalname>[,@ordinal[,NONAME]][,DATA][,PRIVATE]"
   while (!rest.empty()) {
     StringRef tok;
     std::tie(tok, rest) = rest.split(",");
-    if (tok.equals_lower("noname")) {
+    if (tok.equals_insensitive("noname")) {
       if (e.ordinal == 0)
         goto err;
       e.noname = true;
       continue;
     }
-    if (tok.equals_lower("data")) {
+    if (tok.equals_insensitive("data")) {
       e.data = true;
       continue;
     }
-    if (tok.equals_lower("constant")) {
+    if (tok.equals_insensitive("constant")) {
       e.constant = true;
       continue;
     }
-    if (tok.equals_lower("private")) {
+    if (tok.equals_insensitive("private")) {
       e.isPrivate = true;
       continue;
     }
     if (tok.startswith("@")) {
       int32_t ord;
       if (tok.substr(1).getAsInteger(0, ord))
         goto err;
       if (ord <= 0 || 65535 < ord)
ParsedDirectives ArgParser::parseDirectives(StringRef s) {
   ParsedDirectives result;
   SmallVector<const char *, 16> rest;
 
   // Handle /EXPORT and /INCLUDE in a fast path. These directives can appear for
   // potentially every symbol in the object, so they must be handled quickly.
   SmallVector<StringRef, 16> tokens;
   cl::TokenizeWindowsCommandLineNoCopy(s, saver, tokens);
   for (StringRef tok : tokens) {
-    if (tok.startswith_lower("/export:") || tok.startswith_lower("-export:"))
+    if (tok.startswith_insensitive("/export:") || tok.startswith_insensitive("-export:"))
       result.exports.push_back(tok.substr(strlen("/export:")));
-    else if (tok.startswith_lower("/include:") ||
-             tok.startswith_lower("-include:"))
+    else if (tok.startswith_insensitive("/include:") ||
+             tok.startswith_insensitive("-include:"))
       result.includes.push_back(tok.substr(strlen("/include:")));
     else {
       // Copy substrings that are not valid C strings. The tokenizer may have
       // already copied quoted arguments for us, so those do not need to be
       // copied again.
       bool HasNul = tok.end() != s.end() && tok.data()[tok.size()] == '\0';
       rest.push_back(HasNul ? tok.data() : saver.save(tok).data());
     }

lld/Common/Args.cpp

for (StringRef s : arr) {
     s = s.trim();
     if (!s.empty() && s[0] != '#')
       ret.push_back(s);
   }
   return ret;
 }
 
 StringRef lld::args::getFilenameWithoutExe(StringRef path) {
-  if (path.endswith_lower(".exe"))
+  if (path.endswith_insensitive(".exe"))
     return sys::path::stem(path);
   return sys::path::filename(path);
 }

lld/ELF/Relocations.cpp

for (size_t i = 0, e = name.size(); i != e + 1; ++i) {
     // Delete name[i].
     newName = (name.substr(0, i) + name.substr(i + 1)).str();
     if (const Symbol *s = suggest(newName))
       return s;
   }
 
   // Case mismatch, e.g. Foo vs FOO.
   for (auto &it : map)
-    if (name.equals_lower(it.first))
+    if (name.equals_insensitive(it.first))
       return it.second;
   for (Symbol *sym : symtab->symbols())
-    if (!sym->isUndefined() && name.equals_lower(sym->getName()))
+    if (!sym->isUndefined() && name.equals_insensitive(sym->getName()))
       return sym;
 
   // The reference may be a mangled name while the definition is not. Suggest a
   // missing extern "C".
   if (name.startswith("_Z")) {
     std::string buf = name.str();
     llvm::ItaniumPartialDemangler d;
     if (!d.partialDemangle(buf.c_str()))

lld/ELF/ScriptParser.cpp

 }
 
 // Parses Tok as an integer. It recognizes hexadecimal (prefixed with
 // "0x" or suffixed with "H") and decimal numbers. Decimal numbers may
 // have "K" (Ki) or "M" (Mi) suffixes.
 static Optional<uint64_t> parseInt(StringRef tok) {
   // Hexadecimal
   uint64_t val;
-  if (tok.startswith_lower("0x")) {
+  if (tok.startswith_insensitive("0x")) {
     if (!to_integer(tok.substr(2), val, 16))
       return None;
     return val;
   }
-  if (tok.endswith_lower("H")) {
+  if (tok.endswith_insensitive("H")) {
     if (!to_integer(tok.drop_back(), val, 16))
       return None;
     return val;
   }
 
   // Decimal
-  if (tok.endswith_lower("K")) {
+  if (tok.endswith_insensitive("K")) {
     if (!to_integer(tok.drop_back(), val, 10))
       return None;
     return val * 1024;
   }
-  if (tok.endswith_lower("M")) {
+  if (tok.endswith_insensitive("M")) {
     if (!to_integer(tok.drop_back(), val, 10))
       return None;
     return val * 1024 * 1024;
   }
   if (!to_integer(tok, val, 10))
     return None;
   return val;
 }

lld/MinGW/Driver.cpp

for (auto *a : args.filtered(OPT_L)) {
     add("-libpath:" + StringRef(a->getValue()));
   }
 
   StringRef prefix = "";
   bool isStatic = false;
   for (auto *a : args) {
     switch (a->getOption().getID()) {
     case OPT_INPUT:
-      if (StringRef(a->getValue()).endswith_lower(".def"))
+      if (StringRef(a->getValue()).endswith_insensitive(".def"))
         add("-def:" + StringRef(a->getValue()));
       else
         add(prefix + StringRef(a->getValue()));
       break;
     case OPT_l:
       add(prefix + searchLibrary(a->getValue(), searchPaths, isStatic));
       break;
     case OPT_whole_archive:

lld/lib/Driver/DarwinLdDriver.cpp

while (!buffer.empty()) {
     addFile(path, ctx, forceLoad, false);
     buffer = lineAndRest.second;
   }
   return llvm::Error::success();
 }
 
 /// Parse number assuming it is base 16, but allow 0x prefix.
 static bool parseNumberBase16(StringRef numStr, uint64_t &baseAddress) {
-  if (numStr.startswith_lower("0x"))
+  if (numStr.startswith_insensitive("0x"))
     numStr = numStr.drop_front(2);
   return numStr.getAsInteger(16, baseAddress);
 }
 
 static void parseLLVMOptions(const LinkingContext &ctx) {
   // Honor -mllvm
   if (!ctx.llvmOptions().empty()) {
     unsigned numArgs = ctx.llvmOptions().size();

lld/tools/lld/lld.cpp

if (v.size() > 1 && v[1] == StringRef("-flavor")) {
     if (f == Invalid)
       die("Unknown flavor: " + StringRef(v[2]));
     v.erase(v.begin() + 1, v.begin() + 3);
     return f;
   }
 
   // Deduct the flavor from argv[0].
   StringRef arg0 = path::filename(v[0]);
-  if (arg0.endswith_lower(".exe"))
+  if (arg0.endswith_insensitive(".exe"))
     arg0 = arg0.drop_back(4);
   return parseProgname(arg0);
 }
 
 /// Universal linker main(). This linker emulates the gnu, darwin, or
 /// windows linker based on the argv[0] or -flavor option.
 static int lldMain(int argc, const char **argv, llvm::raw_ostream &stdoutOS,
                    llvm::raw_ostream &stderrOS, bool exitEarly = true) {

lldb/source/Commands/CommandObjectMultiword.cpp

 //===-- CommandObjectMultiword.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/Options.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // CommandObjectMultiword
bool CommandObjectMultiword::Execute(const char *args_string,
   }
 
   auto sub_command = args[0].ref();
   if (sub_command.empty()) {
     result.AppendError("Need to specify a non-empty subcommand.");
     return result.Succeeded();
   }
 
-  if (sub_command.equals_lower("help")) {
+  if (sub_command.equals_insensitive("help")) {
     this->CommandObject::GenerateHelpText(result);
     return result.Succeeded();
   }
 
   if (m_subcommand_dict.empty()) {
     result.AppendErrorWithFormat("'%s' does not have any subcommands.\n",
                                  GetCommandName().str().c_str());
     return false;

lldb/source/Host/common/NativeRegisterContext.cpp

 //===-- NativeRegisterContext.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/common/NativeRegisterContext.h"
 
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 
NativeRegisterContext::GetRegisterInfoByName(llvm::StringRef reg_name,
                                              uint32_t start_idx) {
   if (reg_name.empty())
     return nullptr;
 
   const uint32_t num_registers = GetRegisterCount();
   for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
 
-    if (reg_name.equals_lower(reg_info->name) ||
-        reg_name.equals_lower(reg_info->alt_name))
+    if (reg_name.equals_insensitive(reg_info->name) ||
+        reg_name.equals_insensitive(reg_info->alt_name))
       return reg_info;
   }
   return nullptr;
 }
 
 const RegisterInfo *NativeRegisterContext::GetRegisterInfo(uint32_t kind,
                                                            uint32_t num) {
   const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num);

lldb/source/Host/windows/ProcessLauncherWindows.cpp

 //===-- ProcessLauncherWindows.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/windows/ProcessLauncherWindows.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Program.h"
 
 #include <string>
ProcessLauncherWindows::LaunchProcess(const ProcessLaunchInfo &launch_info,
   startupinfo.hStdInput =
       stdin_handle ? stdin_handle : ::GetStdHandle(STD_INPUT_HANDLE);
   startupinfo.hStdOutput =
       stdout_handle ? stdout_handle : ::GetStdHandle(STD_OUTPUT_HANDLE);
 
   const char *hide_console_var =
       getenv("LLDB_LAUNCH_INFERIORS_WITHOUT_CONSOLE");
   if (hide_console_var &&
-      llvm::StringRef(hide_console_var).equals_lower("true")) {
+      llvm::StringRef(hide_console_var).equals_insensitive("true")) {
     startupinfo.dwFlags |= STARTF_USESHOWWINDOW;
     startupinfo.wShowWindow = SW_HIDE;
   }
 
   DWORD flags = CREATE_NEW_CONSOLE | CREATE_UNICODE_ENVIRONMENT;
   if (launch_info.GetFlags().Test(eLaunchFlagDebug))
     flags |= DEBUG_ONLY_THIS_PROCESS;
 

lldb/source/Initialization/SystemInitializerCommon.cpp

 //===-- SystemInitializerCommon.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Initialization/SystemInitializerCommon.h"
 
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/ReproducerProvider.h"
 #include "lldb/Utility/Timer.h"
static llvm::Error InitializeFileSystem() {
   FileSystem::Initialize();
   return llvm::Error::success();
 }
 
 llvm::Error SystemInitializerCommon::Initialize() {
 #if defined(_WIN32)
   const char *disable_crash_dialog_var = getenv("LLDB_DISABLE_CRASH_DIALOG");
   if (disable_crash_dialog_var &&
-      llvm::StringRef(disable_crash_dialog_var).equals_lower("true")) {
+      llvm::StringRef(disable_crash_dialog_var).equals_insensitive("true")) {
     // This will prevent Windows from displaying a dialog box requiring user
     // interaction when
     // LLDB crashes.  This is mostly useful when automating LLDB, for example
     // via the test
     // suite, so that a crash in LLDB does not prevent completion of the test
     // suite.
     ::SetErrorMode(GetErrorMode() | SEM_FAILCRITICALERRORS |
                    SEM_NOGPFAULTERRORBOX);

lldb/source/Interpreter/CommandInterpreter.cpp

 //===-- CommandInterpreter.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstdlib>
 #include <limits>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "Commands/CommandObjectApropos.h"
 #include "Commands/CommandObjectBreakpoint.h"
 #include "Commands/CommandObjectCommands.h"
 #include "Commands/CommandObjectDisassemble.h"
 #include "Commands/CommandObjectExpression.h"
 #include "Commands/CommandObjectFrame.h"
 #include "Commands/CommandObjectGUI.h"
 #include "Commands/CommandObjectHelp.h"
 #include "Commands/CommandObjectLanguage.h"
void CommandInterpreter::FindCommandsForApropos(
   for (pos = command_map.begin(); pos != command_map.end(); ++pos) {
     llvm::StringRef command_name = pos->first;
     CommandObject *cmd_obj = pos->second.get();
 
     const bool search_short_help = true;
     const bool search_long_help = false;
     const bool search_syntax = false;
     const bool search_options = false;
-    if (command_name.contains_lower(search_word) ||
+    if (command_name.contains_insensitive(search_word) ||
         cmd_obj->HelpTextContainsWord(search_word, search_short_help,
                                       search_long_help, search_syntax,
                                       search_options)) {
       commands_found.AppendString(cmd_obj->GetCommandName());
       commands_help.AppendString(cmd_obj->GetHelp());
     }
 
     if (cmd_obj->IsMultiwordObject()) {

lldb/source/Interpreter/CommandObject.cpp

 //===-- CommandObject.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/CommandObject.h"
 
 #include <map>
 #include <sstream>
 #include <string>
 
 #include <cctype>
 #include <cstdlib>
 
bool CommandObject::HelpTextContainsWord(llvm::StringRef search_word,
   std::string options_usage_help;
 
   bool found_word = false;
 
   llvm::StringRef short_help = GetHelp();
   llvm::StringRef long_help = GetHelpLong();
   llvm::StringRef syntax_help = GetSyntax();
 
-  if (search_short_help && short_help.contains_lower(search_word))
+  if (search_short_help && short_help.contains_insensitive(search_word))
     found_word = true;
-  else if (search_long_help && long_help.contains_lower(search_word))
+  else if (search_long_help && long_help.contains_insensitive(search_word))
     found_word = true;
-  else if (search_syntax && syntax_help.contains_lower(search_word))
+  else if (search_syntax && syntax_help.contains_insensitive(search_word))
     found_word = true;
 
   if (!found_word && search_options && GetOptions() != nullptr) {
     StreamString usage_help;
     GetOptions()->GenerateOptionUsage(
         usage_help, this,
         GetCommandInterpreter().GetDebugger().GetTerminalWidth());
     if (!usage_help.Empty()) {
       llvm::StringRef usage_text = usage_help.GetString();
-      if (usage_text.contains_lower(search_word))
+      if (usage_text.contains_insensitive(search_word))
         found_word = true;
     }
   }
 
   return found_word;
 }
 
 bool CommandObject::ParseOptionsAndNotify(Args &args,

lldb/source/Interpreter/OptionArgParser.cpp

 //===-- OptionArgParser.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 bool OptionArgParser::ToBoolean(llvm::StringRef ref, bool fail_value,
                                 bool *success_ptr) {
   if (success_ptr)
     *success_ptr = true;
   ref = ref.trim();
-  if (ref.equals_lower("false") || ref.equals_lower("off") ||
-      ref.equals_lower("no") || ref.equals_lower("0")) {
+  if (ref.equals_insensitive("false") || ref.equals_insensitive("off") ||
+      ref.equals_insensitive("no") || ref.equals_insensitive("0")) {
     return false;
-  } else if (ref.equals_lower("true") || ref.equals_lower("on") ||
-             ref.equals_lower("yes") || ref.equals_lower("1")) {
+  } else if (ref.equals_insensitive("true") || ref.equals_insensitive("on") ||
+             ref.equals_insensitive("yes") || ref.equals_insensitive("1")) {
     return true;
   }
   if (success_ptr)
     *success_ptr = false;
   return fail_value;
 }
 
 char OptionArgParser::ToChar(llvm::StringRef s, char fail_value,
Status OptionArgParser::ToFormat(const char *s, lldb::Format &format,
   return error;
 }
 
 lldb::ScriptLanguage OptionArgParser::ToScriptLanguage(
     llvm::StringRef s, lldb::ScriptLanguage fail_value, bool *success_ptr) {
   if (success_ptr)
     *success_ptr = true;
 
-  if (s.equals_lower("python"))
+  if (s.equals_insensitive("python"))
     return eScriptLanguagePython;
-  if (s.equals_lower("lua"))
+  if (s.equals_insensitive("lua"))
     return eScriptLanguageLua;
-  if (s.equals_lower("default"))
+  if (s.equals_insensitive("default"))
     return eScriptLanguageDefault;
-  if (s.equals_lower("none"))
+  if (s.equals_insensitive("none"))
     return eScriptLanguageNone;
 
   if (success_ptr)
     *success_ptr = false;
   return fail_value;
 }
 
 lldb::addr_t OptionArgParser::ToAddress(const ExecutionContext *exe_ctx,

lldb/source/Interpreter/OptionValueProperties.cpp

 //===-- OptionValueProperties.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueProperties.h"
 
 #include "lldb/Utility/Flags.h"
 
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Interpreter/OptionValues.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Stream.h"
for (size_t i = 0; i < num_properties; ++i) {
     if (property) {
       const OptionValueProperties *properties =
           property->GetValue()->GetAsProperties();
       if (properties) {
         properties->Apropos(keyword, matching_properties);
       } else {
         bool match = false;
         llvm::StringRef name = property->GetName();
-        if (name.contains_lower(keyword))
+        if (name.contains_insensitive(keyword))
           match = true;
         else {
           llvm::StringRef desc = property->GetDescription();
-          if (desc.contains_lower(keyword))
+          if (desc.contains_insensitive(keyword))
             match = true;
         }
         if (match) {
           matching_properties.push_back(property);
         }
       }
     }
   }

lldb/source/Interpreter/ScriptInterpreter.cpp

 //===-- ScriptInterpreter.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
ScriptInterpreter::GetStatusFromSBError(const lldb::SBError &error) const {
   if (error.m_opaque_up)
     return *error.m_opaque_up.get();
 
   return Status();
 }
 
 lldb::ScriptLanguage
 ScriptInterpreter::StringToLanguage(const llvm::StringRef &language) {
-  if (language.equals_lower(LanguageToString(eScriptLanguageNone)))
+  if (language.equals_insensitive(LanguageToString(eScriptLanguageNone)))
     return eScriptLanguageNone;
-  if (language.equals_lower(LanguageToString(eScriptLanguagePython)))
+  if (language.equals_insensitive(LanguageToString(eScriptLanguagePython)))
     return eScriptLanguagePython;
-  if (language.equals_lower(LanguageToString(eScriptLanguageLua)))
+  if (language.equals_insensitive(LanguageToString(eScriptLanguageLua)))
     return eScriptLanguageLua;
   return eScriptLanguageUnknown;
 }
 
 Status ScriptInterpreter::SetBreakpointCommandCallback(
     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
     const char *callback_text) {
   Status return_error;

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

bool CPlusPlusLanguage::IsNilReference(ValueObject &valobj) {
   bool isZero = valobj.GetValueAsUnsigned(0, &canReadValue) == 0;
   return canReadValue && isZero;
 }
 
 bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const {
   const auto suffixes = {".cpp", ".cxx", ".c++", ".cc",  ".c",
                          ".h",   ".hh",  ".hpp", ".hxx", ".h++"};
   for (auto suffix : suffixes) {
-    if (file_path.endswith_lower(suffix))
+    if (file_path.endswith_insensitive(suffix))
       return true;
   }
 
   // Check if we're in a STL path (where the files usually have no extension
   // that we could check for.
   return file_path.contains("/usr/include/c++/");
 }

lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

bool ObjCLanguage::IsNilReference(ValueObject &valobj) {
   bool canReadValue = true;
   bool isZero = valobj.GetValueAsUnsigned(0, &canReadValue) == 0;
   return canReadValue && isZero;
 }
 
 bool ObjCLanguage::IsSourceFile(llvm::StringRef file_path) const {
   const auto suffixes = {".h", ".m", ".M"};
   for (auto suffix : suffixes) {
-    if (file_path.endswith_lower(suffix))
+    if (file_path.endswith_insensitive(suffix))
       return true;
   }
   return false;
 }

lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(ObjCPlusPlusLanguage)
 
 bool ObjCPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const {
   const auto suffixes = {".h", ".mm"};
   for (auto suffix : suffixes) {
-    if (file_path.endswith_lower(suffix))
+    if (file_path.endswith_insensitive(suffix))
       return true;
   }
   return false;
 }
 
 void ObjCPlusPlusLanguage::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), "Objective-C++ Language",
                                 CreateInstance);

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp

ProcessSP ProcessWindows::CreateInstance(lldb::TargetSP target_sp,
                                          lldb::ListenerSP listener_sp,
                                          const FileSpec *,
                                          bool can_connect) {
   return ProcessSP(new ProcessWindows(target_sp, listener_sp));
 }
 
 static bool ShouldUseLLDBServer() {
   llvm::StringRef use_lldb_server = ::getenv("LLDB_USE_LLDB_SERVER");
-  return use_lldb_server.equals_lower("on") ||
-         use_lldb_server.equals_lower("yes") ||
-         use_lldb_server.equals_lower("1") ||
-         use_lldb_server.equals_lower("true");
+  return use_lldb_server.equals_insensitive("on") ||
+         use_lldb_server.equals_insensitive("yes") ||
+         use_lldb_server.equals_insensitive("1") ||
+         use_lldb_server.equals_insensitive("true");
 }
 
 void ProcessWindows::Initialize() {
   if (!ShouldUseLLDBServer()) {
     static llvm::once_flag g_once_flag;
 
     llvm::call_once(g_once_flag, []() {
       PluginManager::RegisterPlugin(GetPluginNameStatic(),

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

std::string name = cantFail(m_minidump_parser->GetMinidumpFile().getString(
         module->ModuleNameRVA));
     const uint64_t load_addr = module->BaseOfImage;
     const uint64_t load_size = module->SizeOfImage;
     LLDB_LOG(log, "found module: name: {0} {1:x10}-{2:x10} size: {3}", name,
              load_addr, load_addr + load_size, load_size);
 
     // check if the process is wow64 - a 32 bit windows process running on a
     // 64 bit windows
-    if (llvm::StringRef(name).endswith_lower("wow64.dll")) {
+    if (llvm::StringRef(name).endswith_insensitive("wow64.dll")) {
       m_is_wow64 = true;
     }
 
     const auto uuid = m_minidump_parser->GetModuleUUID(module);
     auto file_spec = FileSpec(name, GetArchitecture().GetTriple());
     ModuleSpec module_spec(file_spec, uuid);
     module_spec.GetArchitecture() = GetArchitecture();
     Status error;

lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp

static bool IsMainFile(llvm::StringRef main, llvm::StringRef other) {
   // If the files refer to the local file system, we can just ask the file
   // system if they're equivalent.  But if the source isn't present on disk
   // then we still want to try.
   if (llvm::sys::fs::equivalent(main, other))
     return true;
 
   llvm::SmallString<64> normalized(other);
   llvm::sys::path::native(normalized);
-  return main.equals_lower(normalized);
+  return main.equals_insensitive(normalized);
 }
 
 static void ParseCompile3(const CVSymbol &sym, CompilandIndexItem &cci) {
   cci.m_compile_opts.emplace();
   llvm::cantFail(
       SymbolDeserializer::deserializeAs<Compile3Sym>(sym, *cci.m_compile_opts));
 }
 

lldb/source/Plugins/SymbolFile/NativePDB/PdbFPOProgramToDWARFExpression.cpp

 //===-- PdbFPOProgramToDWARFExpression.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PdbFPOProgramToDWARFExpression.h"
 #include "CodeViewRegisterMapping.h"
 
 #include "lldb/Core/StreamBuffer.h"
 #include "lldb/Symbol/PostfixExpression.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Stream.h"
 #include "llvm/ADT/DenseMap.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/EnumTables.h"
default:
       break;
   }
 
   llvm::ArrayRef<llvm::EnumEntry<uint16_t>> register_names =
       llvm::codeview::getRegisterNames(cpu_type);
   auto it = llvm::find_if(
       register_names,
       [&reg_name](const llvm::EnumEntry<uint16_t> &register_entry) {
-        return reg_name.compare_lower(register_entry.Name) == 0;
+        return reg_name.compare_insensitive(register_entry.Name) == 0;
       });
 
   if (it == register_names.end())
     return LLDB_INVALID_REGNUM;
 
   auto reg_id = static_cast<llvm::codeview::RegisterId>(it->Value);
   return npdb::GetLLDBRegisterNumber(arch_type, reg_id);
 }

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

bool ShouldAddLine(uint32_t requested_line, uint32_t actual_line,
   return ((requested_line == 0 || actual_line == requested_line) &&
           addr_length > 0);
 }
 } // namespace
 
 static bool ShouldUseNativeReader() {
 #if defined(_WIN32)
   llvm::StringRef use_native = ::getenv("LLDB_USE_NATIVE_PDB_READER");
-  return use_native.equals_lower("on") || use_native.equals_lower("yes") ||
-         use_native.equals_lower("1") || use_native.equals_lower("true");
+  return use_native.equals_insensitive("on") || use_native.equals_insensitive("yes") ||
+         use_native.equals_insensitive("1") || use_native.equals_insensitive("true");
 #else
   return true;
 #endif
 }
 
 void SymbolFilePDB::Initialize() {
   if (ShouldUseNativeReader()) {
     npdb::SymbolFileNativePDB::Initialize();

lldb/source/Target/Language.cpp

 //===-- Language.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <functional>
 #include <map>
 #include <mutex>
 
 #include "lldb/Target/Language.h"
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/Support/Threading.h"
struct language_name_pair language_names[] = {
     {"objc++", eLanguageTypeObjC_plus_plus},
     {"pascal", eLanguageTypePascal83}};
 
 static uint32_t num_languages =
     sizeof(language_names) / sizeof(struct language_name_pair);
 
 LanguageType Language::GetLanguageTypeFromString(llvm::StringRef string) {
   for (const auto &L : language_names) {
-    if (string.equals_lower(L.name))
+    if (string.equals_insensitive(L.name))
       return static_cast<LanguageType>(L.type);
   }
 
   return eLanguageTypeUnknown;
 }
 
 const char *Language::GetNameForLanguageType(LanguageType language) {
   if (language < num_languages)

lldb/source/Target/RegisterContext.cpp

 //===-- RegisterContext.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
RegisterContext::GetRegisterInfoByName(llvm::StringRef reg_name,
                                        uint32_t start_idx) {
   if (reg_name.empty())
     return nullptr;
 
   const uint32_t num_registers = GetRegisterCount();
   for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
 
-    if (reg_name.equals_lower(reg_info->name) ||
-        reg_name.equals_lower(reg_info->alt_name))
+    if (reg_name.equals_insensitive(reg_info->name) ||
+        reg_name.equals_insensitive(reg_info->alt_name))
       return reg_info;
   }
   return nullptr;
 }
 
 uint32_t
 RegisterContext::UpdateDynamicRegisterSize(const lldb_private::ArchSpec &arch,
                                            RegisterInfo *reg_info) {

lldb/source/Utility/ArchSpec.cpp

 //===-- ArchSpec.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/ArchSpec.h"
 
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-defines.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/MachO.h"
if (def->type == arch_type)
       return def;
   }
   return nullptr;
 }
 
 // Get an architecture definition by name.
 static const CoreDefinition *FindCoreDefinition(llvm::StringRef name) {
   for (unsigned int i = 0; i < llvm::array_lengthof(g_core_definitions); ++i) {
-    if (name.equals_lower(g_core_definitions[i].name))
+    if (name.equals_insensitive(g_core_definitions[i].name))
       return &g_core_definitions[i];
   }
   return nullptr;
 }
 
 static inline const CoreDefinition *FindCoreDefinition(ArchSpec::Core core) {
   if (core < llvm::array_lengthof(g_core_definitions))
     return &g_core_definitions[core];

lldb/source/Utility/ConstString.cpp

 //===-- ConstString.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/ConstString.h"
 
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/DJB.h"
 #include "llvm/Support/FormatProviders.h"
bool ConstString::Equals(ConstString lhs, ConstString rhs,
   // identical pointers, the result must be false for case sensitive equality
   // test.
   if (case_sensitive)
     return false;
 
   // perform case insensitive equality test
   llvm::StringRef lhs_string_ref(lhs.GetStringRef());
   llvm::StringRef rhs_string_ref(rhs.GetStringRef());
-  return lhs_string_ref.equals_lower(rhs_string_ref);
+  return lhs_string_ref.equals_insensitive(rhs_string_ref);
 }
 
 int ConstString::Compare(ConstString lhs, ConstString rhs,
                          const bool case_sensitive) {
   // If the iterators are the same, this is the same string
   const char *lhs_cstr = lhs.m_string;
   const char *rhs_cstr = rhs.m_string;
   if (lhs_cstr == rhs_cstr)
     return 0;
   if (lhs_cstr && rhs_cstr) {
     llvm::StringRef lhs_string_ref(lhs.GetStringRef());
     llvm::StringRef rhs_string_ref(rhs.GetStringRef());
 
     if (case_sensitive) {
       return lhs_string_ref.compare(rhs_string_ref);
     } else {
-      return lhs_string_ref.compare_lower(rhs_string_ref);
+      return lhs_string_ref.compare_insensitive(rhs_string_ref);
     }
   }
 
   if (lhs_cstr)
     return +1; // LHS isn't nullptr but RHS is
   else
     return -1; // LHS is nullptr but RHS isn't
 }

lldb/source/Utility/FileSpec.cpp

 //===-- FileSpec.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"

 void FileSpec::MakeAbsolute(const FileSpec &dir) {
   if (IsRelative())
     PrependPathComponent(dir);
 }
 
 void llvm::format_provider<FileSpec>::format(const FileSpec &F,
                                              raw_ostream &Stream,
                                              StringRef Style) {
   assert(
-      (Style.empty() || Style.equals_lower("F") || Style.equals_lower("D")) &&
+      (Style.empty() || Style.equals_insensitive("F") || Style.equals_insensitive("D")) &&
       "Invalid FileSpec style!");
 
   StringRef dir = F.GetDirectory().GetStringRef();
   StringRef file = F.GetFilename().GetStringRef();
 
   if (dir.empty() && file.empty()) {
     Stream << "(empty)";
     return;
   }
 
-  if (Style.equals_lower("F")) {
+  if (Style.equals_insensitive("F")) {
     Stream << (file.empty() ? "(empty)" : file);
     return;
   }
 
   // Style is either D or empty, either way we need to print the directory.
   if (!dir.empty()) {
     // Directory is stored in normalized form, which might be different than
     // preferred form.  In order to handle this, we need to cut off the
     // filename, then denormalize, then write the entire denorm'ed directory.
     llvm::SmallString<64> denormalized_dir = dir;
     Denormalize(denormalized_dir, F.GetPathStyle());
     Stream << denormalized_dir;
     Stream << GetPreferredPathSeparator(F.GetPathStyle());
   }
 
-  if (Style.equals_lower("D")) {
+  if (Style.equals_insensitive("D")) {
     // We only want to print the directory, so now just exit.
     if (dir.empty())
       Stream << "(empty)";
     return;
   }
 
   if (!file.empty())
     Stream << file;

lldb/source/Utility/Log.cpp

 //===-- Log.cpp -----------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/VASPrintf.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator.h"
 
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/ManagedStatic.h"
ForEachCategory(entry,
                   });
 }
 
 uint32_t Log::GetFlags(llvm::raw_ostream &stream, const ChannelMap::value_type &entry,
                          llvm::ArrayRef<const char *> categories) {
   bool list_categories = false;
   uint32_t flags = 0;
   for (const char *category : categories) {
-    if (llvm::StringRef("all").equals_lower(category)) {
+    if (llvm::StringRef("all").equals_insensitive(category)) {
       flags |= UINT32_MAX;
       continue;
     }
-    if (llvm::StringRef("default").equals_lower(category)) {
+    if (llvm::StringRef("default").equals_insensitive(category)) {
       flags |= entry.second.m_channel.default_flags;
       continue;
     }
     auto cat = llvm::find_if(
         entry.second.m_channel.categories,
-        [&](const Log::Category &c) { return c.name.equals_lower(category); });
+        [&](const Log::Category &c) { return c.name.equals_insensitive(category); });
     if (cat != entry.second.m_channel.categories.end()) {
       flags |= cat->flag;
       continue;
     }
     stream << llvm::formatv("error: unrecognized log category '{0}'\n",
                             category);
     list_categories = true;
   }

llvm/include/llvm/ADT/SmallString.h

public:
 
   /// Check for string equality.  This is more efficient than compare() when
   /// the relative ordering of inequal strings isn't needed.
   bool equals(StringRef RHS) const {
     return str().equals(RHS);
   }
 
   /// Check for string equality, ignoring case.
-  bool equals_lower(StringRef RHS) const {
-    return str().equals_lower(RHS);
+  bool equals_insensitive(StringRef RHS) const {
+    return str().equals_insensitive(RHS);
   }
 
   /// Compare two strings; the result is -1, 0, or 1 if this string is
   /// lexicographically less than, equal to, or greater than the \p RHS.
   int compare(StringRef RHS) const {
     return str().compare(RHS);
   }
 
-  /// compare_lower - Compare two strings, ignoring case.
-  int compare_lower(StringRef RHS) const {
-    return str().compare_lower(RHS);
+  /// compare_insensitive - Compare two strings, ignoring case.
+  int compare_insensitive(StringRef RHS) const {
+    return str().compare_insensitive(RHS);
   }
 
   /// compare_numeric - Compare two strings, treating sequences of digits as
   /// numbers.
   int compare_numeric(StringRef RHS) const {
     return str().compare_numeric(RHS);
   }
 

llvm/include/llvm/ADT/StringRef.h

#endif
     /// equals - Check for string equality, this is more efficient than
     /// compare() when the relative ordering of inequal strings isn't needed.
     LLVM_NODISCARD
     bool equals(StringRef RHS) const {
       return (Length == RHS.Length &&
               compareMemory(Data, RHS.Data, RHS.Length) == 0);
     }
 
-    /// equals_lower - Check for string equality, ignoring case.
+    /// equals_insensitive - Check for string equality, ignoring case.
     LLVM_NODISCARD
-    bool equals_lower(StringRef RHS) const {
-      return Length == RHS.Length && compare_lower(RHS) == 0;
+    bool equals_insensitive(StringRef RHS) const {
+      return Length == RHS.Length && compare_insensitive(RHS) == 0;
     }
 
+    LLVM_NODISCARD
+    bool equals_lower(StringRef RHS) const { return equals_insensitive(RHS); }
+
     /// compare - Compare two strings; the result is -1, 0, or 1 if this string
     /// is lexicographically less than, equal to, or greater than the \p RHS.
     LLVM_NODISCARD
     int compare(StringRef RHS) const {
       // Check the prefix for a mismatch.
       if (int Res = compareMemory(Data, RHS.Data, std::min(Length, RHS.Length)))
         return Res < 0 ? -1 : 1;
 
       // Otherwise the prefixes match, so we only need to check the lengths.
       if (Length == RHS.Length)
         return 0;
       return Length < RHS.Length ? -1 : 1;
     }
 
-    /// compare_lower - Compare two strings, ignoring case.
+    /// compare_insensitive - Compare two strings, ignoring case.
     LLVM_NODISCARD
-    int compare_lower(StringRef RHS) const;
+    int compare_insensitive(StringRef RHS) const;
+
+    LLVM_NODISCARD
+    int compare_lower(StringRef RHS) const { return compare_insensitive(RHS); }
 
     /// compare_numeric - Compare two strings, treating sequences of digits as
     /// numbers.
     LLVM_NODISCARD
     int compare_numeric(StringRef RHS) const;
 
     /// Determine the edit distance between this string and another
     /// string.
#endif
     LLVM_NODISCARD
     bool startswith(StringRef Prefix) const {
       return Length >= Prefix.Length &&
              compareMemory(Data, Prefix.Data, Prefix.Length) == 0;
     }
 
     /// Check if this string starts with the given \p Prefix, ignoring case.
     LLVM_NODISCARD
-    bool startswith_lower(StringRef Prefix) const;
+    bool startswith_insensitive(StringRef Prefix) const;
+
+    LLVM_NODISCARD
+    bool startswith_lower(StringRef Prefix) const {
+      return startswith_insensitive(Prefix);
+    }
 
     /// Check if this string ends with the given \p Suffix.
     LLVM_NODISCARD
     bool endswith(StringRef Suffix) const {
       return Length >= Suffix.Length &&
         compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
     }
 
     /// Check if this string ends with the given \p Suffix, ignoring case.
     LLVM_NODISCARD
-    bool endswith_lower(StringRef Suffix) const;
+    bool endswith_insensitive(StringRef Suffix) const;
+
+    LLVM_NODISCARD
+    bool endswith_lower(StringRef Prefix) const {
+      return endswith_insensitive(Prefix);
+    }
 
     /// @}
     /// @name String Searching
     /// @{
 
     /// Search for the first character \p C in the string.
     ///
     /// \returns The index of the first occurrence of \p C, or npos if not
size_t find(char C, size_t From = 0) const {
       return npos;
     }
 
     /// Search for the first character \p C in the string, ignoring case.
     ///
     /// \returns The index of the first occurrence of \p C, or npos if not
     /// found.
     LLVM_NODISCARD
-    size_t find_lower(char C, size_t From = 0) const;
+    size_t find_insensitive(char C, size_t From = 0) const;
+
+    LLVM_NODISCARD
+    size_t find_lower(char C, size_t From = 0) const {
+      return find_insensitive(C, From);
+    }
 
     /// Search for the first character satisfying the predicate \p F
     ///
     /// \returns The index of the first character satisfying \p F starting from
     /// \p From, or npos if not found.
     LLVM_NODISCARD
     size_t find_if(function_ref<bool(char)> F, size_t From = 0) const {
       StringRef S = drop_front(From);
#endif
     LLVM_NODISCARD
     size_t find(StringRef Str, size_t From = 0) const;
 
     /// Search for the first string \p Str in the string, ignoring case.
     ///
     /// \returns The index of the first occurrence of \p Str, or npos if not
     /// found.
     LLVM_NODISCARD
-    size_t find_lower(StringRef Str, size_t From = 0) const;
+    size_t find_insensitive(StringRef Str, size_t From = 0) const;
+
+    LLVM_NODISCARD
+    size_t find_lower(StringRef Str, size_t From = 0) const {
+      return find_insensitive(Str, From);
+    }
 
     /// Search for the last character \p C in the string.
     ///
     /// \returns The index of the last occurrence of \p C, or npos if not
     /// found.
     LLVM_NODISCARD
     size_t rfind(char C, size_t From = npos) const {
       From = std::min(From, Length);
       size_t i = From;
       while (i != 0) {
         --i;
         if (Data[i] == C)
           return i;
       }
       return npos;
     }
 
     /// Search for the last character \p C in the string, ignoring case.
     ///
     /// \returns The index of the last occurrence of \p C, or npos if not
     /// found.
     LLVM_NODISCARD
-    size_t rfind_lower(char C, size_t From = npos) const;
+    size_t rfind_insensitive(char C, size_t From = npos) const;
+
+    LLVM_NODISCARD
+    size_t rfind_lower(char C, size_t From = npos) const {
+      return rfind_insensitive(C, From);
+    }
 
     /// Search for the last string \p Str in the string.
     ///
     /// \returns The index of the last occurrence of \p Str, or npos if not
     /// found.
     LLVM_NODISCARD
     size_t rfind(StringRef Str) const;
 
     /// Search for the last string \p Str in the string, ignoring case.
     ///
     /// \returns The index of the last occurrence of \p Str, or npos if not
     /// found.
     LLVM_NODISCARD
-    size_t rfind_lower(StringRef Str) const;
+    size_t rfind_insensitive(StringRef Str) const;
+
+    LLVM_NODISCARD
+    size_t rfind_lower(StringRef Str) const { return rfind_insensitive(Str); }
 
     /// Find the first character in the string that is \p C, or npos if not
     /// found. Same as find.
     LLVM_NODISCARD
     size_t find_first_of(char C, size_t From = 0) const {
       return find(C, From);
     }
 
#endif
     /// Return true if the given character is contained in *this, and false
     /// otherwise.
     LLVM_NODISCARD
     bool contains(char C) const { return find_first_of(C) != npos; }
 
     /// Return true if the given string is a substring of *this, and false
     /// otherwise.
     LLVM_NODISCARD
+    bool contains_insensitive(StringRef Other) const {
+      return find_insensitive(Other) != npos;
+    }
+
+    LLVM_NODISCARD
     bool contains_lower(StringRef Other) const {
-      return find_lower(Other) != npos;
+      return contains_insensitive(Other);
     }
 
     /// Return true if the given character is contained in *this, and false
     /// otherwise.
     LLVM_NODISCARD
-    bool contains_lower(char C) const { return find_lower(C) != npos; }
+    bool contains_insensitive(char C) const {
+      return find_insensitive(C) != npos;
+    }
+
+    LLVM_NODISCARD
+    bool contains_lower(char C) const { return contains_insensitive(C); }
 
     /// @}
     /// @name Helpful Algorithms
     /// @{
 
     /// Return the number of occurrences of \p C in the string.
     LLVM_NODISCARD
     size_t count(char C) const {
bool consume_front(StringRef Prefix) {
         return false;
 
       *this = drop_front(Prefix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given prefix, ignoring case,
     /// and removes that prefix.
-    bool consume_front_lower(StringRef Prefix) {
-      if (!startswith_lower(Prefix))
+    bool consume_front_insensitive(StringRef Prefix) {
+      if (!startswith_insensitive(Prefix))
         return false;
 
       *this = drop_front(Prefix.size());
       return true;
     }
 
+    bool consume_front_lower(StringRef Prefix) {
+      return consume_front_insensitive(Prefix);
+    }
+
     /// Returns true if this StringRef has the given suffix and removes that
     /// suffix.
     bool consume_back(StringRef Suffix) {
       if (!endswith(Suffix))
         return false;
 
       *this = drop_back(Suffix.size());
       return true;
     }
 
     /// Returns true if this StringRef has the given suffix, ignoring case,
     /// and removes that suffix.
-    bool consume_back_lower(StringRef Suffix) {
-      if (!endswith_lower(Suffix))
+    bool consume_back_insensitive(StringRef Suffix) {
+      if (!endswith_insensitive(Suffix))
         return false;
 
       *this = drop_back(Suffix.size());
       return true;
     }
 
+    bool consume_back_lower(StringRef Suffix) {
+      return consume_back_insensitive(Suffix);
+    }
+
     /// Return a reference to the substring from [Start, End).
     ///
     /// \param Start The index of the starting character in the substring; if
     /// the index is npos or greater than the length of the string then the
     /// empty substring will be returned.
     ///
     /// \param End The index following the last character to include in the
     /// substring. If this is npos or exceeds the number of characters

llvm/include/llvm/ADT/StringSwitch.h

StringSwitch &Cases(StringLiteral S0, StringLiteral S1, StringLiteral S2,
                       StringLiteral S3, StringLiteral S4, StringLiteral S5,
                       StringLiteral S6, StringLiteral S7, StringLiteral S8,
                       StringLiteral S9, T Value) {
     return Case(S0, Value).Cases(S1, S2, S3, S4, S5, S6, S7, S8, S9, Value);
   }
 
   // Case-insensitive case matchers.
   StringSwitch &CaseLower(StringLiteral S, T Value) {
-    if (!Result && Str.equals_lower(S))
+    if (!Result && Str.equals_insensitive(S))
       Result = std::move(Value);
 
     return *this;
   }
 
   StringSwitch &EndsWithLower(StringLiteral S, T Value) {
-    if (!Result && Str.endswith_lower(S))
+    if (!Result && Str.endswith_insensitive(S))
       Result = Value;
 
     return *this;
   }
 
   StringSwitch &StartsWithLower(StringLiteral S, T Value) {
-    if (!Result && Str.startswith_lower(S))
+    if (!Result && Str.startswith_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 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_lower("x"))
+    if (!Str.startswith_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/include/llvm/Support/VirtualFileSystem.h

private:
   bool shouldFallBackToExternalFS(std::error_code EC, Entry *E = nullptr) const;
 
   // In a RedirectingFileSystem, keys can be specified in Posix or Windows
   // style (or even a mixture of both), so this comparison helper allows
   // slashes (representing a root) to match backslashes (and vice versa).  Note
   // that, other than the root, path components should not contain slashes or
   // backslashes.
   bool pathComponentMatches(llvm::StringRef lhs, llvm::StringRef rhs) const {
-    if ((CaseSensitive ? lhs.equals(rhs) : lhs.equals_lower(rhs)))
+    if ((CaseSensitive ? lhs.equals(rhs) : lhs.equals_insensitive(rhs)))
       return true;
     return (lhs == "/" && rhs == "\\") || (lhs == "\\" && rhs == "/");
   }
 
   /// The root(s) of the virtual file system.
   std::vector<std::unique_ptr<Entry>> Roots;
 
   /// The current working directory of the file system.

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

TargetLowering::getRegForInlineAsmConstraint(const TargetRegisterInfo *RI,
   // Figure out which register class contains this reg.
   for (const TargetRegisterClass *RC : RI->regclasses()) {
     // If none of the value types for this register class are valid, we
     // can't use it.  For example, 64-bit reg classes on 32-bit targets.
     if (!isLegalRC(*RI, *RC))
       continue;
 
     for (const MCPhysReg &PR : *RC) {
-      if (RegName.equals_lower(RI->getRegAsmName(PR))) {
+      if (RegName.equals_insensitive(RI->getRegAsmName(PR))) {
         std::pair<unsigned, const TargetRegisterClass *> S =
             std::make_pair(PR, RC);
 
         // If this register class has the requested value type, return it,
         // otherwise keep searching and return the first class found
         // if no other is found which explicitly has the requested type.
         if (RI->isTypeLegalForClass(*RC, VT))
           return S;

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

static int gsiRecordCmp(StringRef S1, StringRef S2) {
   if (LS != RS)
     return (LS > RS) - (LS < RS);
 
   // If either string contains non ascii characters, memcmp them.
   if (LLVM_UNLIKELY(!isAsciiString(S1) || !isAsciiString(S2)))
     return memcmp(S1.data(), S2.data(), LS);
 
   // Both strings are ascii, perform a case-insensitive comparison.
-  return S1.compare_lower(S2.data());
+  return S1.compare_insensitive(S2.data());
 }
 
 void GSIStreamBuilder::finalizePublicBuckets() {
   PSH->finalizeBuckets(0, Publics);
 }
 
 void GSIStreamBuilder::finalizeGlobalBuckets(uint32_t RecordZeroOffset) {
   // Build up a list of globals to be bucketed. Use the BulkPublic data

llvm/lib/FileCheck/FileCheck.cpp

Pattern::MatchResult Pattern::match(StringRef Buffer,
                                     const SourceMgr &SM) const {
   // If this is the EOF pattern, match it immediately.
   if (CheckTy == Check::CheckEOF)
     return MatchResult(Buffer.size(), 0, Error::success());
 
   // If this is a fixed string pattern, just match it now.
   if (!FixedStr.empty()) {
     size_t Pos =
-        IgnoreCase ? Buffer.find_lower(FixedStr) : Buffer.find(FixedStr);
+        IgnoreCase ? Buffer.find_insensitive(FixedStr) : Buffer.find(FixedStr);
     if (Pos == StringRef::npos)
       return make_error<NotFoundError>();
     return MatchResult(Pos, /*MatchLen=*/FixedStr.size(), Error::success());
   }
 
   // Regex match.
 
   // If there are substitutions, we need to create a temporary string with the

llvm/lib/MC/MCParser/AsmParser.cpp

bool AsmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
   if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) &&
       Lexer.isNot(AsmToken::Identifier))
     return TokError("unexpected token in directive");
 
   // Convert to an APFloat.
   APFloat Value(Semantics);
   StringRef IDVal = getTok().getString();
   if (getLexer().is(AsmToken::Identifier)) {
-    if (!IDVal.compare_lower("infinity") || !IDVal.compare_lower("inf"))
+    if (!IDVal.compare_insensitive("infinity") || !IDVal.compare_insensitive("inf"))
       Value = APFloat::getInf(Semantics);
-    else if (!IDVal.compare_lower("nan"))
+    else if (!IDVal.compare_insensitive("nan"))
       Value = APFloat::getNaN(Semantics, false, ~0);
     else
       return TokError("invalid floating point literal");
   } else if (errorToBool(
                  Value.convertFromString(IDVal, APFloat::rmNearestTiesToEven)
                      .takeError()))
     return TokError("invalid floating point literal");
   if (IsNeg)

llvm/lib/MC/MCParser/COFFMasmParser.cpp

 ///      label "endproc"
 bool COFFMasmParser::ParseDirectiveProc(StringRef Directive, SMLoc Loc) {
   StringRef Label;
   if (getParser().parseIdentifier(Label))
     return Error(Loc, "expected identifier for procedure");
   if (getLexer().is(AsmToken::Identifier)) {
     StringRef nextVal = getTok().getString();
     SMLoc nextLoc = getTok().getLoc();
-    if (nextVal.equals_lower("far")) {
+    if (nextVal.equals_insensitive("far")) {
       // TODO(epastor): Handle far procedure definitions.
       Lex();
       return Error(nextLoc, "far procedure definitions not yet supported");
-    } else if (nextVal.equals_lower("near")) {
+    } else if (nextVal.equals_insensitive("near")) {
       Lex();
       nextVal = getTok().getString();
       nextLoc = getTok().getLoc();
     }
   }
   MCSymbolCOFF *Sym = cast<MCSymbolCOFF>(getContext().getOrCreateSymbol(Label));
 
   // Define symbol as simple external function
   Sym->setExternal(true);
   Sym->setType(COFF::IMAGE_SYM_DTYPE_FUNCTION << COFF::SCT_COMPLEX_TYPE_SHIFT);
 
   bool Framed = false;
   if (getLexer().is(AsmToken::Identifier) &&
-      getTok().getString().equals_lower("frame")) {
+      getTok().getString().equals_insensitive("frame")) {
     Lex();
     Framed = true;
     getStreamer().EmitWinCFIStartProc(Sym, Loc);
   }
   getStreamer().emitLabel(Sym, Loc);
 
   CurrentProcedure = Label;
   CurrentProcedureFramed = Framed;

llvm/lib/MC/MCParser/MasmParser.cpp

const AsmToken &MasmParser::Lex() {
 
   while (tok->is(AsmToken::Identifier)) {
     if (StartOfStatement) {
       AsmToken NextTok;
 
       MutableArrayRef<AsmToken> Buf(NextTok);
       size_t ReadCount = Lexer.peekTokens(Buf);
       if (ReadCount && NextTok.is(AsmToken::Identifier) &&
-          (NextTok.getString().equals_lower("equ") ||
-           NextTok.getString().equals_lower("textequ"))) {
+          (NextTok.getString().equals_insensitive("equ") ||
+           NextTok.getString().equals_insensitive("textequ"))) {
         // This looks like an EQU or TEXTEQU directive; don't expand the
         // identifier, allowing for redefinitions.
         break;
       }
     }
     auto it = Variables.find(tok->getIdentifier().lower());
     const llvm::MCAsmMacro *M =
         getContext().lookupMacro(tok->getIdentifier().lower());
if (parseIdentifier(Identifier)) {
                                         getContext());
           EndLoc = FirstTokenLoc;
           return false;
         }
         return Error(FirstTokenLoc, "invalid token in expression");
       }
     }
     // Parse named bitwise negation.
-    if (Identifier.equals_lower("not")) {
+    if (Identifier.equals_insensitive("not")) {
       if (parsePrimaryExpr(Res, EndLoc, nullptr))
         return true;
       Res = MCUnaryExpr::createNot(Res, getContext(), FirstTokenLoc);
       return false;
     }
     // Parse symbol variant.
     std::pair<StringRef, StringRef> Split;
     if (!MAI.useParensForSymbolVariant()) {
if (Lexer.is(AsmToken::Integer)) {
     IDVal = "*";
   } else if (Lexer.is(AsmToken::Real)) {
     // Treat ".<number>" as a valid identifier in this context.
     IDVal = getTok().getString();
     Lex(); // always eat a token
     if (!IDVal.startswith("."))
       return Error(IDLoc, "unexpected token at start of statement");
   } else if (Lexer.is(AsmToken::Identifier) &&
-             getTok().getString().equals_lower("echo")) {
+             getTok().getString().equals_insensitive("echo")) {
     // Intercept echo early to avoid lexical substitution in its message, and
     // delegate all handling to the appropriate function.
     return parseDirectiveEcho();
   } else if (parseIdentifier(IDVal)) {
     if (!TheCondState.Ignore) {
       Lex(); // always eat a token
       return Error(IDLoc, "unexpected token at start of statement");
     }
if (DirKind != DK_NO_DIRECTIVE) {
     //    all the directives that behave in a target and platform independent
     //    manner, or at least have a default behavior that's shared between
     //    all targets and platforms.
 
     getTargetParser().flushPendingInstructions(getStreamer());
 
     // Special-case handling of structure-end directives at higher priority,
     // since ENDS is overloaded as a segment-end directive.
-    if (IDVal.equals_lower("ends") && StructInProgress.size() > 1 &&
+    if (IDVal.equals_insensitive("ends") && StructInProgress.size() > 1 &&
         getTok().is(AsmToken::EndOfStatement)) {
       return parseDirectiveNestedEnds();
     }
 
     // First, check the extension directive map to see if any extension has
     // registered itself to parse this directive.
     std::pair<MCAsmParserExtension *, DirectiveHandler> Handler =
         ExtensionDirectiveMap.lookup(IDVal.lower());
bool MasmParser::parseStatement(ParseStatementInfo &Info,
   //    all the directives that behave in a target and platform independent
   //    manner, or at least have a default behavior that's shared between
   //    all targets and platforms.
 
   getTargetParser().flushPendingInstructions(getStreamer());
 
   // Special-case handling of structure-end directives at higher priority, since
   // ENDS is overloaded as a segment-end directive.
-  if (nextVal.equals_lower("ends") && StructInProgress.size() == 1) {
+  if (nextVal.equals_insensitive("ends") && StructInProgress.size() == 1) {
     Lex();
     return parseDirectiveEnds(IDVal, IDLoc);
   }
 
   // First, check the extension directive map to see if any extension has
   // registered itself to parse this directive.
   std::pair<MCAsmParserExtension *, DirectiveHandler> Handler =
       ExtensionDirectiveMap.lookup(nextVal.lower());
default:
     break;
   case DK_ASSIGN:
   case DK_EQU:
   case DK_TEXTEQU:
     Lex();
     return parseDirectiveEquate(nextVal, IDVal, DirKind, IDLoc);
   case DK_BYTE:
     if (afterNextTok.is(AsmToken::Identifier) &&
-        afterNextTok.getString().equals_lower("ptr")) {
+        afterNextTok.getString().equals_insensitive("ptr")) {
       // Size directive; part of an instruction.
       break;
     }
     LLVM_FALLTHROUGH;
   case DK_SBYTE:
   case DK_DB:
     Lex();
     return parseDirectiveNamedValue(nextVal, 1, IDVal, IDLoc);
   case DK_WORD:
     if (afterNextTok.is(AsmToken::Identifier) &&
-        afterNextTok.getString().equals_lower("ptr")) {
+        afterNextTok.getString().equals_insensitive("ptr")) {
       // Size directive; part of an instruction.
       break;
     }
     LLVM_FALLTHROUGH;
   case DK_SWORD:
   case DK_DW:
     Lex();
     return parseDirectiveNamedValue(nextVal, 2, IDVal, IDLoc);
   case DK_DWORD:
     if (afterNextTok.is(AsmToken::Identifier) &&
-        afterNextTok.getString().equals_lower("ptr")) {
+        afterNextTok.getString().equals_insensitive("ptr")) {
       // Size directive; part of an instruction.
       break;
     }
     LLVM_FALLTHROUGH;
   case DK_SDWORD:
   case DK_DD:
     Lex();
     return parseDirectiveNamedValue(nextVal, 4, IDVal, IDLoc);
   case DK_FWORD:
     if (afterNextTok.is(AsmToken::Identifier) &&
-        afterNextTok.getString().equals_lower("ptr")) {
+        afterNextTok.getString().equals_insensitive("ptr")) {
       // Size directive; part of an instruction.
       break;
     }
     LLVM_FALLTHROUGH;
   case DK_DF:
     Lex();
     return parseDirectiveNamedValue(nextVal, 6, IDVal, IDLoc);
   case DK_QWORD:
     if (afterNextTok.is(AsmToken::Identifier) &&
-        afterNextTok.getString().equals_lower("ptr")) {
+        afterNextTok.getString().equals_insensitive("ptr")) {
       // Size directive; part of an instruction.
       break;
     }
     LLVM_FALLTHROUGH;
   case DK_SQWORD:
   case DK_DQ:
     Lex();
     return parseDirectiveNamedValue(nextVal, 8, IDVal, IDLoc);
if (Size == 1 && getTok().is(AsmToken::String)) {
     // Pad the string with spaces to the specified length.
     for (size_t i = Value.size(); i < StringPadLength; ++i)
       Values.push_back(MCConstantExpr::create(' ', getContext()));
   } else {
     const MCExpr *Value;
     if (parseExpression(Value))
       return true;
     if (getTok().is(AsmToken::Identifier) &&
-        getTok().getString().equals_lower("dup")) {
+        getTok().getString().equals_insensitive("dup")) {
       Lex(); // Eat 'dup'.
       const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
       if (!MCE)
         return Error(Value->getLoc(),
                      "cannot repeat value a non-constant number of times");
       const int64_t Repetitions = MCE->getValue();
       if (Repetitions < 0)
         return Error(Value->getLoc(),
bool MasmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
   if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) &&
       Lexer.isNot(AsmToken::Identifier))
     return TokError("unexpected token in directive");
 
   // Convert to an APFloat.
   APFloat Value(Semantics);
   StringRef IDVal = getTok().getString();
   if (getLexer().is(AsmToken::Identifier)) {
-    if (IDVal.equals_lower("infinity") || IDVal.equals_lower("inf"))
+    if (IDVal.equals_insensitive("infinity") || IDVal.equals_insensitive("inf"))
       Value = APFloat::getInf(Semantics);
-    else if (IDVal.equals_lower("nan"))
+    else if (IDVal.equals_insensitive("nan"))
       Value = APFloat::getNaN(Semantics, false, ~0);
-    else if (IDVal.equals_lower("?"))
+    else if (IDVal.equals_insensitive("?"))
       Value = APFloat::getZero(Semantics);
     else
       return TokError("invalid floating point literal");
   } else if (IDVal.consume_back("r") || IDVal.consume_back("R")) {
     // MASM hexadecimal floating-point literal; no APFloat conversion needed.
     // To match ML64.exe, ignore the initial sign.
     unsigned SizeInBits = Value.getSizeInBits(Semantics);
     if (SizeInBits != (IDVal.size() << 2))

 bool MasmParser::parseRealInstList(const fltSemantics &Semantics,
                                    SmallVectorImpl<APInt> &ValuesAsInt,
                                    const AsmToken::TokenKind EndToken) {
   while (getTok().isNot(EndToken) ||
          (EndToken == AsmToken::Greater &&
           getTok().isNot(AsmToken::GreaterGreater))) {
     const AsmToken NextTok = peekTok();
     if (NextTok.is(AsmToken::Identifier) &&
-        NextTok.getString().equals_lower("dup")) {
+        NextTok.getString().equals_insensitive("dup")) {
       const MCExpr *Value;
       if (parseExpression(Value) || parseToken(AsmToken::Identifier))
         return true;
       const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
       if (!MCE)
         return Error(Value->getLoc(),
                      "cannot repeat value a non-constant number of times");
       const int64_t Repetitions = MCE->getValue();

 bool MasmParser::parseStructInstList(
     const StructInfo &Structure, std::vector<StructInitializer> &Initializers,
     const AsmToken::TokenKind EndToken) {
   while (getTok().isNot(EndToken) ||
          (EndToken == AsmToken::Greater &&
           getTok().isNot(AsmToken::GreaterGreater))) {
     const AsmToken NextTok = peekTok();
     if (NextTok.is(AsmToken::Identifier) &&
-        NextTok.getString().equals_lower("dup")) {
+        NextTok.getString().equals_insensitive("dup")) {
       const MCExpr *Value;
       if (parseExpression(Value) || parseToken(AsmToken::Identifier))
         return true;
       const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
       if (!MCE)
         return Error(Value->getLoc(),
                      "cannot repeat value a non-constant number of times");
       const int64_t Repetitions = MCE->getValue();
bool MasmParser::parseDirectiveStruct(StringRef Directive,
   }
 
   StringRef Qualifier;
   SMLoc QualifierLoc;
   if (parseOptionalToken(AsmToken::Comma)) {
     QualifierLoc = getTok().getLoc();
     if (parseIdentifier(Qualifier))
       return addErrorSuffix(" in '" + Twine(Directive) + "' directive");
-    if (!Qualifier.equals_lower("nonunique"))
+    if (!Qualifier.equals_insensitive("nonunique"))
       return Error(QualifierLoc, "Unrecognized qualifier for '" +
                                      Twine(Directive) +
                                      "' directive; expected none or NONUNIQUE");
   }
 
   if (parseToken(AsmToken::EndOfStatement))
     return addErrorSuffix(" in '" + Twine(Directive) + "' directive");
 
bool MasmParser::parseDirectiveNestedStruct(StringRef Directive,
   return false;
 }
 
 bool MasmParser::parseDirectiveEnds(StringRef Name, SMLoc NameLoc) {
   if (StructInProgress.empty())
     return Error(NameLoc, "ENDS directive without matching STRUC/STRUCT/UNION");
   if (StructInProgress.size() > 1)
     return Error(NameLoc, "unexpected name in nested ENDS directive");
-  if (StructInProgress.back().Name.compare_lower(Name))
+  if (StructInProgress.back().Name.compare_insensitive(Name))
     return Error(NameLoc, "mismatched name in ENDS directive; expected '" +
                               StructInProgress.back().Name + "'");
   StructInfo Structure = StructInProgress.pop_back_val();
   // Pad to make the structure's size divisible by the smaller of its alignment
   // and the size of its largest field.
   Structure.Size = llvm::alignTo(
       Structure.Size, std::min(Structure.Alignment, Structure.AlignmentSize));
   Structs[Name.lower()] = Structure;
if (!Parameters.empty() && Parameters.back().Vararg)
                        "' should be last in the list of parameters");
 
     MCAsmMacroParameter Parameter;
     if (parseIdentifier(Parameter.Name))
       return TokError("expected identifier in 'macro' directive");
 
     // Emit an error if two (or more) named parameters share the same name.
     for (const MCAsmMacroParameter& CurrParam : Parameters)
-      if (CurrParam.Name.equals_lower(Parameter.Name))
+      if (CurrParam.Name.equals_insensitive(Parameter.Name))
         return TokError("macro '" + Name + "' has multiple parameters"
                         " named '" + Parameter.Name + "'");
 
     if (Lexer.is(AsmToken::Colon)) {
       Lex();  // consume ':'
 
       if (parseOptionalToken(AsmToken::Equal)) {
         // Default value
         SMLoc ParamLoc;
 
         ParamLoc = Lexer.getLoc();
         if (parseMacroArgument(nullptr, Parameter.Value))
           return true;
       } else {
         SMLoc QualLoc;
         StringRef Qualifier;
 
         QualLoc = Lexer.getLoc();
         if (parseIdentifier(Qualifier))
           return Error(QualLoc, "missing parameter qualifier for "
                                 "'" +
                                     Parameter.Name + "' in macro '" + Name +
                                     "'");
 
-        if (Qualifier.equals_lower("req"))
+        if (Qualifier.equals_insensitive("req"))
           Parameter.Required = true;
-        else if (Qualifier.equals_lower("vararg"))
+        else if (Qualifier.equals_insensitive("vararg"))
           Parameter.Vararg = true;
         else
           return Error(QualLoc,
                        Qualifier + " is not a valid parameter qualifier for '" +
                            Parameter.Name + "' in macro '" + Name + "'");
       }
     }
 
     Parameters.push_back(std::move(Parameter));
 
     if (getLexer().is(AsmToken::Comma))
       Lex();
   }
 
   // Eat just the end of statement.
   Lexer.Lex();
 
   std::vector<std::string> Locals;
   if (getTok().is(AsmToken::Identifier) &&
-      getTok().getIdentifier().equals_lower("local")) {
+      getTok().getIdentifier().equals_insensitive("local")) {
     Lex(); // Eat the LOCAL directive.
 
     StringRef ID;
     while (true) {
       if (parseIdentifier(ID))
         return true;
       Locals.push_back(ID.lower());
 
while (true) {
 
     // Check whether we have reached the end of the file.
     if (getLexer().is(AsmToken::Eof))
       return Error(NameLoc, "no matching 'endm' in definition");
 
     // Otherwise, check whether we have reached the 'endm'... and determine if
     // this is a macro function.
     if (getLexer().is(AsmToken::Identifier)) {
-      if (getTok().getIdentifier().equals_lower("endm")) {
+      if (getTok().getIdentifier().equals_insensitive("endm")) {
         if (MacroDepth == 0) { // Outermost macro.
           EndToken = getTok();
           Lexer.Lex();
           if (getLexer().isNot(AsmToken::EndOfStatement))
             return TokError("unexpected token in '" + EndToken.getIdentifier() +
                             "' directive");
           break;
         } else {
           // Otherwise we just found the end of an inner macro.
           --MacroDepth;
         }
-      } else if (getTok().getIdentifier().equals_lower("exitm")) {
+      } else if (getTok().getIdentifier().equals_insensitive("exitm")) {
         if (MacroDepth == 0 && peekTok().isNot(AsmToken::EndOfStatement)) {
           IsMacroFunction = true;
         }
       } else if (isMacroLikeDirective()) {
         // We allow nested macros. Those aren't instantiated until the
         // outermost macro is expanded so just ignore them for now.
         ++MacroDepth;
       }
if (ExpectEqual)
       return TokError("expected text item parameter for 'ifidn' directive");
     return TokError("expected text item parameter for 'ifdif' directive");
   }
 
   TheCondStack.push_back(TheCondState);
   TheCondState.TheCond = AsmCond::IfCond;
   if (CaseInsensitive)
     TheCondState.CondMet =
-        ExpectEqual == (StringRef(String1).equals_lower(String2));
+        ExpectEqual == (StringRef(String1).equals_insensitive(String2));
   else
     TheCondState.CondMet = ExpectEqual == (String1 == String2);
   TheCondState.Ignore = !TheCondState.CondMet;
 
   return false;
 }
 
 /// parseDirectiveIfdef
if (parseTextItem(String2)) {
       if (ExpectEqual)
         return TokError(
             "expected text item parameter for 'elseifidn' directive");
       return TokError("expected text item parameter for 'elseifdif' directive");
     }
 
     if (CaseInsensitive)
       TheCondState.CondMet =
-          ExpectEqual == (StringRef(String1).equals_lower(String2));
+          ExpectEqual == (StringRef(String1).equals_insensitive(String2));
     else
       TheCondState.CondMet = ExpectEqual == (String1 == String2);
     TheCondState.Ignore = !TheCondState.CondMet;
   }
 
   return false;
 }
 
if (Lexer.isNot(AsmToken::EndOfStatement)) {
     if (parseToken(AsmToken::Comma))
       return addErrorSuffix(" in '.erridn' directive");
     Message = parseStringTo(AsmToken::EndOfStatement);
   }
   Lex();
 
   if (CaseInsensitive)
     TheCondState.CondMet =
-        ExpectEqual == (StringRef(String1).equals_lower(String2));
+        ExpectEqual == (StringRef(String1).equals_insensitive(String2));
   else
     TheCondState.CondMet = ExpectEqual == (String1 == String2);
   TheCondState.Ignore = !TheCondState.CondMet;
 
   if ((CaseInsensitive &&
-       ExpectEqual == StringRef(String1).equals_lower(String2)) ||
+       ExpectEqual == StringRef(String1).equals_insensitive(String2)) ||
       (ExpectEqual == (String1 == String2)))
     return Error(DirectiveLoc, Message);
   return false;
 }
 
 /// parseDirectiveErrorIfe
 ///   ::= .erre expression[, message]
 bool MasmParser::parseDirectiveErrorIfe(SMLoc DirectiveLoc, bool ExpectZero) {
bool IsMacroLike = StringSwitch<bool>(getTok().getIdentifier())
                            .CaseLower("while", true)
                            .CasesLower("for", "irp", true)
                            .CasesLower("forc", "irpc", true)
                            .Default(false);
     if (IsMacroLike)
       return true;
   }
   if (peekTok().is(AsmToken::Identifier) &&
-      peekTok().getIdentifier().equals_lower("macro"))
+      peekTok().getIdentifier().equals_insensitive("macro"))
     return true;
 
   return false;
 }
 
 MCAsmMacro *MasmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
   AsmToken EndToken, StartToken = getTok();
 
   unsigned NestLevel = 0;
   while (true) {
     // Check whether we have reached the end of the file.
     if (getLexer().is(AsmToken::Eof)) {
       printError(DirectiveLoc, "no matching 'endm' in definition");
       return nullptr;
     }
 
     if (isMacroLikeDirective())
       ++NestLevel;
 
     // Otherwise, check whether we have reached the endm.
     if (Lexer.is(AsmToken::Identifier) &&
-        getTok().getIdentifier().equals_lower("endm")) {
+        getTok().getIdentifier().equals_insensitive("endm")) {
       if (NestLevel == 0) {
         EndToken = getTok();
         Lex();
         if (Lexer.isNot(AsmToken::EndOfStatement)) {
           printError(getTok().getLoc(), "unexpected token in 'endm' directive");
           return nullptr;
         }
         break;
if (parseOptionalToken(AsmToken::Equal)) {
 
       QualLoc = Lexer.getLoc();
       if (parseIdentifier(Qualifier))
         return Error(QualLoc, "missing parameter qualifier for "
                               "'" +
                                   Parameter.Name + "' in '" + Dir +
                                   "' directive");
 
-      if (Qualifier.equals_lower("req"))
+      if (Qualifier.equals_insensitive("req"))
         Parameter.Required = true;
       else
         return Error(QualLoc,
                      Qualifier + " is not a valid parameter qualifier for '" +
                          Parameter.Name + "' in '" + Dir + "' directive");
     }
   }
 

 
 /// parseDirectiveEcho
 ///   ::= "echo" message
 bool MasmParser::parseDirectiveEcho() {
   // We're called before the directive is parsed, to avoid triggering lexical
   // substitutions in the message. Assert that the next token is the directive,
   // then eat it without using the Parser's Lex method.
   assert(getTok().is(AsmToken::Identifier) &&
-         getTok().getString().equals_lower("echo"));
+         getTok().getString().equals_insensitive("echo"));
   Lexer.Lex();
 
   std::string Message = parseStringTo(AsmToken::EndOfStatement);
   llvm::outs() << Message;
   if (!StringRef(Message).endswith("\n"))
     llvm::outs() << '\n';
   return false;
 }

llvm/lib/Option/OptTable.cpp

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

llvm/lib/ProfileData/InstrProfReader.cpp

 Error TextInstrProfReader::readHeader() {
   Symtab.reset(new InstrProfSymtab());
   bool IsIRInstr = false;
   bool IsEntryFirst = false;
   bool IsCS = false;
 
   while (Line->startswith(":")) {
     StringRef Str = Line->substr(1);
-    if (Str.equals_lower("ir"))
+    if (Str.equals_insensitive("ir"))
       IsIRInstr = true;
-    else if (Str.equals_lower("fe"))
+    else if (Str.equals_insensitive("fe"))
       IsIRInstr = false;
-    else if (Str.equals_lower("csir")) {
+    else if (Str.equals_insensitive("csir")) {
       IsIRInstr = true;
       IsCS = true;
-    } else if (Str.equals_lower("entry_first"))
+    } else if (Str.equals_insensitive("entry_first"))
       IsEntryFirst = true;
-    else if (Str.equals_lower("not_entry_first"))
+    else if (Str.equals_insensitive("not_entry_first"))
       IsEntryFirst = false;
     else
       return error(instrprof_error::bad_header);
     ++Line;
   }
   IsIRLevelProfile = IsIRInstr;
   InstrEntryBBEnabled = IsEntryFirst;
   HasCSIRLevelProfile = IsCS;

llvm/lib/Support/StringExtras.cpp

 /// StrInStrNoCase - Portable version of strcasestr.  Locates the first
 /// occurrence of string 's1' in string 's2', ignoring case.  Returns
 /// the offset of s2 in s1 or npos if s2 cannot be found.
 StringRef::size_type llvm::StrInStrNoCase(StringRef s1, StringRef s2) {
   size_t N = s2.size(), M = s1.size();
   if (N > M)
     return StringRef::npos;
   for (size_t i = 0, e = M - N + 1; i != e; ++i)
-    if (s1.substr(i, N).equals_lower(s2))
+    if (s1.substr(i, N).equals_insensitive(s2))
       return i;
   return StringRef::npos;
 }
 
 /// getToken - This function extracts one token from source, ignoring any
 /// leading characters that appear in the Delimiters string, and ending the
 /// token at any of the characters that appear in the Delimiters string.  If
 /// there are no tokens in the source string, an empty string is returned.

llvm/lib/Support/StringRef.cpp

for (size_t I = 0; I < Length; ++I) {
     unsigned char LHC = toLower(LHS[I]);
     unsigned char RHC = toLower(RHS[I]);
     if (LHC != RHC)
       return LHC < RHC ? -1 : 1;
   }
   return 0;
 }
 
-/// compare_lower - Compare strings, ignoring case.
-int StringRef::compare_lower(StringRef RHS) const {
+/// compare_insensitive - Compare strings, ignoring case.
+int StringRef::compare_insensitive(StringRef RHS) const {
   if (int Res = ascii_strncasecmp(Data, RHS.Data, std::min(Length, RHS.Length)))
     return Res;
   if (Length == RHS.Length)
     return 0;
   return Length < RHS.Length ? -1 : 1;
 }
 
 /// Check if this string starts with the given \p Prefix, ignoring case.
-bool StringRef::startswith_lower(StringRef Prefix) const {
+bool StringRef::startswith_insensitive(StringRef Prefix) const {
   return Length >= Prefix.Length &&
       ascii_strncasecmp(Data, Prefix.Data, Prefix.Length) == 0;
 }
 
 /// Check if this string ends with the given \p Suffix, ignoring case.
-bool StringRef::endswith_lower(StringRef Suffix) const {
+bool StringRef::endswith_insensitive(StringRef Suffix) const {
   return Length >= Suffix.Length &&
       ascii_strncasecmp(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
 }
 
-size_t StringRef::find_lower(char C, size_t From) const {
+size_t StringRef::find_insensitive(char C, size_t From) const {
   char L = toLower(C);
   return find_if([L](char D) { return toLower(D) == L; }, From);
 }
 
 /// compare_numeric - Compare strings, handle embedded numbers.
 int StringRef::compare_numeric(StringRef RHS) const {
   for (size_t I = 0, E = std::min(Length, RHS.Length); I != E; ++I) {
     // Check for sequences of digits.
do {
 
     // Otherwise skip the appropriate number of bytes.
     Start += BadCharSkip[Last];
   } while (Start < Stop);
 
   return npos;
 }
 
-size_t StringRef::find_lower(StringRef Str, size_t From) const {
+size_t StringRef::find_insensitive(StringRef Str, size_t From) const {
   StringRef This = substr(From);
   while (This.size() >= Str.size()) {
-    if (This.startswith_lower(Str))
+    if (This.startswith_insensitive(Str))
       return From;
     This = This.drop_front();
     ++From;
   }
   return npos;
 }
 
-size_t StringRef::rfind_lower(char C, size_t From) const {
+size_t StringRef::rfind_insensitive(char C, size_t From) const {
   From = std::min(From, Length);
   size_t i = From;
   while (i != 0) {
     --i;
     if (toLower(Data[i]) == toLower(C))
       return i;
   }
   return npos;
size_t StringRef::rfind(StringRef Str) const {
   for (size_t i = Length - N + 1, e = 0; i != e;) {
     --i;
     if (substr(i, N).equals(Str))
       return i;
   }
   return npos;
 }
 
-size_t StringRef::rfind_lower(StringRef Str) const {
+size_t StringRef::rfind_insensitive(StringRef Str) const {
   size_t N = Str.size();
   if (N > Length)
     return npos;
   for (size_t i = Length - N + 1, e = 0; i != e;) {
     --i;
-    if (substr(i, N).equals_lower(Str))
+    if (substr(i, N).equals_insensitive(Str))
       return i;
   }
   return npos;
 }
 
 /// find_first_of - Find the first character in the string that is in \arg
 /// Chars, or npos if not found.
 ///

llvm/lib/Support/VirtualFileSystem.cpp

class llvm::vfs::RedirectingFileSystemParser {
 
   // false on error
   bool parseScalarBool(yaml::Node *N, bool &Result) {
     SmallString<5> Storage;
     StringRef Value;
     if (!parseScalarString(N, Value, Storage))
       return false;
 
-    if (Value.equals_lower("true") || Value.equals_lower("on") ||
-        Value.equals_lower("yes") || Value == "1") {
+    if (Value.equals_insensitive("true") || Value.equals_insensitive("on") ||
+        Value.equals_insensitive("yes") || Value == "1") {
       Result = true;
       return true;
-    } else if (Value.equals_lower("false") || Value.equals_lower("off") ||
-               Value.equals_lower("no") || Value == "0") {
+    } else if (Value.equals_insensitive("false") || Value.equals_insensitive("off") ||
+               Value.equals_insensitive("no") || Value == "0") {
       Result = false;
       return true;
     }
 
     error(N, "expected boolean value");
     return false;
   }
 

llvm/lib/Support/Windows/Path.inc

static bool isReservedName(StringRef path) {
 
   // First, check to see if this is a device namespace, which always
   // starts with \\.\, since device namespaces are not legal file paths.
   if (path.startswith("\\\\.\\"))
     return true;
 
   // Then compare against the list of ancient reserved names.
   for (size_t i = 0; i < array_lengthof(sReservedNames); ++i) {
-    if (path.equals_lower(sReservedNames[i]))
+    if (path.equals_insensitive(sReservedNames[i]))
       return true;
   }
 
   // The path isn't what we consider reserved.
   return false;
 }
 
 static file_type file_type_from_attrs(DWORD Attrs) {

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

if (Constraint.size() == 1) {
     if (PC != PredicateConstraint::Invalid) {
       if (!VT.isScalableVector() || VT.getVectorElementType() != MVT::i1)
         return std::make_pair(0U, nullptr);
       bool restricted = (PC == PredicateConstraint::Upl);
       return restricted ? std::make_pair(0U, &AArch64::PPR_3bRegClass)
                         : std::make_pair(0U, &AArch64::PPRRegClass);
     }
   }
-  if (StringRef("{cc}").equals_lower(Constraint))
+  if (StringRef("{cc}").equals_insensitive(Constraint))
     return std::make_pair(unsigned(AArch64::NZCV), &AArch64::CCRRegClass);
 
   // Use the default implementation in TargetLowering to convert the register
   // constraint into a member of a register class.
   std::pair<unsigned, const TargetRegisterClass *> Res;
   Res = TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
 
   // Not found as a standard register?

llvm/lib/Target/AArch64/AArch64MachineFunctionInfo.cpp

if (!F.hasFnAttribute("sign-return-address-key")) {
     if (const auto *BKey = mdconst::extract_or_null<ConstantInt>(
             F.getParent()->getModuleFlag("sign-return-address-with-bkey")))
       return BKey->getZExtValue();
     return false;
   }
 
   const StringRef Key =
       F.getFnAttribute("sign-return-address-key").getValueAsString();
-  assert(Key.equals_lower("a_key") || Key.equals_lower("b_key"));
-  return Key.equals_lower("b_key");
+  assert(Key.equals_insensitive("a_key") || Key.equals_insensitive("b_key"));
+  return Key.equals_insensitive("b_key");
 }
 
 AArch64FunctionInfo::AArch64FunctionInfo(MachineFunction &MF) : MF(MF) {
   // If we already know that the function doesn't have a redzone, set
   // HasRedZone here.
   if (MF.getFunction().hasFnAttribute(Attribute::NoRedZone))
     HasRedZone = false;
 
   const Function &F = MF.getFunction();
   std::tie(SignReturnAddress, SignReturnAddressAll) = GetSignReturnAddress(F);
   SignWithBKey = ShouldSignWithBKey(F);
 
   if (!F.hasFnAttribute("branch-target-enforcement")) {
     if (const auto *BTE = mdconst::extract_or_null<ConstantInt>(
             F.getParent()->getModuleFlag("branch-target-enforcement")))
       BranchTargetEnforcement = BTE->getZExtValue();
     return;
   }
 
   const StringRef BTIEnable = F.getFnAttribute("branch-target-enforcement").getValueAsString();
-  assert(BTIEnable.equals_lower("true") || BTIEnable.equals_lower("false"));
-  BranchTargetEnforcement = BTIEnable.equals_lower("true");
+  assert(BTIEnable.equals_insensitive("true") || BTIEnable.equals_insensitive("false"));
+  BranchTargetEnforcement = BTIEnable.equals_insensitive("true");
 }
 
 bool AArch64FunctionInfo::shouldSignReturnAddress(bool SpillsLR) const {
   if (!SignReturnAddress)
     return false;
   if (SignReturnAddressAll)
     return true;
   return SpillsLR;
 }
 
 bool AArch64FunctionInfo::shouldSignReturnAddress() const {
   return shouldSignReturnAddress(llvm::any_of(
       MF.getFrameInfo().getCalleeSavedInfo(),
       [](const auto &Info) { return Info.getReg() == AArch64::LR; }));
 }

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

else if (Parser.getTok().isNot(AsmToken::Comma)) {
     return MatchOperand_Success;
   }
 
   // Eat ','
   Parser.Lex();
 
   // The optional operand must be "lsl #N" where N is non-negative.
   if (!Parser.getTok().is(AsmToken::Identifier) ||
-      !Parser.getTok().getIdentifier().equals_lower("lsl")) {
+      !Parser.getTok().getIdentifier().equals_insensitive("lsl")) {
     Error(Parser.getTok().getLoc(), "only 'lsl #+N' valid after immediate");
     return MatchOperand_ParseFail;
   }
 
   // Eat 'lsl'
   Parser.Lex();
 
   parseOptionalToken(AsmToken::Hash);

 }
 
 bool AArch64AsmParser::parseOptionalMulOperand(OperandVector &Operands) {
   MCAsmParser &Parser = getParser();
 
   // Some SVE instructions have a decoration after the immediate, i.e.
   // "mul vl". We parse them here and add tokens, which must be present in the
   // asm string in the tablegen instruction.
-  bool NextIsVL = Parser.getLexer().peekTok().getString().equals_lower("vl");
+  bool NextIsVL = Parser.getLexer().peekTok().getString().equals_insensitive("vl");
   bool NextIsHash = Parser.getLexer().peekTok().is(AsmToken::Hash);
-  if (!Parser.getTok().getString().equals_lower("mul") ||
+  if (!Parser.getTok().getString().equals_insensitive("mul") ||
       !(NextIsVL || NextIsHash))
     return true;
 
   Operands.push_back(
     AArch64Operand::CreateToken("mul", false, getLoc(), getContext()));
   Parser.Lex(); // Eat the "mul"
 
   if (NextIsVL) {
if (!ExtensionString.empty())
     ExtensionString.split(RequestedExtensions, '+');
 
   ExpandCryptoAEK(ID, RequestedExtensions);
 
   FeatureBitset Features = STI.getFeatureBits();
   for (auto Name : RequestedExtensions) {
     bool EnableFeature = true;
 
-    if (Name.startswith_lower("no")) {
+    if (Name.startswith_insensitive("no")) {
       EnableFeature = false;
       Name = Name.substr(2);
     }
 
     for (const auto &Extension : ExtensionMap) {
       if (Extension.Name != Name)
         continue;
 
bool AArch64AsmParser::parseDirectiveArchExtension(SMLoc L) {
 
   StringRef Name = getParser().parseStringToEndOfStatement().trim();
 
   if (parseToken(AsmToken::EndOfStatement,
                  "unexpected token in '.arch_extension' directive"))
     return true;
 
   bool EnableFeature = true;
-  if (Name.startswith_lower("no")) {
+  if (Name.startswith_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) {
 
   FeatureBitset Features = STI.getFeatureBits();
   for (auto Name : RequestedExtensions) {
     // Advance source location past '+'.
     CurLoc = incrementLoc(CurLoc, 1);
 
     bool EnableFeature = true;
 
-    if (Name.startswith_lower("no")) {
+    if (Name.startswith_insensitive("no")) {
       EnableFeature = false;
       Name = Name.substr(2);
     }
 
     bool FoundExtension = false;
     for (const auto &Extension : ExtensionMap) {
       if (Extension.Name != Name)
         continue;

llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp

 }
 
 bool AMDGPULibCalls::fold_wavefrontsize(CallInst *CI, IRBuilder<> &B) {
   if (!TM)
     return false;
 
   StringRef CPU = TM->getTargetCPU();
   StringRef Features = TM->getTargetFeatureString();
-  if ((CPU.empty() || CPU.equals_lower("generic")) &&
+  if ((CPU.empty() || CPU.equals_insensitive("generic")) &&
       (Features.empty() ||
-       Features.find_lower("wavefrontsize") == StringRef::npos))
+       Features.find_insensitive("wavefrontsize") == StringRef::npos))
     return false;
 
   Function *F = CI->getParent()->getParent();
   const GCNSubtarget &ST = TM->getSubtarget<GCNSubtarget>(*F);
   unsigned N = ST.getWavefrontSize();
 
   LLVM_DEBUG(errs() << "AMDIC: fold_wavefrontsize (" << *CI << ") with "
                << N << "\n");

llvm/lib/Target/AMDGPU/AMDGPUSubtarget.cpp

GCNSubtarget::initializeSubtargetDependencies(const Triple &TT,
 
   // Turn on features that HSA ABI requires. Also turn on FlatForGlobal by default
   if (isAmdHsaOS())
     FullFS += "+flat-for-global,+unaligned-access-mode,+trap-handler,";
 
   FullFS += "+enable-prt-strict-null,"; // This is overridden by a disable in FS
 
   // Disable mutually exclusive bits.
-  if (FS.find_lower("+wavefrontsize") != StringRef::npos) {
-    if (FS.find_lower("wavefrontsize16") == StringRef::npos)
+  if (FS.find_insensitive("+wavefrontsize") != StringRef::npos) {
+    if (FS.find_insensitive("wavefrontsize16") == StringRef::npos)
       FullFS += "-wavefrontsize16,";
-    if (FS.find_lower("wavefrontsize32") == StringRef::npos)
+    if (FS.find_insensitive("wavefrontsize32") == StringRef::npos)
       FullFS += "-wavefrontsize32,";
-    if (FS.find_lower("wavefrontsize64") == StringRef::npos)
+    if (FS.find_insensitive("wavefrontsize64") == StringRef::npos)
       FullFS += "-wavefrontsize64,";
   }
 
   FullFS += FS;
 
   ParseSubtargetFeatures(GPU, /*TuneCPU*/ GPU, FullFS);
 
   // Implement the "generic" processors, which acts as the default when no

llvm/lib/Target/ARM/ARMISelLowering.cpp

if (Constraint[0] == 'T') {
       }
     }
     break;
 
   default:
     break;
   }
 
-  if (StringRef("{cc}").equals_lower(Constraint))
+  if (StringRef("{cc}").equals_insensitive(Constraint))
     return std::make_pair(unsigned(ARM::CPSR), &ARM::CCRRegClass);
 
   return TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
 }
 
 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
 /// vector.  If it is invalid, don't add anything to Ops.
 void ARMTargetLowering::LowerAsmOperandForConstraint(SDValue Op,

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

 ARMAsmParser::parseTraceSyncBarrierOptOperand(OperandVector &Operands) {
   MCAsmParser &Parser = getParser();
   SMLoc S = Parser.getTok().getLoc();
   const AsmToken &Tok = Parser.getTok();
 
   if (Tok.isNot(AsmToken::Identifier))
      return MatchOperand_NoMatch;
 
-  if (!Tok.getString().equals_lower("csync"))
+  if (!Tok.getString().equals_insensitive("csync"))
     return MatchOperand_NoMatch;
 
   Parser.Lex(); // Eat identifier token.
 
   Operands.push_back(ARMOperand::CreateTraceSyncBarrierOpt(ARM_TSB::CSYNC, S));
   return MatchOperand_Success;
 }
 
 /// parseInstSyncBarrierOptOperand - Try to parse ISB inst sync barrier options.
 OperandMatchResultTy
 ARMAsmParser::parseInstSyncBarrierOptOperand(OperandVector &Operands) {
   MCAsmParser &Parser = getParser();
   SMLoc S = Parser.getTok().getLoc();
   const AsmToken &Tok = Parser.getTok();
   unsigned Opt;
 
   if (Tok.is(AsmToken::Identifier)) {
     StringRef OptStr = Tok.getString();
 
-    if (OptStr.equals_lower("sy"))
+    if (OptStr.equals_insensitive("sy"))
       Opt = ARM_ISB::SY;
     else
       return MatchOperand_NoMatch;
 
     Parser.Lex(); // Eat identifier token.
   } else if (Tok.is(AsmToken::Hash) ||
              Tok.is(AsmToken::Dollar) ||
              Tok.is(AsmToken::Integer)) {
if (!ExpectLabel) {
         return false;
       int Res = tryParseShiftRegister(Operands);
       if (Res == 0) // success
         return false;
       else if (Res == -1) // irrecoverable error
         return true;
       // If this is VMRS, check for the apsr_nzcv operand.
       if (Mnemonic == "vmrs" &&
-          Parser.getTok().getString().equals_lower("apsr_nzcv")) {
+          Parser.getTok().getString().equals_insensitive("apsr_nzcv")) {
         S = Parser.getTok().getLoc();
         Parser.Lex();
         Operands.push_back(ARMOperand::CreateToken("APSR_nzcv", S));
         return false;
       }
     }
 
     // Fall though for the Identifier case that is not a register or a
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_lower("no")) {
+  if (Name.startswith_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/Hexagon/AsmParser/HexagonAsmParser.cpp

while (true) {
     if (!Parser.getTok().is(AsmToken::Colon))
       return false;
     Lex();
     char const *MemNoShuffMsg =
         "invalid instruction packet: mem_noshuf specifier not "
         "supported with this architecture";
     StringRef Option = Parser.getTok().getString();
     auto IDLoc = Parser.getTok().getLoc();
-    if (Option.compare_lower("endloop01") == 0) {
+    if (Option.compare_insensitive("endloop01") == 0) {
       HexagonMCInstrInfo::setInnerLoop(MCB);
       HexagonMCInstrInfo::setOuterLoop(MCB);
-    } else if (Option.compare_lower("endloop0") == 0) {
+    } else if (Option.compare_insensitive("endloop0") == 0) {
       HexagonMCInstrInfo::setInnerLoop(MCB);
-    } else if (Option.compare_lower("endloop1") == 0) {
+    } else if (Option.compare_insensitive("endloop1") == 0) {
       HexagonMCInstrInfo::setOuterLoop(MCB);
-    } else if (Option.compare_lower("mem_noshuf") == 0) {
+    } else if (Option.compare_insensitive("mem_noshuf") == 0) {
       if (getSTI().getFeatureBits()[Hexagon::FeatureMemNoShuf])
         HexagonMCInstrInfo::setMemReorderDisabled(MCB);
       else
         return getParser().Error(IDLoc, MemNoShuffMsg);
-    } else if (Option.compare_lower("mem_no_order") == 0) {
+    } else if (Option.compare_insensitive("mem_no_order") == 0) {
       // Nothing.
     } else
       return getParser().Error(IDLoc, llvm::Twine("'") + Option +
                                           "' is not a valid bundle option");
     Lex();
   }
 }
 

 
 static bool previousEqual(OperandVector &Operands, size_t Index,
                           StringRef String) {
   if (Index >= Operands.size())
     return false;
   MCParsedAsmOperand &Operand = *Operands[Operands.size() - Index - 1];
   if (!Operand.isToken())
     return false;
-  return static_cast<HexagonOperand &>(Operand).getToken().equals_lower(String);
+  return static_cast<HexagonOperand &>(Operand).getToken().equals_insensitive(String);
 }
 
 static bool previousIsLoop(OperandVector &Operands, size_t Index) {
   return previousEqual(Operands, Index, "loop0") ||
          previousEqual(Operands, Index, "loop1") ||
          previousEqual(Operands, Index, "sp1loop0") ||
          previousEqual(Operands, Index, "sp2loop0") ||
          previousEqual(Operands, Index, "sp3loop0");
if (!ErrorMissingParenthesis)
           static char const *LParen = "(";
           static char const *RParen = ")";
           Operands.push_back(
               HexagonOperand::CreateToken(getContext(), LParen, Begin));
           Operands.push_back(
               HexagonOperand::CreateReg(getContext(), Register, Begin, End));
           const AsmToken &MaybeDotNew = Lexer.getTok();
           if (MaybeDotNew.is(AsmToken::TokenKind::Identifier) &&
-              MaybeDotNew.getString().equals_lower(".new"))
+              MaybeDotNew.getString().equals_insensitive(".new"))
             splitIdentifier(Operands);
           Operands.push_back(
               HexagonOperand::CreateToken(getContext(), RParen, Begin));
           return false;
         }
         if (previousEqual(Operands, 0, "!") &&
             previousEqual(Operands, 1, "if")) {
           if (WarnMissingParenthesis)
             Warning(Begin, "Missing parenthesis around predicate register");
           static char const *LParen = "(";
           static char const *RParen = ")";
           Operands.insert(Operands.end() - 1, HexagonOperand::CreateToken(
                                                   getContext(), LParen, Begin));
           Operands.push_back(
               HexagonOperand::CreateReg(getContext(), Register, Begin, End));
           const AsmToken &MaybeDotNew = Lexer.getTok();
           if (MaybeDotNew.is(AsmToken::TokenKind::Identifier) &&
-              MaybeDotNew.getString().equals_lower(".new"))
+              MaybeDotNew.getString().equals_insensitive(".new"))
             splitIdentifier(Operands);
           Operands.push_back(
               HexagonOperand::CreateToken(getContext(), RParen, Begin));
           return false;
         }
         break;
       }
     Operands.push_back(

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCDuplexInfo.cpp

if (MIbG == HexagonII::HSIG_L2) {
     if ((MIb.getNumOperands() > 1) && MIb.getOperand(1).isReg() &&
         (MIb.getOperand(1).getReg() == Hexagon::R31))
       return false;
     if ((MIb.getNumOperands() > 0) && MIb.getOperand(0).isReg() &&
         (MIb.getOperand(0).getReg() == Hexagon::R31))
       return false;
   }
 
-  if (STI.getCPU().equals_lower("hexagonv5") ||
-      STI.getCPU().equals_lower("hexagonv55") ||
-      STI.getCPU().equals_lower("hexagonv60")) {
+  if (STI.getCPU().equals_insensitive("hexagonv5") ||
+      STI.getCPU().equals_insensitive("hexagonv55") ||
+      STI.getCPU().equals_insensitive("hexagonv60")) {
     // If a store appears, it must be in slot 0 (MIa) 1st, and then slot 1 (MIb);
     //   therefore, not duplexable if slot 1 is a store, and slot 0 is not.
     if ((MIbG == HexagonII::HSIG_S1) || (MIbG == HexagonII::HSIG_S2)) {
       if ((MIaG != HexagonII::HSIG_S1) && (MIaG != HexagonII::HSIG_S2))
         return false;
     }
   }
 

llvm/lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp

std::unique_ptr<LanaiOperand> LanaiAsmParser::parseIdentifier() {
   if (Lexer.getKind() != AsmToken::Identifier)
     return nullptr;
 
   StringRef Identifier;
   if (Parser.parseIdentifier(Identifier))
     return nullptr;
 
   // Check if identifier has a modifier
-  if (Identifier.equals_lower("hi"))
+  if (Identifier.equals_insensitive("hi"))
     Kind = LanaiMCExpr::VK_Lanai_ABS_HI;
-  else if (Identifier.equals_lower("lo"))
+  else if (Identifier.equals_insensitive("lo"))
     Kind = LanaiMCExpr::VK_Lanai_ABS_LO;
 
   // If the identifier corresponds to a variant then extract the real
   // identifier.
   if (Kind != LanaiMCExpr::VK_Lanai_None) {
     if (Lexer.getKind() != AsmToken::LParen) {
       Error(Lexer.getLoc(), "Expected '('");
       return nullptr;

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

OperandMatchResultTy MSP430AsmParser::tryParseRegister(unsigned &RegNo,
   }
 
   return MatchOperand_ParseFail;
 }
 
 bool MSP430AsmParser::parseJccInstruction(ParseInstructionInfo &Info,
                                           StringRef Name, SMLoc NameLoc,
                                           OperandVector &Operands) {
-  if (!Name.startswith_lower("j"))
+  if (!Name.startswith_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_lower(".w"))
+  if (Name.endswith_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

 bool PPCAsmParser::MatchRegisterName(unsigned &RegNo, int64_t &IntVal) {
   if (getParser().getTok().is(AsmToken::Percent))
     getParser().Lex(); // Eat the '%'.
 
   if (!getParser().getTok().is(AsmToken::Identifier))
     return true;
 
   StringRef Name = getParser().getTok().getString();
-  if (Name.equals_lower("lr")) {
+  if (Name.equals_insensitive("lr")) {
     RegNo = isPPC64() ? PPC::LR8 : PPC::LR;
     IntVal = 8;
-  } else if (Name.equals_lower("ctr")) {
+  } else if (Name.equals_insensitive("ctr")) {
     RegNo = isPPC64() ? PPC::CTR8 : PPC::CTR;
     IntVal = 9;
-  } else if (Name.equals_lower("vrsave")) {
+  } else if (Name.equals_insensitive("vrsave")) {
     RegNo = PPC::VRSAVE;
     IntVal = 256;
-  } else if (Name.startswith_lower("r") &&
+  } else if (Name.startswith_insensitive("r") &&
              !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
     RegNo = isPPC64() ? XRegs[IntVal] : RRegs[IntVal];
-  } else if (Name.startswith_lower("f") &&
+  } else if (Name.startswith_insensitive("f") &&
              !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
     RegNo = FRegs[IntVal];
-  } else if (Name.startswith_lower("vs") &&
+  } else if (Name.startswith_insensitive("vs") &&
              !Name.substr(2).getAsInteger(10, IntVal) && IntVal < 64) {
     RegNo = VSRegs[IntVal];
-  } else if (Name.startswith_lower("v") &&
+  } else if (Name.startswith_insensitive("v") &&
              !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
     RegNo = VRegs[IntVal];
-  } else if (Name.startswith_lower("cr") &&
+  } else if (Name.startswith_insensitive("cr") &&
              !Name.substr(2).getAsInteger(10, IntVal) && IntVal < 8) {
     RegNo = CRRegs[IntVal];
   } else
     return true;
   getParser().Lex();
   return false;
 }
 

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

PPCTargetLowering::getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
   // the AsmName field from *RegisterInfo.td, then this would not be necessary.
   if (R.first && VT == MVT::i64 && Subtarget.isPPC64() &&
       PPC::GPRCRegClass.contains(R.first))
     return std::make_pair(TRI->getMatchingSuperReg(R.first,
                             PPC::sub_32, &PPC::G8RCRegClass),
                           &PPC::G8RCRegClass);
 
   // GCC accepts 'cc' as an alias for 'cr0', and we need to do the same.
-  if (!R.second && StringRef("{cc}").equals_lower(Constraint)) {
+  if (!R.second && StringRef("{cc}").equals_insensitive(Constraint)) {
     R.first = PPC::CR0;
     R.second = &PPC::CRRCRegClass;
   }
   // FIXME: This warning should ideally be emitted in the front end.
   const auto &TM = getTargetMachine();
   if (Subtarget.isAIXABI() && !TM.getAIXExtendedAltivecABI()) {
     if (((R.first >= PPC::V20 && R.first <= PPC::V31) ||
          (R.first >= PPC::VF20 && R.first <= PPC::VF31)) &&

llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp

bool PPCTTIImpl::mightUseCTR(BasicBlock *BB, TargetLibraryInfo *LibInfo,
   // Loop through the inline asm constraints and look for something that
   // clobbers ctr.
   auto asmClobbersCTR = [](InlineAsm *IA) {
     InlineAsm::ConstraintInfoVector CIV = IA->ParseConstraints();
     for (unsigned i = 0, ie = CIV.size(); i < ie; ++i) {
       InlineAsm::ConstraintInfo &C = CIV[i];
       if (C.Type != InlineAsm::isInput)
         for (unsigned j = 0, je = C.Codes.size(); j < je; ++j)
-          if (StringRef(C.Codes[j]).equals_lower("{ctr}"))
+          if (StringRef(C.Codes[j]).equals_insensitive("{ctr}"))
             return true;
     }
     return false;
   };
 
   auto isLargeIntegerTy = [](bool Is32Bit, Type *Ty) {
     if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
       return ITy->getBitWidth() > (Is32Bit ? 32U : 64U);

llvm/lib/Target/Sparc/AsmParser/SparcAsmParser.cpp

if (Tok.is(AsmToken::Identifier)) {
     }
 
     if (name.equals("y")) {
       RegNo = Sparc::Y;
       RegKind = SparcOperand::rk_Special;
       return true;
     }
 
-    if (name.substr(0, 3).equals_lower("asr")
+    if (name.substr(0, 3).equals_insensitive("asr")
         && !name.substr(3).getAsInteger(10, intVal)
         && intVal > 0 && intVal < 32) {
       RegNo = ASRRegs[intVal];
       RegKind = SparcOperand::rk_Special;
       return true;
     }
 
     // %fprs is an alias of %asr6.
if (Tok.is(AsmToken::Identifier)) {
     if (name.equals("xcc")) {
       // FIXME:: check 64bit.
       RegNo = Sparc::ICC;
       RegKind = SparcOperand::rk_Special;
       return true;
     }
 
     // %fcc0 - %fcc3
-    if (name.substr(0, 3).equals_lower("fcc")
+    if (name.substr(0, 3).equals_insensitive("fcc")
         && !name.substr(3).getAsInteger(10, intVal)
         && intVal < 4) {
       // FIXME: check 64bit and  handle %fcc1 - %fcc3
       RegNo = Sparc::FCC0 + intVal;
       RegKind = SparcOperand::rk_Special;
       return true;
     }
 
     // %g0 - %g7
-    if (name.substr(0, 1).equals_lower("g")
+    if (name.substr(0, 1).equals_insensitive("g")
         && !name.substr(1).getAsInteger(10, intVal)
         && intVal < 8) {
       RegNo = IntRegs[intVal];
       RegKind = SparcOperand::rk_IntReg;
       return true;
     }
     // %o0 - %o7
-    if (name.substr(0, 1).equals_lower("o")
+    if (name.substr(0, 1).equals_insensitive("o")
         && !name.substr(1).getAsInteger(10, intVal)
         && intVal < 8) {
       RegNo = IntRegs[8 + intVal];
       RegKind = SparcOperand::rk_IntReg;
       return true;
     }
-    if (name.substr(0, 1).equals_lower("l")
+    if (name.substr(0, 1).equals_insensitive("l")
         && !name.substr(1).getAsInteger(10, intVal)
         && intVal < 8) {
       RegNo = IntRegs[16 + intVal];
       RegKind = SparcOperand::rk_IntReg;
       return true;
     }
-    if (name.substr(0, 1).equals_lower("i")
+    if (name.substr(0, 1).equals_insensitive("i")
         && !name.substr(1).getAsInteger(10, intVal)
         && intVal < 8) {
       RegNo = IntRegs[24 + intVal];
       RegKind = SparcOperand::rk_IntReg;
       return true;
     }
     // %f0 - %f31
-    if (name.substr(0, 1).equals_lower("f")
+    if (name.substr(0, 1).equals_insensitive("f")
         && !name.substr(1, 2).getAsInteger(10, intVal) && intVal < 32) {
       RegNo = FloatRegs[intVal];
       RegKind = SparcOperand::rk_FloatReg;
       return true;
     }
     // %f32 - %f62
-    if (name.substr(0, 1).equals_lower("f")
+    if (name.substr(0, 1).equals_insensitive("f")
         && !name.substr(1, 2).getAsInteger(10, intVal)
         && intVal >= 32 && intVal <= 62 && (intVal % 2 == 0)) {
       // FIXME: Check V9
       RegNo = DoubleRegs[intVal/2];
       RegKind = SparcOperand::rk_DoubleReg;
       return true;
     }
 
     // %r0 - %r31
-    if (name.substr(0, 1).equals_lower("r")
+    if (name.substr(0, 1).equals_insensitive("r")
         && !name.substr(1, 2).getAsInteger(10, intVal) && intVal < 31) {
       RegNo = IntRegs[intVal];
       RegKind = SparcOperand::rk_IntReg;
       return true;
     }
 
     // %c0 - %c31
-    if (name.substr(0, 1).equals_lower("c")
+    if (name.substr(0, 1).equals_insensitive("c")
         && !name.substr(1).getAsInteger(10, intVal)
         && intVal < 32) {
       RegNo = CoprocRegs[intVal];
       RegKind = SparcOperand::rk_CoprocReg;
       return true;
     }
 
     if (name.equals("tpc")) {

llvm/lib/Target/Sparc/LeonPasses.cpp

for (auto MFI = MF.begin(), E = MF.end(); MFI != E; ++MFI) {
     for (auto MBBI = MBB.begin(), E = MBB.end(); MBBI != E; ++MBBI) {
       MachineInstr &MI = *MBBI;
       unsigned Opcode = MI.getOpcode();
       if (Opcode == SP::CALL && MI.getNumOperands() > 0) {
         MachineOperand &MO = MI.getOperand(0);
 
         if (MO.isGlobal()) {
           StringRef FuncName = MO.getGlobal()->getName();
-          if (FuncName.compare_lower("fesetround") == 0) {
+          if (FuncName.compare_insensitive("fesetround") == 0) {
             errs() << "Error: You are using the detectroundchange "
                       "option to detect rounding changes that will "
                       "cause LEON errata. The only way to fix this "
                       "is to remove the call to fesetround from "
                       "the source code.\n";
           }
         }
       }

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

#include "WebAssemblyGenAsmMatcher.inc"
   }
 
   bool parseSpecialFloatMaybe(bool IsNegative, OperandVector &Operands) {
     if (Lexer.isNot(AsmToken::Identifier))
       return true;
     auto &Flt = Lexer.getTok();
     auto S = Flt.getString();
     double Val;
-    if (S.compare_lower("infinity") == 0) {
+    if (S.compare_insensitive("infinity") == 0) {
       Val = std::numeric_limits<double>::infinity();
-    } else if (S.compare_lower("nan") == 0) {
+    } else if (S.compare_insensitive("nan") == 0) {
       Val = std::numeric_limits<double>::quiet_NaN();
     } else {
       return true;
     }
     if (IsNegative)
       Val = -Val;
     Operands.push_back(std::make_unique<WebAssemblyOperand>(
         WebAssemblyOperand::Float, Flt.getLoc(), Flt.getEndLoc(),

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

 bool X86AsmParser::ParseIntelNamedOperator(StringRef Name,
                                            IntelExprStateMachine &SM,
                                            bool &ParseError, SMLoc &End) {
   // A named operator should be either lower or upper case, but not a mix...
   // except in MASM, which uses full case-insensitivity.
   if (Name.compare(Name.lower()) && Name.compare(Name.upper()) &&
       !getParser().isParsingMasm())
     return false;
-  if (Name.equals_lower("not")) {
+  if (Name.equals_insensitive("not")) {
     SM.onNot();
-  } else if (Name.equals_lower("or")) {
+  } else if (Name.equals_insensitive("or")) {
     SM.onOr();
-  } else if (Name.equals_lower("shl")) {
+  } else if (Name.equals_insensitive("shl")) {
     SM.onLShift();
-  } else if (Name.equals_lower("shr")) {
+  } else if (Name.equals_insensitive("shr")) {
     SM.onRShift();
-  } else if (Name.equals_lower("xor")) {
+  } else if (Name.equals_insensitive("xor")) {
     SM.onXor();
-  } else if (Name.equals_lower("and")) {
+  } else if (Name.equals_insensitive("and")) {
     SM.onAnd();
-  } else if (Name.equals_lower("mod")) {
+  } else if (Name.equals_insensitive("mod")) {
     SM.onMod();
-  } else if (Name.equals_lower("offset")) {
+  } else if (Name.equals_insensitive("offset")) {
     SMLoc OffsetLoc = getTok().getLoc();
     const MCExpr *Val = nullptr;
     StringRef ID;
     InlineAsmIdentifierInfo Info;
     ParseError = ParseIntelOffsetOperator(Val, ID, Info, End);
     if (ParseError)
       return true;
     StringRef ErrMsg;
     ParseError =
         SM.onOffset(Val, OffsetLoc, ID, Info, isParsingMSInlineAsm(), ErrMsg);
     if (ParseError)
       return Error(SMLoc::getFromPointer(Name.data()), ErrMsg);
   } else {
     return false;
   }
-  if (!Name.equals_lower("offset"))
+  if (!Name.equals_insensitive("offset"))
     End = consumeToken();
   return true;
 }
 bool X86AsmParser::ParseMasmNamedOperator(StringRef Name,
                                           IntelExprStateMachine &SM,
                                           bool &ParseError, SMLoc &End) {
-  if (Name.equals_lower("eq")) {
+  if (Name.equals_insensitive("eq")) {
     SM.onEq();
-  } else if (Name.equals_lower("ne")) {
+  } else if (Name.equals_insensitive("ne")) {
     SM.onNE();
-  } else if (Name.equals_lower("lt")) {
+  } else if (Name.equals_insensitive("lt")) {
     SM.onLT();
-  } else if (Name.equals_lower("le")) {
+  } else if (Name.equals_insensitive("le")) {
     SM.onLE();
-  } else if (Name.equals_lower("gt")) {
+  } else if (Name.equals_insensitive("gt")) {
     SM.onGT();
-  } else if (Name.equals_lower("ge")) {
+  } else if (Name.equals_insensitive("ge")) {
     SM.onGE();
   } else {
     return false;
   }
   End = consumeToken();
   return true;
 }
 
case AsmToken::Identifier: {
           }
           break;
         }
       }
       // (MASM only) <TYPE> PTR operator
       if (Parser.isParsingMasm()) {
         const AsmToken &NextTok = getLexer().peekTok();
         if (NextTok.is(AsmToken::Identifier) &&
-            NextTok.getIdentifier().equals_lower("ptr")) {
+            NextTok.getIdentifier().equals_insensitive("ptr")) {
           AsmTypeInfo Info;
           if (Parser.lookUpType(Identifier, Info))
             return Error(Tok.getLoc(), "unknown type");
           SM.onCast(Info);
           // Eat type and PTR.
           consumeToken();
           End = consumeToken();
           break;
if (Name == "{") {
         // FIXME: The mnemonic won't match correctly if its not in lower case.
         Name = Parser.getTok().getString();
         Parser.Lex();
       }
       continue;
     }
     // Parse MASM style pseudo prefixes.
     if (isParsingMSInlineAsm()) {
-      if (Name.equals_lower("vex"))
+      if (Name.equals_insensitive("vex"))
         ForcedVEXEncoding = VEXEncoding_VEX;
-      else if (Name.equals_lower("vex2"))
+      else if (Name.equals_insensitive("vex2"))
         ForcedVEXEncoding = VEXEncoding_VEX2;
-      else if (Name.equals_lower("vex3"))
+      else if (Name.equals_insensitive("vex3"))
         ForcedVEXEncoding = VEXEncoding_VEX3;
-      else if (Name.equals_lower("evex"))
+      else if (Name.equals_insensitive("evex"))
         ForcedVEXEncoding = VEXEncoding_EVEX;
 
       if (ForcedVEXEncoding != VEXEncoding_Default) {
         if (getLexer().isNot(AsmToken::Identifier))
           return Error(Parser.getTok().getLoc(), "Expected identifier");
         // FIXME: The mnemonic won't match correctly if its not in lower case.
         Name = Parser.getTok().getString();
         NameLoc = Parser.getTok().getLoc();
bool X86AsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
 
   // Hack to skip "short" following Jcc.
   if (isParsingIntelSyntax() &&
       (PatchedName == "jmp" || PatchedName == "jc" || PatchedName == "jnc" ||
        PatchedName == "jcxz" || PatchedName == "jecxz" ||
        (PatchedName.startswith("j") &&
         ParseConditionCode(PatchedName.substr(1)) != X86::COND_INVALID))) {
     StringRef NextTok = Parser.getTok().getString();
-    if (Parser.isParsingMasm() ? NextTok.equals_lower("short")
+    if (Parser.isParsingMasm() ? NextTok.equals_insensitive("short")
                                : NextTok == "short") {
       SMLoc NameEndLoc =
           NameLoc.getFromPointer(NameLoc.getPointer() + Name.size());
       // Eat the short keyword.
       Parser.Lex();
       // MS and GAS ignore the short keyword; they both determine the jmp type
       // based on the distance of the label. (NASM does emit different code with
       // and without "short," though.)
else if (IDVal == ".cv_fpo_stackalloc")
     return parseDirectiveFPOStackAlloc(DirectiveID.getLoc());
   else if (IDVal == ".cv_fpo_stackalign")
     return parseDirectiveFPOStackAlign(DirectiveID.getLoc());
   else if (IDVal == ".cv_fpo_endprologue")
     return parseDirectiveFPOEndPrologue(DirectiveID.getLoc());
   else if (IDVal == ".cv_fpo_endproc")
     return parseDirectiveFPOEndProc(DirectiveID.getLoc());
   else if (IDVal == ".seh_pushreg" ||
-           (Parser.isParsingMasm() && IDVal.equals_lower(".pushreg")))
+           (Parser.isParsingMasm() && IDVal.equals_insensitive(".pushreg")))
     return parseDirectiveSEHPushReg(DirectiveID.getLoc());
   else if (IDVal == ".seh_setframe" ||
-           (Parser.isParsingMasm() && IDVal.equals_lower(".setframe")))
+           (Parser.isParsingMasm() && IDVal.equals_insensitive(".setframe")))
     return parseDirectiveSEHSetFrame(DirectiveID.getLoc());
   else if (IDVal == ".seh_savereg" ||
-           (Parser.isParsingMasm() && IDVal.equals_lower(".savereg")))
+           (Parser.isParsingMasm() && IDVal.equals_insensitive(".savereg")))
     return parseDirectiveSEHSaveReg(DirectiveID.getLoc());
   else if (IDVal == ".seh_savexmm" ||
-           (Parser.isParsingMasm() && IDVal.equals_lower(".savexmm128")))
+           (Parser.isParsingMasm() && IDVal.equals_insensitive(".savexmm128")))
     return parseDirectiveSEHSaveXMM(DirectiveID.getLoc());
   else if (IDVal == ".seh_pushframe" ||
-           (Parser.isParsingMasm() && IDVal.equals_lower(".pushframe")))
+           (Parser.isParsingMasm() && IDVal.equals_insensitive(".pushframe")))
     return parseDirectiveSEHPushFrame(DirectiveID.getLoc());
 
   return true;
 }
 
 bool X86AsmParser::parseDirectiveArch() {
   // Ignore .arch for now.
   getParser().parseStringToEndOfStatement();

llvm/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

if (is64Bit)
       MAI = new X86_64MCAsmInfoDarwin(TheTriple);
     else
       MAI = new X86MCAsmInfoDarwin(TheTriple);
   } else if (TheTriple.isOSBinFormatELF()) {
     // Force the use of an ELF container.
     MAI = new X86ELFMCAsmInfo(TheTriple);
   } else if (TheTriple.isWindowsMSVCEnvironment() ||
              TheTriple.isWindowsCoreCLREnvironment()) {
-    if (Options.getAssemblyLanguage().equals_lower("masm"))
+    if (Options.getAssemblyLanguage().equals_insensitive("masm"))
       MAI = new X86MCAsmInfoMicrosoftMASM(TheTriple);
     else
       MAI = new X86MCAsmInfoMicrosoft(TheTriple);
   } else if (TheTriple.isOSCygMing() ||
              TheTriple.isWindowsItaniumEnvironment()) {
     MAI = new X86MCAsmInfoGNUCOFF(TheTriple);
   } else {
     // The default is ELF.

llvm/lib/Target/X86/X86ISelLowering.cpp

         // singleton class in cases where we have a reference to it.
         if (Constraint[4] == '7')
           return std::make_pair(X86::FP7, &X86::RFP80_7RegClass);
         return std::make_pair(X86::FP0 + Constraint[4] - '0',
                               &X86::RFP80RegClass);
       }
 
       // GCC allows "st(0)" to be called just plain "st".
-      if (StringRef("{st}").equals_lower(Constraint))
+      if (StringRef("{st}").equals_insensitive(Constraint))
         return std::make_pair(X86::FP0, &X86::RFP80RegClass);
     }
 
     // flags -> EFLAGS
-    if (StringRef("{flags}").equals_lower(Constraint))
+    if (StringRef("{flags}").equals_insensitive(Constraint))
       return std::make_pair(X86::EFLAGS, &X86::CCRRegClass);
 
     // dirflag -> DF
     // Only allow for clobber.
-    if (StringRef("{dirflag}").equals_lower(Constraint) && VT == MVT::Other)
+    if (StringRef("{dirflag}").equals_insensitive(Constraint) && VT == MVT::Other)
       return std::make_pair(X86::DF, &X86::DFCCRRegClass);
 
     // fpsr -> FPSW
-    if (StringRef("{fpsr}").equals_lower(Constraint))
+    if (StringRef("{fpsr}").equals_insensitive(Constraint))
       return std::make_pair(X86::FPSW, &X86::FPCCRRegClass);
 
     return Res;
   }
 
   // Make sure it isn't a register that requires 64-bit mode.
   if (!Subtarget.is64Bit() &&
       (isFRClass(*Res.second) || isGRClass(*Res.second)) &&

llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp

 }
 
 Optional<std::string> getPrefix(StringRef Argv0) {
   StringRef ProgName = llvm::sys::path::stem(Argv0);
   // x86_64-w64-mingw32-dlltool -> x86_64-w64-mingw32
   // llvm-dlltool -> None
   // aarch64-w64-mingw32-llvm-dlltool-10.exe -> aarch64-w64-mingw32
   ProgName = ProgName.rtrim("0123456789.-");
-  if (!ProgName.consume_back_lower("dlltool"))
+  if (!ProgName.consume_back_insensitive("dlltool"))
     return None;
-  ProgName.consume_back_lower("llvm-");
-  ProgName.consume_back_lower("-");
+  ProgName.consume_back_insensitive("llvm-");
+  ProgName.consume_back_insensitive("-");
   return ProgName.str();
 }
 
 } // namespace
 
 int llvm::dlltoolDriverMain(llvm::ArrayRef<const char *> ArgsArr) {
   DllOptTable Table;
   unsigned MissingIndex;

llvm/tools/bugpoint/ToolRunner.cpp

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

llvm/tools/llvm-ar/llvm-ar.cpp

MODIFIERS:
   [T] - create a thin archive
   [u] - update only [files] newer than archive contents
   [U] - use actual timestamps and uids/gids
   [v] - be verbose about actions taken
   [V] - display the version and exit
 )";
 
 static void printHelpMessage() {
-  if (Stem.contains_lower("ranlib"))
+  if (Stem.contains_insensitive("ranlib"))
     outs() << RanlibHelp;
-  else if (Stem.contains_lower("ar"))
+  else if (Stem.contains_insensitive("ar"))
     outs() << ArHelp;
 }
 
 static unsigned MRILineNumber;
 static bool ParsingMRIScript;
 
 // Show the error plus the usage message, and exit.
 LLVM_ATTRIBUTE_NORETURN static void badUsage(Twine Error) {
int main(int argc, char **argv) {
 
   Stem = sys::path::stem(ToolName);
   auto Is = [](StringRef Tool) {
     // We need to recognize the following filenames.
     //
     // Lib.exe -> lib (see D44808, MSBuild runs Lib.exe)
     // dlltool.exe -> dlltool
     // arm-pokymllib32-linux-gnueabi-llvm-ar-10 -> ar
-    auto I = Stem.rfind_lower(Tool);
+    auto I = Stem.rfind_insensitive(Tool);
     return I != StringRef::npos &&
            (I + Tool.size() == Stem.size() || !isAlnum(Stem[I + Tool.size()]));
   };
 
   if (Is("dlltool"))
     return dlltoolDriverMain(makeArrayRef(argv, argc));
   if (Is("ranlib"))
     return ranlib_main(argc, argv);
   if (Is("lib"))
     return libDriverMain(makeArrayRef(argv, argc));
   if (Is("ar"))
     return ar_main(argc, argv);
 
   fail("not ranlib, ar, lib or dlltool");
 }

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_lower("gcov"))
+  if (sys::path::stem(argv[0]).endswith_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:
   int64_t TargetDelta = 0;
 };
 
 Expected<uint64_t> getSlabAllocSize(StringRef SizeString) {
   SizeString = SizeString.trim();
 
   uint64_t Units = 1024;
 
-  if (SizeString.endswith_lower("kb"))
+  if (SizeString.endswith_insensitive("kb"))
     SizeString = SizeString.drop_back(2).rtrim();
-  else if (SizeString.endswith_lower("mb")) {
+  else if (SizeString.endswith_insensitive("mb")) {
     Units = 1024 * 1024;
     SizeString = SizeString.drop_back(2).rtrim();
-  } else if (SizeString.endswith_lower("gb")) {
+  } else if (SizeString.endswith_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());

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

static Expected<DriverConfig> getDriverConfig(ArrayRef<const char *> Args) {
   StringRef Stem = sys::path::stem(ToolName);
   auto Is = [=](StringRef Tool) {
     // We need to recognize the following filenames:
     //
     // llvm-objcopy -> objcopy
     // strip-10.exe -> strip
     // powerpc64-unknown-freebsd13-objcopy -> objcopy
     // llvm-install-name-tool -> install-name-tool
-    auto I = Stem.rfind_lower(Tool);
+    auto I = Stem.rfind_insensitive(Tool);
     return I != StringRef::npos &&
            (I + Tool.size() == Stem.size() || !isAlnum(Stem[I + Tool.size()]));
   };
 
   if (Is("bitcode-strip") || Is("bitcode_strip"))
     return parseBitcodeStripOptions(Args);
   else if (Is("strip"))
     return parseStripOptions(Args, reportWarning);

llvm/tools/llvm-objdump/llvm-objdump.cpp

int main(int argc, char **argv) {
 
   StringRef Stem = sys::path::stem(ToolName);
   auto Is = [=](StringRef Tool) {
     // We need to recognize the following filenames:
     //
     // llvm-objdump -> objdump
     // llvm-otool-10.exe -> otool
     // powerpc64-unknown-freebsd13-objdump -> objdump
-    auto I = Stem.rfind_lower(Tool);
+    auto I = Stem.rfind_insensitive(Tool);
     return I != StringRef::npos &&
            (I + Tool.size() == Stem.size() || !isAlnum(Stem[I + Tool.size()]));
   };
   if (Is("otool")) {
     T = std::make_unique<OtoolOptTable>();
     Unknown = OTOOL_UNKNOWN;
     HelpFlag = OTOOL_help;
     HelpHiddenFlag = OTOOL_help_hidden;

llvm/tools/llvm-pdbutil/DumpOutputStyle.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_lower(".dll"))
+  if (Name.endswith_insensitive(".dll"))
     return false;
-  if (Name.equals_lower("* linker *"))
+  if (Name.equals_insensitive("* linker *"))
     return false;
-  if (Name.startswith_lower("f:\\binaries\\Intermediate\\vctools"))
+  if (Name.startswith_insensitive("f:\\binaries\\Intermediate\\vctools"))
     return false;
-  if (Name.startswith_lower("f:\\dd\\vctools\\crt"))
+  if (Name.startswith_insensitive("f:\\dd\\vctools\\crt"))
     return false;
   return true;
 }
 
 static bool shouldDumpSymbolGroup(uint32_t Idx, const SymbolGroup &Group) {
   if (opts::dump::JustMyCode && !isMyCode(Group))
     return false;
 

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_lower("L");
+  IsLongString = Str.startswith_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;
 }

llvm/tools/llvm-rc/ResourceScriptCppFilter.cpp

if (!Line.consume_front("\""))
     return false; // Malformed line, no quote found.
 
   // Split the string at the last quote (in case the path name had
   // escaped quotes as well).
   Line = Line.rsplit('"').first;
 
   StringRef Ext = Line.rsplit('.').second;
 
-  if (Ext.equals_lower("h") || Ext.equals_lower("c")) {
+  if (Ext.equals_insensitive("h") || Ext.equals_insensitive("c")) {
     Outputting = false;
   } else {
     Outputting = true;
   }
 
   return false;
 }
 

llvm/tools/llvm-rc/ResourceScriptParser.cpp

Expected<IntWithNotMask> RCParser::parseIntExpr2() {
   case Kind::LeftParen: {
     consume();
     ASSIGN_OR_RETURN(Result, parseIntExpr1());
     RETURN_IF_ERROR(consumeType(Kind::RightParen));
     return *Result;
   }
 
   case Kind::Identifier: {
-    if (!read().value().equals_lower("not"))
+    if (!read().value().equals_insensitive("not"))
       return getExpectedError(ErrorMsg, true);
     ASSIGN_OR_RETURN(Result, parseIntExpr2());
     return IntWithNotMask(0, (*Result).getValue());
   }
 
   default:
     return getExpectedError(ErrorMsg);
   }
Expected<uint32_t> RCParser::parseFlags(ArrayRef<StringRef> FlagDesc,
 
   uint32_t Result = 0;
   while (isNextTokenKind(Kind::Comma)) {
     consume();
     ASSIGN_OR_RETURN(FlagResult, readIdentifier());
     bool FoundFlag = false;
 
     for (size_t FlagId = 0; FlagId < FlagDesc.size(); ++FlagId) {
-      if (!FlagResult->equals_lower(FlagDesc[FlagId]))
+      if (!FlagResult->equals_insensitive(FlagDesc[FlagId]))
         continue;
 
       Result |= FlagValues[FlagId];
       FoundFlag = true;
       break;
     }
 
     if (!FoundFlag)
       return getExpectedError(join(FlagDesc, "/"), true);
   }
 
   return Result;
 }
 
 uint16_t RCParser::parseMemoryFlags(uint16_t Flags) {
   while (!isEof()) {
     const RCToken &Token = look();
     if (Token.kind() != Kind::Identifier)
       return Flags;
     const StringRef Ident = Token.value();
-    if (Ident.equals_lower("PRELOAD"))
+    if (Ident.equals_insensitive("PRELOAD"))
       Flags |= MfPreload;
-    else if (Ident.equals_lower("LOADONCALL"))
+    else if (Ident.equals_insensitive("LOADONCALL"))
       Flags &= ~MfPreload;
-    else if (Ident.equals_lower("FIXED"))
+    else if (Ident.equals_insensitive("FIXED"))
       Flags &= ~(MfMoveable | MfDiscardable);
-    else if (Ident.equals_lower("MOVEABLE"))
+    else if (Ident.equals_insensitive("MOVEABLE"))
       Flags |= MfMoveable;
-    else if (Ident.equals_lower("DISCARDABLE"))
+    else if (Ident.equals_insensitive("DISCARDABLE"))
       Flags |= MfDiscardable | MfMoveable | MfPure;
-    else if (Ident.equals_lower("PURE"))
+    else if (Ident.equals_insensitive("PURE"))
       Flags |= MfPure;
-    else if (Ident.equals_lower("IMPURE"))
+    else if (Ident.equals_insensitive("IMPURE"))
       Flags &= ~(MfPure | MfDiscardable);
-    else if (Ident.equals_lower("SHARED"))
+    else if (Ident.equals_insensitive("SHARED"))
       Flags |= MfPure;
-    else if (Ident.equals_lower("NONSHARED"))
+    else if (Ident.equals_insensitive("NONSHARED"))
       Flags &= ~(MfPure | MfDiscardable);
     else
       return Flags;
     consume();
   }
   return Flags;
 }
 
 Expected<OptionalStmtList>
 RCParser::parseOptionalStatements(OptStmtType StmtsType) {
   OptionalStmtList Result;
 
   // The last statement is always followed by the start of the block.
   while (!isNextTokenKind(Kind::BlockBegin)) {
     ASSIGN_OR_RETURN(SingleParse, parseSingleOptionalStatement(StmtsType));
     Result.addStmt(std::move(*SingleParse));
   }
 
   return std::move(Result);
 }
 
 Expected<std::unique_ptr<OptionalStmt>>
 RCParser::parseSingleOptionalStatement(OptStmtType StmtsType) {
   ASSIGN_OR_RETURN(TypeToken, readIdentifier());
-  if (TypeToken->equals_lower("CHARACTERISTICS"))
+  if (TypeToken->equals_insensitive("CHARACTERISTICS"))
     return parseCharacteristicsStmt();
-  if (TypeToken->equals_lower("LANGUAGE"))
+  if (TypeToken->equals_insensitive("LANGUAGE"))
     return parseLanguageStmt();
-  if (TypeToken->equals_lower("VERSION"))
+  if (TypeToken->equals_insensitive("VERSION"))
     return parseVersionStmt();
 
   if (StmtsType != OptStmtType::BasicStmt) {
-    if (TypeToken->equals_lower("CAPTION"))
+    if (TypeToken->equals_insensitive("CAPTION"))
       return parseCaptionStmt();
-    if (TypeToken->equals_lower("CLASS"))
+    if (TypeToken->equals_insensitive("CLASS"))
       return parseClassStmt();
-    if (TypeToken->equals_lower("EXSTYLE"))
+    if (TypeToken->equals_insensitive("EXSTYLE"))
       return parseExStyleStmt();
-    if (TypeToken->equals_lower("FONT"))
+    if (TypeToken->equals_insensitive("FONT"))
       return parseFontStmt(StmtsType);
-    if (TypeToken->equals_lower("STYLE"))
+    if (TypeToken->equals_insensitive("STYLE"))
       return parseStyleStmt();
   }
 
   return getExpectedError("optional statement type, BEGIN or '{'",
                           /* IsAlreadyRead = */ true);
 }
 
 RCParser::ParseType RCParser::parseLanguageResource() {
Expected<MenuDefinitionList> RCParser::parseMenuItemsList() {
 
   // Read a set of items. Each item is of one of three kinds:
   //   MENUITEM SEPARATOR
   //   MENUITEM caption:String, result:Int [, menu flags]...
   //   POPUP caption:String [, menu flags]... { items... }
   while (!consumeOptionalType(Kind::BlockEnd)) {
     ASSIGN_OR_RETURN(ItemTypeResult, readIdentifier());
 
-    bool IsMenuItem = ItemTypeResult->equals_lower("MENUITEM");
-    bool IsPopup = ItemTypeResult->equals_lower("POPUP");
+    bool IsMenuItem = ItemTypeResult->equals_insensitive("MENUITEM");
+    bool IsPopup = ItemTypeResult->equals_insensitive("POPUP");
     if (!IsMenuItem && !IsPopup)
       return getExpectedError("MENUITEM, POPUP, END or '}'", true);
 
     if (IsMenuItem && isNextTokenKind(Kind::Identifier)) {
       // Now, expecting SEPARATOR.
       ASSIGN_OR_RETURN(SeparatorResult, readIdentifier());
-      if (SeparatorResult->equals_lower("SEPARATOR")) {
+      if (SeparatorResult->equals_insensitive("SEPARATOR")) {
         List.addDefinition(std::make_unique<MenuSeparator>());
         continue;
       }
 
       return getExpectedError("SEPARATOR or string", true);
     }
 
     // Not a separator. Read the caption.
RCParser::parseVersionInfoBlockContents(StringRef BlockName) {
 
   return std::move(Contents);
 }
 
 Expected<std::unique_ptr<VersionInfoStmt>> RCParser::parseVersionInfoStmt() {
   // Expect either BLOCK or VALUE, then a name or a key (a string).
   ASSIGN_OR_RETURN(TypeResult, readIdentifier());
 
-  if (TypeResult->equals_lower("BLOCK")) {
+  if (TypeResult->equals_insensitive("BLOCK")) {
     ASSIGN_OR_RETURN(NameResult, readString());
     return parseVersionInfoBlockContents(*NameResult);
   }
 
-  if (TypeResult->equals_lower("VALUE")) {
+  if (TypeResult->equals_insensitive("VALUE")) {
     ASSIGN_OR_RETURN(KeyResult, readString());
     // Read a non-empty list of strings and/or ints, each
     // possibly preceded by a comma. Unfortunately, the tool behavior depends
     // on them existing or not, so we need to memorize where we found them.
     std::vector<IntOrString> Values;
     std::vector<bool> PrecedingCommas;
     RETURN_IF_ERROR(consumeType(Kind::Comma));
     while (!isNextTokenKind(Kind::Identifier) &&

llvm/tools/llvm-rc/ResourceScriptStmt.h

public:
   IntOrString() : IntOrString(RCInt(0)) {}
   IntOrString(uint32_t Value) : Data(Value), IsInt(1) {}
   IntOrString(RCInt Value) : Data(Value), IsInt(1) {}
   IntOrString(StringRef Value) : Data(Value), IsInt(0) {}
   IntOrString(const RCToken &Token)
       : Data(Token), IsInt(Token.kind() == RCToken::Kind::Int) {}
 
   bool equalsLower(const char *Str) {
-    return !IsInt && Data.String.equals_lower(Str);
+    return !IsInt && Data.String.equals_insensitive(Str);
   }
 
   bool isInt() const { return IsInt; }
 
   RCInt getInt() const {
     assert(IsInt);
     return Data.Int;
   }

llvm/tools/llvm-rc/ResourceScriptToken.cpp

default:
     return Kind::Invalid;
   }
 }
 
 void Tokenizer::processIdentifier(RCToken &Token) const {
   assert(Token.kind() == Kind::Identifier);
   StringRef Name = Token.value();
 
-  if (Name.equals_lower("begin"))
+  if (Name.equals_insensitive("begin"))
     Token = RCToken(Kind::BlockBegin, Name);
-  else if (Name.equals_lower("end"))
+  else if (Name.equals_insensitive("end"))
     Token = RCToken(Kind::BlockEnd, Name);
 }
 
 } // anonymous namespace
 
 namespace llvm {
 
 Expected<std::vector<RCToken>> tokenizeRC(StringRef Input) {
   return Tokenizer(Input).run();
 }
 
 } // namespace llvm

llvm/tools/llvm-rc/llvm-rc.cpp

 }
 
 static std::pair<bool, std::string> isWindres(llvm::StringRef Argv0) {
   StringRef ProgName = llvm::sys::path::stem(Argv0);
   // x86_64-w64-mingw32-windres -> x86_64-w64-mingw32, windres
   // llvm-rc -> "", llvm-rc
   // aarch64-w64-mingw32-llvm-windres-10.exe -> aarch64-w64-mingw32, llvm-windres
   ProgName = ProgName.rtrim("0123456789.-");
-  if (!ProgName.consume_back_lower("windres"))
+  if (!ProgName.consume_back_insensitive("windres"))
     return std::make_pair<bool, std::string>(false, "");
-  ProgName.consume_back_lower("llvm-");
-  ProgName.consume_back_lower("-");
+  ProgName.consume_back_insensitive("llvm-");
+  ProgName.consume_back_insensitive("-");
   return std::make_pair<bool, std::string>(true, ProgName.str());
 }
 
 Format parseFormat(StringRef S) {
   Format F = StringSwitch<Format>(S.lower())
                  .Case("rc", Rc)
                  .Case("res", Res)
                  .Case("coff", Coff)

llvm/unittests/ADT/SmallStringTest.cpp

 TEST_F(SmallStringTest, Comparisons) {
   EXPECT_EQ(-1, SmallString<10>("aab").compare("aad"));
   EXPECT_EQ( 0, SmallString<10>("aab").compare("aab"));
   EXPECT_EQ( 1, SmallString<10>("aab").compare("aaa"));
   EXPECT_EQ(-1, SmallString<10>("aab").compare("aabb"));
   EXPECT_EQ( 1, SmallString<10>("aab").compare("aa"));
   EXPECT_EQ( 1, SmallString<10>("\xFF").compare("\1"));
 
-  EXPECT_EQ(-1, SmallString<10>("AaB").compare_lower("aAd"));
-  EXPECT_EQ( 0, SmallString<10>("AaB").compare_lower("aab"));
-  EXPECT_EQ( 1, SmallString<10>("AaB").compare_lower("AAA"));
-  EXPECT_EQ(-1, SmallString<10>("AaB").compare_lower("aaBb"));
-  EXPECT_EQ( 1, SmallString<10>("AaB").compare_lower("aA"));
-  EXPECT_EQ( 1, SmallString<10>("\xFF").compare_lower("\1"));
+  EXPECT_EQ(-1, SmallString<10>("AaB").compare_insensitive("aAd"));
+  EXPECT_EQ( 0, SmallString<10>("AaB").compare_insensitive("aab"));
+  EXPECT_EQ( 1, SmallString<10>("AaB").compare_insensitive("AAA"));
+  EXPECT_EQ(-1, SmallString<10>("AaB").compare_insensitive("aaBb"));
+  EXPECT_EQ( 1, SmallString<10>("AaB").compare_insensitive("aA"));
+  EXPECT_EQ( 1, SmallString<10>("\xFF").compare_insensitive("\1"));
 
   EXPECT_EQ(-1, SmallString<10>("aab").compare_numeric("aad"));
   EXPECT_EQ( 0, SmallString<10>("aab").compare_numeric("aab"));
   EXPECT_EQ( 1, SmallString<10>("aab").compare_numeric("aaa"));
   EXPECT_EQ(-1, SmallString<10>("aab").compare_numeric("aabb"));
   EXPECT_EQ( 1, SmallString<10>("aab").compare_numeric("aa"));
   EXPECT_EQ(-1, SmallString<10>("1").compare_numeric("10"));
   EXPECT_EQ( 0, SmallString<10>("10").compare_numeric("10"));

llvm/unittests/ADT/StringRefTest.cpp

TEST(StringRefTest, StringOps) {
   EXPECT_EQ((size_t) 5, StringRef("hello").size());
   EXPECT_EQ(-1, StringRef("aab").compare("aad"));
   EXPECT_EQ( 0, StringRef("aab").compare("aab"));
   EXPECT_EQ( 1, StringRef("aab").compare("aaa"));
   EXPECT_EQ(-1, StringRef("aab").compare("aabb"));
   EXPECT_EQ( 1, StringRef("aab").compare("aa"));
   EXPECT_EQ( 1, StringRef("\xFF").compare("\1"));
 
-  EXPECT_EQ(-1, StringRef("AaB").compare_lower("aAd"));
-  EXPECT_EQ( 0, StringRef("AaB").compare_lower("aab"));
-  EXPECT_EQ( 1, StringRef("AaB").compare_lower("AAA"));
-  EXPECT_EQ(-1, StringRef("AaB").compare_lower("aaBb"));
-  EXPECT_EQ(-1, StringRef("AaB").compare_lower("bb"));
-  EXPECT_EQ( 1, StringRef("aaBb").compare_lower("AaB"));
-  EXPECT_EQ( 1, StringRef("bb").compare_lower("AaB"));
-  EXPECT_EQ( 1, StringRef("AaB").compare_lower("aA"));
-  EXPECT_EQ( 1, StringRef("\xFF").compare_lower("\1"));
+  EXPECT_EQ(-1, StringRef("AaB").compare_insensitive("aAd"));
+  EXPECT_EQ( 0, StringRef("AaB").compare_insensitive("aab"));
+  EXPECT_EQ( 1, StringRef("AaB").compare_insensitive("AAA"));
+  EXPECT_EQ(-1, StringRef("AaB").compare_insensitive("aaBb"));
+  EXPECT_EQ(-1, StringRef("AaB").compare_insensitive("bb"));
+  EXPECT_EQ( 1, StringRef("aaBb").compare_insensitive("AaB"));
+  EXPECT_EQ( 1, StringRef("bb").compare_insensitive("AaB"));
+  EXPECT_EQ( 1, StringRef("AaB").compare_insensitive("aA"));
+  EXPECT_EQ( 1, StringRef("\xFF").compare_insensitive("\1"));
 
   EXPECT_EQ(-1, StringRef("aab").compare_numeric("aad"));
   EXPECT_EQ( 0, StringRef("aab").compare_numeric("aab"));
   EXPECT_EQ( 1, StringRef("aab").compare_numeric("aaa"));
   EXPECT_EQ(-1, StringRef("aab").compare_numeric("aabb"));
   EXPECT_EQ( 1, StringRef("aab").compare_numeric("aa"));
   EXPECT_EQ(-1, StringRef("1").compare_numeric("10"));
   EXPECT_EQ( 0, StringRef("10").compare_numeric("10"));

 TEST(StringRefTest, StartsWith) {
   StringRef Str("hello");
   EXPECT_TRUE(Str.startswith(""));
   EXPECT_TRUE(Str.startswith("he"));
   EXPECT_FALSE(Str.startswith("helloworld"));
   EXPECT_FALSE(Str.startswith("hi"));
 }
 
-TEST(StringRefTest, StartsWithLower) {
+TEST(StringRefTest, StartsWithInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.startswith_lower(""));
-  EXPECT_TRUE(Str.startswith_lower("he"));
-  EXPECT_TRUE(Str.startswith_lower("hell"));
-  EXPECT_TRUE(Str.startswith_lower("HELlo"));
-  EXPECT_FALSE(Str.startswith_lower("helloworld"));
-  EXPECT_FALSE(Str.startswith_lower("hi"));
+  EXPECT_TRUE(Str.startswith_insensitive(""));
+  EXPECT_TRUE(Str.startswith_insensitive("he"));
+  EXPECT_TRUE(Str.startswith_insensitive("hell"));
+  EXPECT_TRUE(Str.startswith_insensitive("HELlo"));
+  EXPECT_FALSE(Str.startswith_insensitive("helloworld"));
+  EXPECT_FALSE(Str.startswith_insensitive("hi"));
 }
 
 TEST(StringRefTest, ConsumeFront) {
   StringRef Str("hello");
   EXPECT_TRUE(Str.consume_front(""));
   EXPECT_EQ("hello", Str);
   EXPECT_TRUE(Str.consume_front("he"));
   EXPECT_EQ("llo", Str);
   EXPECT_FALSE(Str.consume_front("lloworld"));
   EXPECT_EQ("llo", Str);
   EXPECT_FALSE(Str.consume_front("lol"));
   EXPECT_EQ("llo", Str);
   EXPECT_TRUE(Str.consume_front("llo"));
   EXPECT_EQ("", Str);
   EXPECT_FALSE(Str.consume_front("o"));
   EXPECT_TRUE(Str.consume_front(""));
 }
 
-TEST(StringRefTest, ConsumeFrontLower) {
+TEST(StringRefTest, ConsumeFrontInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.consume_front_lower(""));
+  EXPECT_TRUE(Str.consume_front_insensitive(""));
   EXPECT_EQ("heLLo", Str);
   EXPECT_FALSE(Str.consume_front("HEl"));
   EXPECT_EQ("heLLo", Str);
-  EXPECT_TRUE(Str.consume_front_lower("HEl"));
+  EXPECT_TRUE(Str.consume_front_insensitive("HEl"));
   EXPECT_EQ("Lo", Str);
-  EXPECT_FALSE(Str.consume_front_lower("loworld"));
+  EXPECT_FALSE(Str.consume_front_insensitive("loworld"));
   EXPECT_EQ("Lo", Str);
-  EXPECT_FALSE(Str.consume_front_lower("ol"));
+  EXPECT_FALSE(Str.consume_front_insensitive("ol"));
   EXPECT_EQ("Lo", Str);
-  EXPECT_TRUE(Str.consume_front_lower("lo"));
+  EXPECT_TRUE(Str.consume_front_insensitive("lo"));
   EXPECT_EQ("", Str);
-  EXPECT_FALSE(Str.consume_front_lower("o"));
-  EXPECT_TRUE(Str.consume_front_lower(""));
+  EXPECT_FALSE(Str.consume_front_insensitive("o"));
+  EXPECT_TRUE(Str.consume_front_insensitive(""));
 }
 
 TEST(StringRefTest, EndsWith) {
   StringRef Str("hello");
   EXPECT_TRUE(Str.endswith(""));
   EXPECT_TRUE(Str.endswith("lo"));
   EXPECT_FALSE(Str.endswith("helloworld"));
   EXPECT_FALSE(Str.endswith("worldhello"));
   EXPECT_FALSE(Str.endswith("so"));
 }
 
-TEST(StringRefTest, EndsWithLower) {
+TEST(StringRefTest, EndsWithInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.endswith_lower(""));
-  EXPECT_TRUE(Str.endswith_lower("lo"));
-  EXPECT_TRUE(Str.endswith_lower("LO"));
-  EXPECT_TRUE(Str.endswith_lower("ELlo"));
-  EXPECT_FALSE(Str.endswith_lower("helloworld"));
-  EXPECT_FALSE(Str.endswith_lower("hi"));
+  EXPECT_TRUE(Str.endswith_insensitive(""));
+  EXPECT_TRUE(Str.endswith_insensitive("lo"));
+  EXPECT_TRUE(Str.endswith_insensitive("LO"));
+  EXPECT_TRUE(Str.endswith_insensitive("ELlo"));
+  EXPECT_FALSE(Str.endswith_insensitive("helloworld"));
+  EXPECT_FALSE(Str.endswith_insensitive("hi"));
 }
 
 TEST(StringRefTest, ConsumeBack) {
   StringRef Str("hello");
   EXPECT_TRUE(Str.consume_back(""));
   EXPECT_EQ("hello", Str);
   EXPECT_TRUE(Str.consume_back("lo"));
   EXPECT_EQ("hel", Str);
   EXPECT_FALSE(Str.consume_back("helhel"));
   EXPECT_EQ("hel", Str);
   EXPECT_FALSE(Str.consume_back("hle"));
   EXPECT_EQ("hel", Str);
   EXPECT_TRUE(Str.consume_back("hel"));
   EXPECT_EQ("", Str);
   EXPECT_FALSE(Str.consume_back("h"));
   EXPECT_TRUE(Str.consume_back(""));
 }
 
-TEST(StringRefTest, ConsumeBackLower) {
+TEST(StringRefTest, ConsumeBackInsensitive) {
   StringRef Str("heLLo");
-  EXPECT_TRUE(Str.consume_back_lower(""));
+  EXPECT_TRUE(Str.consume_back_insensitive(""));
   EXPECT_EQ("heLLo", Str);
   EXPECT_FALSE(Str.consume_back("lO"));
   EXPECT_EQ("heLLo", Str);
-  EXPECT_TRUE(Str.consume_back_lower("lO"));
+  EXPECT_TRUE(Str.consume_back_insensitive("lO"));
   EXPECT_EQ("heL", Str);
-  EXPECT_FALSE(Str.consume_back_lower("helhel"));
+  EXPECT_FALSE(Str.consume_back_insensitive("helhel"));
   EXPECT_EQ("heL", Str);
-  EXPECT_FALSE(Str.consume_back_lower("hle"));
+  EXPECT_FALSE(Str.consume_back_insensitive("hle"));
   EXPECT_EQ("heL", Str);
-  EXPECT_TRUE(Str.consume_back_lower("hEl"));
+  EXPECT_TRUE(Str.consume_back_insensitive("hEl"));
   EXPECT_EQ("", Str);
-  EXPECT_FALSE(Str.consume_back_lower("h"));
-  EXPECT_TRUE(Str.consume_back_lower(""));
+  EXPECT_FALSE(Str.consume_back_insensitive("h"));
+  EXPECT_TRUE(Str.consume_back_insensitive(""));
 }
 
 TEST(StringRefTest, Find) {
   StringRef Str("helloHELLO");
   StringRef LongStr("hellx xello hell ello world foo bar hello HELLO");
 
   struct {
     StringRef Str;
     char C;
     std::size_t From;
     std::size_t Pos;
-    std::size_t LowerPos;
+    std::size_t InsensitivePos;
   } CharExpectations[] = {
       {Str, 'h', 0U, 0U, 0U},
       {Str, 'e', 0U, 1U, 1U},
       {Str, 'l', 0U, 2U, 2U},
       {Str, 'l', 3U, 3U, 3U},
       {Str, 'o', 0U, 4U, 4U},
       {Str, 'L', 0U, 7U, 2U},
       {Str, 'z', 0U, StringRef::npos, StringRef::npos},
   };
 
   struct {
     StringRef Str;
     llvm::StringRef S;
     std::size_t From;
     std::size_t Pos;
-    std::size_t LowerPos;
+    std::size_t InsensitivePos;
   } StrExpectations[] = {
       {Str, "helloword", 0, StringRef::npos, StringRef::npos},
       {Str, "hello", 0, 0U, 0U},
       {Str, "ello", 0, 1U, 1U},
       {Str, "zz", 0, StringRef::npos, StringRef::npos},
       {Str, "ll", 2U, 2U, 2U},
       {Str, "ll", 3U, StringRef::npos, 7U},
       {Str, "LL", 2U, 7U, 2U},
       {Str, "LL", 3U, 7U, 7U},
       {Str, "", 0U, 0U, 0U},
       {LongStr, "hello", 0U, 36U, 36U},
       {LongStr, "foo", 0U, 28U, 28U},
       {LongStr, "hell", 2U, 12U, 12U},
       {LongStr, "HELL", 2U, 42U, 12U},
       {LongStr, "", 0U, 0U, 0U}};
 
   for (auto &E : CharExpectations) {
     EXPECT_EQ(E.Pos, E.Str.find(E.C, E.From));
-    EXPECT_EQ(E.LowerPos, E.Str.find_lower(E.C, E.From));
-    EXPECT_EQ(E.LowerPos, E.Str.find_lower(toupper(E.C), E.From));
+    EXPECT_EQ(E.InsensitivePos, E.Str.find_insensitive(E.C, E.From));
+    EXPECT_EQ(E.InsensitivePos, E.Str.find_insensitive(toupper(E.C), E.From));
   }
 
   for (auto &E : StrExpectations) {
     EXPECT_EQ(E.Pos, E.Str.find(E.S, E.From));
-    EXPECT_EQ(E.LowerPos, E.Str.find_lower(E.S, E.From));
-    EXPECT_EQ(E.LowerPos, E.Str.find_lower(E.S.upper(), E.From));
+    EXPECT_EQ(E.InsensitivePos, E.Str.find_insensitive(E.S, E.From));
+    EXPECT_EQ(E.InsensitivePos, E.Str.find_insensitive(E.S.upper(), E.From));
   }
 
   EXPECT_EQ(3U, Str.rfind('l'));
   EXPECT_EQ(StringRef::npos, Str.rfind('z'));
   EXPECT_EQ(StringRef::npos, Str.rfind("helloworld"));
   EXPECT_EQ(0U, Str.rfind("hello"));
   EXPECT_EQ(1U, Str.rfind("ello"));
   EXPECT_EQ(StringRef::npos, Str.rfind("zz"));
 
-  EXPECT_EQ(8U, Str.rfind_lower('l'));
-  EXPECT_EQ(8U, Str.rfind_lower('L'));
-  EXPECT_EQ(StringRef::npos, Str.rfind_lower('z'));
-  EXPECT_EQ(StringRef::npos, Str.rfind_lower("HELLOWORLD"));
+  EXPECT_EQ(8U, Str.rfind_insensitive('l'));
+  EXPECT_EQ(8U, Str.rfind_insensitive('L'));
+  EXPECT_EQ(StringRef::npos, Str.rfind_insensitive('z'));
+  EXPECT_EQ(StringRef::npos, Str.rfind_insensitive("HELLOWORLD"));
   EXPECT_EQ(5U, Str.rfind("HELLO"));
   EXPECT_EQ(6U, Str.rfind("ELLO"));
   EXPECT_EQ(StringRef::npos, Str.rfind("ZZ"));
 
   EXPECT_EQ(2U, Str.find_first_of('l'));
   EXPECT_EQ(1U, Str.find_first_of("el"));
   EXPECT_EQ(StringRef::npos, Str.find_first_of("xyz"));
 

llvm/unittests/Support/CommandLineTest.cpp

TEST(CommandLineTest, GetCommandLineArguments) {
   char **argv = __argv;
 
   // GetCommandLineArguments is called in InitLLVM.
   llvm::InitLLVM X(argc, argv);
 
   EXPECT_EQ(llvm::sys::path::is_absolute(argv[0]),
             llvm::sys::path::is_absolute(__argv[0]));
 
   EXPECT_TRUE(llvm::sys::path::filename(argv[0])
-              .equals_lower("supporttests.exe"))
+              .equals_insensitive("supporttests.exe"))
       << "Filename of test executable is "
       << llvm::sys::path::filename(argv[0]);
 }
 #endif
 
 class OutputRedirector {
 public:
   OutputRedirector(int RedirectFD)

llvm/utils/TableGen/AsmMatcherEmitter.cpp

struct MatchableInfo {
   }
 
   void buildInstructionResultOperands();
   void buildAliasResultOperands(bool AliasConstraintsAreChecked);
 
   /// operator< - Compare two matchables.
   bool operator<(const MatchableInfo &RHS) const {
     // The primary comparator is the instruction mnemonic.
-    if (int Cmp = Mnemonic.compare_lower(RHS.Mnemonic))
+    if (int Cmp = Mnemonic.compare_insensitive(RHS.Mnemonic))
       return Cmp == -1;
 
     if (AsmOperands.size() != RHS.AsmOperands.size())
       return AsmOperands.size() < RHS.AsmOperands.size();
 
     // Compare lexicographically by operand. The matcher validates that other
     // orderings wouldn't be ambiguous using \see couldMatchAmbiguouslyWith().
     for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {

mlir/test/lib/Dialect/Test/TestTypes.cpp

 // Custom parser for SignednessSemantics.
 static ParseResult
 parseSignedness(DialectAsmParser &parser,
                 TestIntegerType::SignednessSemantics &result) {
   StringRef signStr;
   auto loc = parser.getCurrentLocation();
   if (parser.parseKeyword(&signStr))
     return failure();
-  if (signStr.compare_lower("u") || signStr.compare_lower("unsigned"))
+  if (signStr.compare_insensitive("u") || signStr.compare_insensitive("unsigned"))
     result = TestIntegerType::SignednessSemantics::Unsigned;
-  else if (signStr.compare_lower("s") || signStr.compare_lower("signed"))
+  else if (signStr.compare_insensitive("s") || signStr.compare_insensitive("signed"))
     result = TestIntegerType::SignednessSemantics::Signed;
-  else if (signStr.compare_lower("n") || signStr.compare_lower("none"))
+  else if (signStr.compare_insensitive("n") || signStr.compare_insensitive("none"))
     result = TestIntegerType::SignednessSemantics::Signless;
   else
     return parser.emitError(loc, "expected signed, unsigned, or none");
   return success();
 }
 
 // Custom printer for SignednessSemantics.
 static void printSignedness(DialectAsmPrinter &printer,