Merge from 'main' to 'sycl-web' (276 commits)

  CONFLICT (content): Merge conflict in openmp/libomptarget/test/unified_shared_memory/api.c

Author: haonanya1

bolt/include/bolt/Core/DebugData.h

@@ -1049,12 +1049,9 @@ class DebugAbbrevWriter {
     assert(&Unit.getContext() == &Context &&
            "cannot update attribute from a different DWARF context");
     std::lock_guard<std::mutex> Lock(WriterMutex);
-    bool AlreadyAdded = false;
-    for (AbbrevEntry &E : NewAbbrevEntries[&Unit][Abbrev])
-      if (E.Attr == AttrTag) {
-        AlreadyAdded = true;
-        break;
-      }
+    bool AlreadyAdded =
+        llvm::any_of(NewAbbrevEntries[&Unit][Abbrev],
+                     [&](AbbrevEntry &E) { return E.Attr == AttrTag; });
 
     if (AlreadyAdded)
       return;

bolt/include/bolt/Profile/DataReader.h

@@ -449,7 +449,7 @@ class DataReader : public ProfileReaderBase {
   bool usesEvent(StringRef Name) const {
     for (auto I = EventNames.begin(), E = EventNames.end(); I != E; ++I) {
       StringRef Event = I->getKey();
-      if (Event.find(Name) != StringRef::npos)
+      if (Event.contains(Name))
         return true;
     }
     return false;

bolt/lib/Core/BinaryFunction.cpp

@@ -1824,13 +1824,9 @@ bool BinaryFunction::postProcessIndirectBranches(
       // If this block contains an epilogue code and has an indirect branch,
       // then most likely it's a tail call. Otherwise, we cannot tell for sure
       // what it is and conservatively reject the function's CFG.
-      bool IsEpilogue = false;
-      for (const MCInst &Instr : BB) {
-        if (BC.MIB->isLeave(Instr) || BC.MIB->isPop(Instr)) {
-          IsEpilogue = true;
-          break;
-        }
-      }
+      bool IsEpilogue = llvm::any_of(BB, [&](const MCInst &Instr) {
+        return BC.MIB->isLeave(Instr) || BC.MIB->isPop(Instr);
+      });
       if (IsEpilogue) {
         BC.MIB->convertJmpToTailCall(Instr);
         BB.removeAllSuccessors();

bolt/lib/Passes/FrameAnalysis.cpp

@@ -56,20 +56,11 @@ bool shouldFrameOptimize(const llvm::bolt::BinaryFunction &Function) {
     FrameOptFunctionNamesFile = "";
   }
 
-  bool IsValid = true;
-  if (!FrameOptFunctionNames.empty()) {
-    IsValid = false;
-    for (std::string &Name : FrameOptFunctionNames) {
-      if (Function.hasName(Name)) {
-        IsValid = true;
-        break;
-      }
-    }
-  }
-  if (!IsValid)
-    return false;
-
-  return IsValid;
+  if (FrameOptFunctionNames.empty())
+    return true;
+  return llvm::any_of(FrameOptFunctionNames, [&](std::string &Name) {
+    return Function.hasName(Name);
+  });
 }
 } // namespace opts
 

bolt/lib/Passes/PatchEntries.cpp

@@ -13,6 +13,7 @@
 
 #include "bolt/Passes/PatchEntries.h"
 #include "bolt/Utils/NameResolver.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace opts {
@@ -34,14 +35,11 @@ void PatchEntries::runOnFunctions(BinaryContext &BC) {
   if (!opts::ForcePatch) {
     // Mark the binary for patching if we did not create external references
     // for original code in any of functions we are not going to emit.
-    bool NeedsPatching = false;
-    for (auto &BFI : BC.getBinaryFunctions()) {
-      BinaryFunction &Function = BFI.second;
-      if (!BC.shouldEmit(Function) && !Function.hasExternalRefRelocations()) {
-        NeedsPatching = true;
-        break;
-      }
-    }
+    bool NeedsPatching = llvm::any_of(
+        llvm::make_second_range(BC.getBinaryFunctions()),
+        [&](BinaryFunction &BF) {
+          return !BC.shouldEmit(BF) && !BF.hasExternalRefRelocations();
+        });
 
     if (!NeedsPatching)
       return;

bolt/lib/Passes/ReorderData.cpp

@@ -108,13 +108,9 @@ bool filterSymbol(const BinaryData *BD) {
   bool IsValid = true;
 
   if (!opts::ReorderSymbols.empty()) {
-    IsValid = false;
-    for (const std::string &Name : opts::ReorderSymbols) {
-      if (BD->hasName(Name)) {
-        IsValid = true;
-        break;
-      }
-    }
+    IsValid = llvm::any_of(opts::ReorderSymbols, [&](const std::string &Name) {
+      return BD->hasName(Name);
+    });
   }
 
   if (!IsValid)

bolt/lib/Passes/ShrinkWrapping.cpp

@@ -1810,14 +1810,10 @@ BBIterTy ShrinkWrapping::processInsertion(BBIterTy InsertionPoint,
 BBIterTy ShrinkWrapping::processInsertionsList(
     BBIterTy InsertionPoint, BinaryBasicBlock *CurBB,
     std::vector<WorklistItem> &TodoList, int64_t SPVal, int64_t FPVal) {
-  bool HasInsertions = false;
-  for (WorklistItem &Item : TodoList) {
-    if (Item.Action == WorklistItem::Erase ||
-        Item.Action == WorklistItem::ChangeToAdjustment)
-      continue;
-    HasInsertions = true;
-    break;
-  }
+  bool HasInsertions = llvm::any_of(TodoList, [&](WorklistItem &Item) {
+    return Item.Action == WorklistItem::InsertLoadOrStore ||
+           Item.Action == WorklistItem::InsertPushOrPop;
+  });
 
   if (!HasInsertions)
     return InsertionPoint;

bolt/lib/Profile/DataAggregator.cpp

@@ -18,6 +18,7 @@
 #include "bolt/Profile/Heatmap.h"
 #include "bolt/Utils/CommandLineOpts.h"
 #include "bolt/Utils/Utils.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
@@ -1157,7 +1158,7 @@ ErrorOr<DataAggregator::PerfMemSample> DataAggregator::parseMemSample() {
   ErrorOr<StringRef> Event = parseString(FieldSeparator);
   if (std::error_code EC = Event.getError())
     return EC;
-  if (Event.get().find("mem-loads") == StringRef::npos) {
+  if (!Event.get().contains("mem-loads")) {
     consumeRestOfLine();
     return Res;
   }
@@ -2022,19 +2023,16 @@ std::error_code DataAggregator::parseMMapEvents() {
     MMapInfo &MMapInfo = I->second;
     if (BC->HasFixedLoadAddress && MMapInfo.MMapAddress) {
       // Check that the binary mapping matches one of the segments.
-      bool MatchFound = false;
-      for (auto &KV : BC->SegmentMapInfo) {
-        SegmentInfo &SegInfo = KV.second;
-        // The mapping is page-aligned and hence the MMapAddress could be
-        // different from the segment start address. We cannot know the page
-        // size of the mapping, but we know it should not exceed the segment
-        // alignment value. Hence we are performing an approximate check.
-        if (SegInfo.Address >= MMapInfo.MMapAddress &&
-            SegInfo.Address - MMapInfo.MMapAddress < SegInfo.Alignment) {
-          MatchFound = true;
-          break;
-        }
-      }
+      bool MatchFound = llvm::any_of(
+          llvm::make_second_range(BC->SegmentMapInfo),
+          [&](SegmentInfo &SegInfo) {
+            // The mapping is page-aligned and hence the MMapAddress could be
+            // different from the segment start address. We cannot know the page
+            // size of the mapping, but we know it should not exceed the segment
+            // alignment value. Hence we are performing an approximate check.
+            return SegInfo.Address >= MMapInfo.MMapAddress &&
+                   SegInfo.Address - MMapInfo.MMapAddress < SegInfo.Alignment;
+          });
       if (!MatchFound) {
         errs() << "PERF2BOLT-WARNING: ignoring mapping of " << NameToUse
                << " at 0x" << Twine::utohexstr(MMapInfo.MMapAddress) << '\n';

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -31,6 +31,7 @@
 #include "bolt/Utils/CommandLineOpts.h"
 #include "bolt/Utils/Utils.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
@@ -2500,15 +2501,12 @@ void RewriteInstance::handleRelocation(const SectionRef &RelocatedSection,
             BC->getBinaryFunctionAtAddress(Address + 1)) {
       // Do an extra check that the function was referenced previously.
       // It's a linear search, but it should rarely happen.
-      bool Found = false;
-      for (const auto &RelKV : ContainingBF->Relocations) {
-        const Relocation &Rel = RelKV.second;
-        if (Rel.Symbol == RogueBF->getSymbol() &&
-            !Relocation::isPCRelative(Rel.Type)) {
-          Found = true;
-          break;
-        }
-      }
+      bool Found =
+          llvm::any_of(llvm::make_second_range(ContainingBF->Relocations),
+                       [&](const Relocation &Rel) {
+                         return Rel.Symbol == RogueBF->getSymbol() &&
+                                !Relocation::isPCRelative(Rel.Type);
+                       });
 
       if (Found) {
         errs() << "BOLT-WARNING: detected possible compiler de-virtualization "

bolt/utils/nfc-check-setup.py

@@ -59,7 +59,7 @@ def main():
                            text=True).stdout
     if stash:
         # save local changes before checkout
-        subprocess.run(shlex.split("git stash"), cwd=source_dir)
+        subprocess.run(shlex.split("git stash push -u"), cwd=source_dir)
     # check out the previous commit
     subprocess.run(shlex.split("git checkout -f HEAD^"), cwd=source_dir)
     # get the parent commit hash for logging

clang-tools-extra/clang-change-namespace/ChangeNamespace.cpp

@@ -206,7 +206,7 @@ std::string getShortestQualifiedNameInNamespace(llvm::StringRef DeclName,
                                                 llvm::StringRef NsName) {
   DeclName = DeclName.ltrim(':');
   NsName = NsName.ltrim(':');
-  if (DeclName.find(':') == llvm::StringRef::npos)
+  if (!DeclName.contains(':'))
     return std::string(DeclName);
 
   auto NsNameSplitted = splitSymbolName(NsName);

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

@@ -8,6 +8,7 @@
 
 #include "AssignmentInIfConditionCheck.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
@@ -17,30 +18,61 @@ namespace tidy {
 namespace bugprone {
 
 void AssignmentInIfConditionCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(ifStmt(hasCondition(forEachDescendant(
-                         binaryOperator(isAssignmentOperator())
-                             .bind("assignment_in_if_statement")))),
-                     this);
-  Finder->addMatcher(ifStmt(hasCondition(forEachDescendant(
-                         cxxOperatorCallExpr(isAssignmentOperator())
-                             .bind("assignment_in_if_statement")))),
-                     this);
+  Finder->addMatcher(translationUnitDecl(), this);
 }
 
 void AssignmentInIfConditionCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  const auto *MatchedDecl =
-      Result.Nodes.getNodeAs<clang::Stmt>("assignment_in_if_statement");
-  if (!MatchedDecl) {
-    return;
-  }
-  diag(MatchedDecl->getBeginLoc(),
-       "an assignment within an 'if' condition is bug-prone");
-  diag(MatchedDecl->getBeginLoc(),
+    const ast_matchers::MatchFinder::MatchResult &Result) {
+  class Visitor : public RecursiveASTVisitor<Visitor> {
+    AssignmentInIfConditionCheck &Check;
+
+  public:
+    explicit Visitor(AssignmentInIfConditionCheck &Check) : Check(Check) {}
+    bool VisitIfStmt(IfStmt *If) {
+      class ConditionVisitor : public RecursiveASTVisitor<ConditionVisitor> {
+        AssignmentInIfConditionCheck &Check;
+
+      public:
+        explicit ConditionVisitor(AssignmentInIfConditionCheck &Check)
+            : Check(Check) {}
+
+        // Dont traverse into any lambda expressions.
+        bool TraverseLambdaExpr(LambdaExpr *, DataRecursionQueue * = nullptr) {
+          return true;
+        }
+
+        bool VisitBinaryOperator(BinaryOperator *BO) {
+          if (BO->isAssignmentOp())
+            Check.report(BO);
+          return true;
+        }
+
+        bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *OCE) {
+          if (OCE->isAssignmentOp())
+            Check.report(OCE);
+          return true;
+        }
+      };
+
+      ConditionVisitor(Check).TraverseStmt(If->getCond());
+      return true;
+    }
+  };
+  Visitor(*this).TraverseAST(*Result.Context);
+}
+
+void AssignmentInIfConditionCheck::report(const Expr *AssignmentExpr) {
+  SourceLocation OpLoc =
+      isa<BinaryOperator>(AssignmentExpr)
+          ? cast<BinaryOperator>(AssignmentExpr)->getOperatorLoc()
+          : cast<CXXOperatorCallExpr>(AssignmentExpr)->getOperatorLoc();
+
+  diag(OpLoc, "an assignment within an 'if' condition is bug-prone")
+      << AssignmentExpr->getSourceRange();
+  diag(OpLoc,
        "if it should be an assignment, move it out of the 'if' condition",
        DiagnosticIDs::Note);
-  diag(MatchedDecl->getBeginLoc(),
-       "if it is meant to be an equality check, change '=' to '=='",
+  diag(OpLoc, "if it is meant to be an equality check, change '=' to '=='",
        DiagnosticIDs::Note);
 }
 

clang-tools-extra/clang-tidy/bugprone/AssignmentInIfConditionCheck.h

@@ -25,6 +25,7 @@ class AssignmentInIfConditionCheck : public ClangTidyCheck {
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void report(const Expr *AssignmentExpr);
 };
 
 } // namespace bugprone