[BOLT] Add support for safe-icf

bolt/include/bolt/Passes/IdenticalCodeFolding.h

@@ -39,20 +39,29 @@ class IdenticalCodeFolding : public BinaryFunctionPass {
     All,  // Aggressive ICF for code.
   };
   explicit IdenticalCodeFolding(const cl::opt<bool> &PrintPass)
-      : BinaryFunctionPass(PrintPass) {}
+      : BinaryFunctionPass(PrintPass) {
+    VtableBitVector.resize((((uint64_t)1) << 32) / 8);
+  }
 
   const char *getName() const override { return "identical-code-folding"; }
   Error runOnFunctions(BinaryContext &BC) override;
 
 private:
+  /// Bit vector of memory addresses of vtables.
+  llvm::BitVector VtableBitVector;
+  bool isInVTable(uint64_t Address) const {
+    return VtableBitVector.test(Address / 8);
+  }
+  /// Scans symbol table and creates a bit vector of memory addresses of
+  /// vtables.
+  void processSymbolTable(const BinaryContext &BC);
   /// Analyze .text section and relocations and mark functions that are not
   /// safe to fold.
   Error markFunctionsUnsafeToFold(BinaryContext &BC);
   /// Process relocations in the .data section to identify function
   /// references.
   Error processDataRelocations(BinaryContext &BC,
                                const SectionRef &SecRefRelData,
-                               const llvm::BitVector &BitVector,
                                const bool HasAddressTaken);
 };
 

bolt/lib/Passes/IdenticalCodeFolding.cpp

@@ -355,22 +355,21 @@ typedef std::unordered_map<BinaryFunction *, std::vector<BinaryFunction *>,
 namespace llvm {
 namespace bolt {
 /// Scans symbol table and creates a bit vector of memory addresses of vtables.
-static void processSymbolTable(const BinaryContext &BC,
-                               llvm::BitVector &BitVector) {
+void IdenticalCodeFolding::processSymbolTable(const BinaryContext &BC) {
   for (auto &[Address, Data] : BC.getBinaryData()) {
     // Filter out all symbols that are not vtables.
     if (!Data->getName().starts_with("_ZTV"))
       continue;
     for (uint64_t I = Address / 8, End = I + (Data->getSize() / 8); I < End;
          ++I)
-      BitVector.set(I);
+      VtableBitVector.set(I);
   }
 }
 Error IdenticalCodeFolding::processDataRelocations(
     BinaryContext &BC, const SectionRef &SecRefRelData,
-    const llvm::BitVector &BitVector, const bool HasAddressTaken) {
+    const bool HasAddressTaken) {
   for (const RelocationRef &Rel : SecRefRelData.relocations()) {
-    if (BitVector.test(Rel.getOffset() / 8))
+    if (isInVTable(Rel.getOffset()))
       continue;
     symbol_iterator SymbolIter = Rel.getSymbol();
     const ObjectFile *OwningObj = Rel.getObject();
@@ -393,10 +392,8 @@ Error IdenticalCodeFolding::processDataRelocations(
 
 Error IdenticalCodeFolding::markFunctionsUnsafeToFold(BinaryContext &BC) {
   if (!BC.isX86())
-    BC.outs() << "BOLT-WARNING: Safe ICF is only supported for x86\n";
-  constexpr uint64_t NumBits = (((uint64_t)1) << 32) / 8;
-  llvm::BitVector BitVector(NumBits);
-  processSymbolTable(BC, BitVector);
+    BC.outs() << "BOLT-WARNING: safe ICF is only supported for x86\n";
+  processSymbolTable(BC);
   for (const auto &Sec : BC.sections()) {
     if (!Sec.hasSectionRef() || !Sec.isRela())
       continue;
@@ -414,26 +411,26 @@ Error IdenticalCodeFolding::markFunctionsUnsafeToFold(BinaryContext &BC) {
     if (!RelocatedSecRef.isData() || SkipRelocs)
       continue;
 
-    Error ErrorStatus = processDataRelocations(BC, SecRef, BitVector,
-                                               /* HasAddressTaken */ true);
+    Error ErrorStatus =
+        processDataRelocations(BC, SecRef, /* HasAddressTaken */ true);
     if (ErrorStatus)
       return ErrorStatus;
   }
   ErrorOr<BinarySection &> SecRelDataIA =
       BC.getUniqueSectionByName(".rela.init_array");
   if (SecRelDataIA) {
     const SectionRef SecRefRelData = SecRelDataIA->getSectionRef();
-    Error ErrorStatus = processDataRelocations(BC, SecRefRelData, BitVector,
-                                               /* !HasAddressTaken */ false);
+    Error ErrorStatus =
+        processDataRelocations(BC, SecRefRelData, /* !HasAddressTaken */ false);
     if (ErrorStatus)
       return ErrorStatus;
   }
   ErrorOr<BinarySection &> SecRelDataFIA =
       BC.getUniqueSectionByName(".rela.fini_array");
   if (SecRelDataFIA) {
     const SectionRef SecRefRelData = SecRelDataFIA->getSectionRef();
-    Error ErrorStatus = processDataRelocations(BC, SecRefRelData, BitVector,
-                                               /* !HasAddressTaken */ false);
+    Error ErrorStatus =
+        processDataRelocations(BC, SecRefRelData, /* !HasAddressTaken */ false);
     if (ErrorStatus)
       return ErrorStatus;
   }