Remove StringRef deprecation warning

ahueck · ahueck · commit 9a50452311ee · 2025-01-26T13:02:36.000+01:00
diff --git a/lib/passes/analysis/MemInstFinder.cpp b/lib/passes/analysis/MemInstFinder.cpp
@@ -191,15 +191,9 @@ bool MemInstFinderPass::runOnModule(Module& module) {
                           return true;
                         }
 
-                        if (name.startswith("llvm.") || name.startswith("__llvm_gcov") ||
-                            name.startswith("__llvm_gcda") || name.startswith("__profn")) {
-                          // 2nd and 3rd check: Check if the global is private gcov data (--coverage).
-                          LOG_DEBUG("LLVM startswith \"llvm\"")
-                          return true;
-                        }
-
-                        if (name.startswith("___asan") || name.startswith("__msan") || name.startswith("__tsan")) {
-                          LOG_DEBUG("LLVM startswith \"sanitizer\"")
+                        if (util::starts_with_any_of(name, "llvm.", "__llvm_gcov", "__llvm_gcda", "__profn", "___asan",
+                                                     "__msan", "__tsan")) {
+                          LOG_DEBUG("Prefixed matched on " << name)
                           return true;
                         }
 
@@ -267,7 +261,7 @@ bool MemInstFinderPass::runOnModule(Module& module) {
 }  // namespace typeart
 
 bool MemInstFinderPass::runOnFunction(llvm::Function& function) {
-  if (function.isDeclaration() || function.getName().startswith("__typeart")) {
+  if (function.isDeclaration() || util::starts_with_any_of(function.getName(), "__typeart")) {
     return false;
   }
 
diff --git a/lib/passes/filter/Matcher.h b/lib/passes/filter/Matcher.h
@@ -43,10 +43,10 @@ class NoMatcher final : public Matcher {
 };
 
 class DefaultStringMatcher final : public Matcher {
-  Regex matcher;
+  llvm::Regex matcher;
 
  public:
-  explicit DefaultStringMatcher(const std::string& regex) : matcher(regex, Regex::NoFlags) {
+  explicit DefaultStringMatcher(const std::string& regex) : matcher(regex, llvm::Regex::NoFlags) {
   }
 
   MatchResult match(llvm::CallSite c) const override {
@@ -82,13 +82,13 @@ class FunctionOracleMatcher final : public Matcher {
       if (skip_set.count(f_name) > 0) {
         return MatchResult::ShouldSkip;
       }
-      if (f_name_ref.startswith("__typeart_")) {
+      if (util::starts_with_any_of(f_name_ref, "__typeart_")) {
         return MatchResult::ShouldSkip;
       }
       if (mem_operations.kind(f_name)) {
         return MatchResult::ShouldSkip;
       }
-      if (f_name_ref.startswith("__ubsan") || f_name_ref.startswith("__asan") || f_name_ref.startswith("__msan")) {
+      if (util::starts_with_any_of(f_name_ref, "__ubsan", "__asan", "__msan")) {
         return MatchResult::ShouldContinue;
       }
     }
diff --git a/lib/passes/filter/OmpUtil.h b/lib/passes/filter/OmpUtil.h
@@ -17,6 +17,7 @@
 #include "compat/CallSite.h"
 #include "support/DefUseChain.h"
 #include "support/OmpUtil.h"
+#include "support/Util.h"
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
@@ -37,31 +38,31 @@ struct OmpContext {
     const auto called = c.getCalledFunction();
     if (called != nullptr) {
       // TODO probably not complete (openmp task?, see isOmpTask*())
-      return called->getName().startswith("__kmpc_fork_call");
+      return util::starts_with_any_of(called->getName(), "__kmpc_fork_call");
     }
     return false;
   }
 
   static bool isOmpTaskAlloc(const llvm::CallSite& c) {
     const auto called = c.getCalledFunction();
     if (called != nullptr) {
-      return called->getName().startswith("__kmpc_omp_task_alloc");
+      return util::starts_with_any_of(called->getName(), "__kmpc_omp_task_alloc");
     }
     return false;
   }
 
   static bool isOmpTaskCall(const llvm::CallSite& c) {
     const auto called = c.getCalledFunction();
     if (called != nullptr) {
-      return called->getName().endswith("__kmpc_omp_task");
+      return util::ends_with_any_of(called->getName(), "__kmpc_omp_task");
     }
     return false;
   }
 
   static bool isOmpTaskRelated(const llvm::CallSite& c) {
     const auto called = c.getCalledFunction();
     if (called != nullptr) {
-      return called->getName().startswith("__kmpc_omp_task");
+      return util::starts_with_any_of(called->getName(), "__kmpc_omp_task");
     }
     return false;
   }
@@ -71,9 +72,8 @@ struct OmpContext {
     if (!is_execute) {
       const auto called = c.getCalledFunction();
       if (called != nullptr) {
-        const auto name = called->getName();
         // TODO extend this if required
-        return name.startswith("__kmpc") || name.startswith("omp_");
+        return util::starts_with_any_of(called->getName(), "__kmpc", "omp_");
       }
     }
     return false;
@@ -142,7 +142,8 @@ struct OmpContext {
           llvm::CallSite site(value);
           if (site.isCall() || site.isInvoke()) {
             const auto called = site.getCalledFunction();
-            if (called != nullptr && called->getName().startswith("__kmpc_omp_task(")) {
+
+            if (called != nullptr && util::starts_with_any_of(called->getName(), "__kmpc_omp_task(")) {
               found = true;
               return util::DefUseChain::cancel;
             }
@@ -171,7 +172,7 @@ struct OmpContext {
           if (s.isCall() || s.isInvoke()) {
             if (auto f = s.getCalledFunction()) {
               // once true, the find_all should cancel
-              return f->getName().startswith("__kmpc_omp_task_alloc");
+              return util::starts_with_any_of(f->getName(), "__kmpc_omp_task_alloc");
             }
           }
           return false;
diff --git a/lib/passes/support/OmpUtil.h b/lib/passes/support/OmpUtil.h
@@ -24,7 +24,7 @@ inline bool isOmpContext(llvm::Function* f) {
   if (f != nullptr) {
     const auto name_ = demangle(f->getName());
     llvm::StringRef fname(name_);
-    return fname.startswith(".omp") || fname.startswith("__kmpc") || fname.startswith("__omp");
+    return util::starts_with_any_of(fname, ".omp", "__kmpc", "__omp");
   }
   return false;
 }
diff --git a/lib/passes/support/Util.h b/lib/passes/support/Util.h
@@ -22,6 +22,10 @@
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include <algorithm>
+#include <llvm/ADT/StringRef.h>
+#include <string>
+
 namespace typeart::util {
 
 namespace detail {
@@ -126,18 +130,6 @@ inline std::vector<llvm::Instruction*> find_all(llvm::Function* f, Predicate&& p
   return v;
 }
 
-template <typename Predicate>
-inline llvm::Instruction* find_first_of(llvm::Function* f, Predicate&& p) {
-  for (auto& bb : *f) {
-    for (auto& inst : bb) {
-      if (p(inst)) {
-        return &inst;
-      }
-    }
-  }
-  return nullptr;
-}
-
 inline bool regex_matches(const std::string& regex, const std::string& in, bool case_sensitive = false) {
   using namespace llvm;
   Regex r(regex, !case_sensitive ? Regex::IgnoreCase : Regex::NoFlags);
@@ -187,6 +179,29 @@ inline std::string glob2regex(const std::string& glob) {
   return glob_reg;
 }
 
+template <typename... StringTy>
+bool with_any_of(llvm::StringRef lhs, StringTy&&... rhs) {
+  return !lhs.empty() && ((lhs == rhs) || ...);
+}
+
+template <typename... StringTy>
+inline bool starts_with_any_of(llvm::StringRef lhs, StringTy... rhs) {
+#if LLVM_VERSION_MAJOR > 14
+  return !lhs.empty() && ((lhs.starts_with(rhs)) || ...);
+#else
+  return !lhs.empty() && ((lhs.startswith(rhs)) || ...);
+#endif
+}
+
+template <typename... StringTy>
+inline bool ends_with_any_of(llvm::StringRef lhs, StringTy... rhs) {
+#if LLVM_VERSION_MAJOR > 14
+  return !lhs.empty() && ((lhs.ends_with(rhs)) || ...);
+#else
+  return !lhs.empty() && ((lhs.endswith(rhs)) || ...);
+#endif
+}
+
 }  // namespace typeart::util
 
 #endif /* LIB_UTIL_H_ */

Original file line number	Diff line number	Diff line change
`@@ -43,10 +43,10 @@ class NoMatcher final : public Matcher {`
`43`	`43`	`};`
`44`	`44`
`45`	`45`	`class DefaultStringMatcher final : public Matcher {`
`46`		`- Regex matcher;`
	`46`	`+ llvm::Regex matcher;`
`47`	`47`
`48`	`48`	`public:`
`49`		`- explicit DefaultStringMatcher(const std::string& regex) : matcher(regex, Regex::NoFlags) {`
	`49`	`+ explicit DefaultStringMatcher(const std::string& regex) : matcher(regex, llvm::Regex::NoFlags) {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`MatchResult match(llvm::CallSite c) const override {`
`@@ -82,13 +82,13 @@ class FunctionOracleMatcher final : public Matcher {`
`82`	`82`	`if (skip_set.count(f_name) > 0) {`
`83`	`83`	`return MatchResult::ShouldSkip;`
`84`	`84`	`}`
`85`		`- if (f_name_ref.startswith("__typeart_")) {`
	`85`	`+ if (util::starts_with_any_of(f_name_ref, "__typeart_")) {`
`86`	`86`	`return MatchResult::ShouldSkip;`
`87`	`87`	`}`
`88`	`88`	`if (mem_operations.kind(f_name)) {`
`89`	`89`	`return MatchResult::ShouldSkip;`
`90`	`90`	`}`
`91`		`- if (f_name_ref.startswith("__ubsan") \|\| f_name_ref.startswith("__asan") \|\| f_name_ref.startswith("__msan")) {`
	`91`	`+ if (util::starts_with_any_of(f_name_ref, "__ubsan", "__asan", "__msan")) {`
`92`	`92`	`return MatchResult::ShouldContinue;`
`93`	`93`	`}`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@`
`17`	`17`	`#include "compat/CallSite.h"`
`18`	`18`	`#include "support/DefUseChain.h"`
`19`	`19`	`#include "support/OmpUtil.h"`
	`20`	`+#include "support/Util.h"`
`20`	`21`
`21`	`22`	`#include "llvm/IR/Function.h"`
`22`	`23`	`#include "llvm/IR/Instructions.h"`
`@@ -37,31 +38,31 @@ struct OmpContext {`
`37`	`38`	`const auto called = c.getCalledFunction();`
`38`	`39`	`if (called != nullptr) {`
`39`	`40`	`// TODO probably not complete (openmp task?, see isOmpTask*())`
`40`		`- return called->getName().startswith("__kmpc_fork_call");`
	`41`	`+ return util::starts_with_any_of(called->getName(), "__kmpc_fork_call");`
`41`	`42`	`}`
`42`	`43`	`return false;`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`static bool isOmpTaskAlloc(const llvm::CallSite& c) {`
`46`	`47`	`const auto called = c.getCalledFunction();`
`47`	`48`	`if (called != nullptr) {`
`48`		`- return called->getName().startswith("__kmpc_omp_task_alloc");`
	`49`	`+ return util::starts_with_any_of(called->getName(), "__kmpc_omp_task_alloc");`
`49`	`50`	`}`
`50`	`51`	`return false;`
`51`	`52`	`}`
`52`	`53`
`53`	`54`	`static bool isOmpTaskCall(const llvm::CallSite& c) {`
`54`	`55`	`const auto called = c.getCalledFunction();`
`55`	`56`	`if (called != nullptr) {`
`56`		`- return called->getName().endswith("__kmpc_omp_task");`
	`57`	`+ return util::ends_with_any_of(called->getName(), "__kmpc_omp_task");`
`57`	`58`	`}`
`58`	`59`	`return false;`
`59`	`60`	`}`
`60`	`61`
`61`	`62`	`static bool isOmpTaskRelated(const llvm::CallSite& c) {`
`62`	`63`	`const auto called = c.getCalledFunction();`
`63`	`64`	`if (called != nullptr) {`
`64`		`- return called->getName().startswith("__kmpc_omp_task");`
	`65`	`+ return util::starts_with_any_of(called->getName(), "__kmpc_omp_task");`
`65`	`66`	`}`
`66`	`67`	`return false;`
`67`	`68`	`}`
`@@ -71,9 +72,8 @@ struct OmpContext {`
`71`	`72`	`if (!is_execute) {`
`72`	`73`	`const auto called = c.getCalledFunction();`
`73`	`74`	`if (called != nullptr) {`
`74`		`- const auto name = called->getName();`
`75`	`75`	`// TODO extend this if required`
`76`		`- return name.startswith("__kmpc") \|\| name.startswith("omp_");`
	`76`	`+ return util::starts_with_any_of(called->getName(), "__kmpc", "omp_");`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`	`return false;`
`@@ -142,7 +142,8 @@ struct OmpContext {`
`142`	`142`	`llvm::CallSite site(value);`
`143`	`143`	`if (site.isCall() \|\| site.isInvoke()) {`
`144`	`144`	`const auto called = site.getCalledFunction();`
`145`		`- if (called != nullptr && called->getName().startswith("__kmpc_omp_task(")) {`
	`145`	`+`
	`146`	`+ if (called != nullptr && util::starts_with_any_of(called->getName(), "__kmpc_omp_task(")) {`
`146`	`147`	`found = true;`
`147`	`148`	`return util::DefUseChain::cancel;`
`148`	`149`	`}`
`@@ -171,7 +172,7 @@ struct OmpContext {`
`171`	`172`	`if (s.isCall() \|\| s.isInvoke()) {`
`172`	`173`	`if (auto f = s.getCalledFunction()) {`
`173`	`174`	`// once true, the find_all should cancel`
`174`		`- return f->getName().startswith("__kmpc_omp_task_alloc");`
	`175`	`+ return util::starts_with_any_of(f->getName(), "__kmpc_omp_task_alloc");`
`175`	`176`	`}`
`176`	`177`	`}`
`177`	`178`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ inline bool isOmpContext(llvm::Function* f) {`
`24`	`24`	`if (f != nullptr) {`
`25`	`25`	`const auto name_ = demangle(f->getName());`
`26`	`26`	`llvm::StringRef fname(name_);`
`27`		`- return fname.startswith(".omp") \|\| fname.startswith("__kmpc") \|\| fname.startswith("__omp");`
	`27`	`+ return util::starts_with_any_of(fname, ".omp", "__kmpc", "__omp");`
`28`	`28`	`}`
`29`	`29`	`return false;`
`30`	`30`	`}`