[BOLT] Fix multithreading in llvm#120064

- use SkipPredicates,
- use atomic counters.

Author: bgergely0

bolt/include/bolt/Core/BinaryFunction.h

@@ -149,7 +149,7 @@ class BinaryFunction {
   };
 
   void setContainedNegateRAState() { HadNegateRAState = true; }
-  bool containedNegateRAState() { return HadNegateRAState; }
+  bool containedNegateRAState() const { return HadNegateRAState; }
   void setInitialRAState(bool State) { InitialRAState = State; }
   bool getInitialRAState() { return InitialRAState; }
 

bolt/include/bolt/Passes/InsertNegateRAStatePass.h

@@ -28,7 +28,6 @@ class InsertNegateRAState : public BinaryFunctionPass {
   void runOnFunction(BinaryFunction &BF);
 
 private:
-  uint64_t FunctionsModified{0};
   /// Because states are tracked as MCAnnotations on individual instructions,
   /// newly inserted instructions do not have a state associated with them.
   /// New states are "inherited" from the last known state.

bolt/include/bolt/Passes/MarkRAStates.h

@@ -26,9 +26,6 @@ class MarkRAStates : public BinaryFunctionPass {
   /// Pass entry point
   Error runOnFunctions(BinaryContext &BC) override;
   bool runOnFunction(BinaryFunction &BF);
-
-private:
-  uint64_t FunctionsIgnored{0};
 };
 
 } // namespace bolt

bolt/lib/Passes/InsertNegateRAStatePass.cpp

@@ -114,20 +114,23 @@ void InsertNegateRAState::inferUnknownStates(BinaryFunction &BF) {
 }
 
 Error InsertNegateRAState::runOnFunctions(BinaryContext &BC) {
+  std::atomic<uint64_t> FunctionsModified{0};
   ParallelUtilities::WorkFuncTy WorkFun = [&](BinaryFunction &BF) {
-    if (BF.containedNegateRAState() && !BF.isIgnored()) {
-      // We can skip functions which did not include negate-ra-state CFIs. This
-      // includes code using pac-ret hardening as well, if the binary is
-      // compiled with `-fno-exceptions -fno-unwind-tables
-      // -fno-asynchronous-unwind-tables`
-      FunctionsModified++;
-      runOnFunction(BF);
-    }
+    FunctionsModified++;
+    runOnFunction(BF);
+  };
+
+  ParallelUtilities::PredicateTy SkipPredicate = [&](const BinaryFunction &BF) {
+    // We can skip functions which did not include negate-ra-state CFIs. This
+    // includes code using pac-ret hardening as well, if the binary is
+    // compiled with `-fno-exceptions -fno-unwind-tables
+    // -fno-asynchronous-unwind-tables`
+    return !BF.containedNegateRAState() || BF.isIgnored();
   };
 
   ParallelUtilities::runOnEachFunction(
-      BC, ParallelUtilities::SchedulingPolicy::SP_TRIVIAL, WorkFun, nullptr,
-      "InsertNegateRAStatePass");
+      BC, ParallelUtilities::SchedulingPolicy::SP_TRIVIAL, WorkFun,
+      SkipPredicate, "InsertNegateRAStatePass");
 
   BC.outs() << "BOLT-INFO: rewritten pac-ret DWARF info in "
             << FunctionsModified << " out of " << BC.getBinaryFunctions().size()

bolt/lib/Passes/MarkRAStates.cpp

@@ -119,21 +119,24 @@ bool MarkRAStates::runOnFunction(BinaryFunction &BF) {
 }
 
 Error MarkRAStates::runOnFunctions(BinaryContext &BC) {
+  std::atomic<uint64_t> FunctionsIgnored{0};
   ParallelUtilities::WorkFuncTy WorkFun = [&](BinaryFunction &BF) {
-    if (BF.containedNegateRAState() && !BF.isIgnored()) {
-      // We can skip functions which did not include negate-ra-state CFIs. This
-      // includes code using pac-ret hardening as well, if the binary is
-      // compiled with `-fno-exceptions -fno-unwind-tables
-      // -fno-asynchronous-unwind-tables`
-      if (!runOnFunction(BF)) {
-        FunctionsIgnored++;
-      }
+    if (!runOnFunction(BF)) {
+      FunctionsIgnored++;
     }
   };
 
+  ParallelUtilities::PredicateTy SkipPredicate = [&](const BinaryFunction &BF) {
+    // We can skip functions which did not include negate-ra-state CFIs. This
+    // includes code using pac-ret hardening as well, if the binary is
+    // compiled with `-fno-exceptions -fno-unwind-tables
+    // -fno-asynchronous-unwind-tables`
+    return !BF.containedNegateRAState() || BF.isIgnored();
+  };
+
   ParallelUtilities::runOnEachFunction(
-      BC, ParallelUtilities::SchedulingPolicy::SP_TRIVIAL, WorkFun, nullptr,
-      "MarkRAStates");
+      BC, ParallelUtilities::SchedulingPolicy::SP_TRIVIAL, WorkFun,
+      SkipPredicate, "MarkRAStates");
 
   int Total = llvm::count_if(
       BC.getBinaryFunctions(),