[BOLT] Do run negate-ra-state rewriting passes on all functions

- if a BinaryFunction did not contain any .cfi_negate_ra_state,
  we can skip MarkRAStates and InsertNegateRAStatePass. This can happen
  with handwritten assembly, or if the binary was compiled in a way that
  drops DWARF tables.

Author: bgergely0

bolt/include/bolt/Core/BinaryFunction.h

@@ -148,6 +148,8 @@ class BinaryFunction {
     PF_MEMEVENT = 4, /// Profile has mem events.
   };
 
+  void setContainedNegateRAState() { HadNegateRAState = true; }
+  bool containedNegateRAState() { return HadNegateRAState; }
   void setInitialRAState(bool State) { InitialRAState = State; }
   bool getInitialRAState() { return InitialRAState; }
 
@@ -224,6 +226,10 @@ class BinaryFunction {
   /// Current state of the function.
   State CurrentState{State::Empty};
 
+  /// Indicates if the Function contained .cfi-negate-ra-state. These are not
+  /// read from the binary. This boolean is used when deciding to run the
+  /// .cfi-negate-ra-state rewriting passes on a function or not.
+  bool HadNegateRAState{false};
   bool InitialRAState{false};
 
   /// A list of symbols associated with the function entry point.

bolt/lib/Core/Exceptions.cpp

@@ -647,6 +647,7 @@ bool CFIReaderWriter::fillCFIInfoFor(BinaryFunction &Function) const {
       // DW_CFA_GNU_window_save and DW_CFA_AARCH64_negate_ra_state just use the
       // same id but mean different things. The latter is used in AArch64.
       if (Function.getBinaryContext().isAArch64()) {
+        Function.setContainedNegateRAState();
         // The location OpNegateRAState CFIs are needed
         // depends on the order of BasicBlocks, which changes during
         // optimizations. Instead of adding OpNegateRAState CFIs, an annotation

bolt/lib/Passes/InsertNegateRAStatePass.cpp

@@ -137,7 +137,13 @@ void InsertNegateRAState::fixUnknownStates(BinaryFunction &BF) {
 
 Error InsertNegateRAState::runOnFunctions(BinaryContext &BC) {
   ParallelUtilities::WorkFuncTy WorkFun = [&](BinaryFunction &BF) {
-    runOnFunction(BF);
+    if (BF.containedNegateRAState()) {
+      // 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`
+      runOnFunction(BF);
+    }
   };
 
   ParallelUtilities::runOnEachFunction(

bolt/lib/Passes/MarkRAStates.cpp

@@ -127,7 +127,13 @@ void MarkRAStates::runOnFunction(BinaryFunction &BF) {
 
 Error MarkRAStates::runOnFunctions(BinaryContext &BC) {
   ParallelUtilities::WorkFuncTy WorkFun = [&](BinaryFunction &BF) {
-    runOnFunction(BF);
+    if (BF.containedNegateRAState()) {
+      // 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`
+      runOnFunction(BF);
+    }
   };
 
   ParallelUtilities::runOnEachFunction(