[BOLT] Rename BF::isParentFragment -> isChildOf

[Amir]

Summary

isChildOf is a more concise name for the check. Also, there's no need to
test if the function is a fragment before doing isChildOf check.

[rafauler]

LGTM

[maksfb]

LGTM. Thanks.

bolt/include/bolt/Core/BinaryFunction.h

   /// Return the size of this function' image in memory.
   uint64_t getImageSize() const {
     return getLayout().getMainFragment().getImageSize();
   }
 
   /// Return true if the function is a secondary fragment of another function.
   bool isFragment() const { return IsFragment; }
 
-  /// Returns if the given function is a parent fragment of this function.
-  bool isParentFragment(BinaryFunction *Parent) const {
-    return ParentFragments.count(Parent);
+  /// Returns if this function is a child of \p Other function.
+  bool isChildOf(const BinaryFunction &Other) const {
+    return llvm::is_contained(ParentFragments, &Other);
   }
 
   /// Set the profile data for the number of times the function was called.
   BinaryFunction &setExecutionCount(uint64_t Count) {
     ExecutionCount = Count;
     return *this;
   }
 

bolt/lib/Core/BinaryContext.cpp

bool BinaryContext::analyzeJumpTable(
   auto doesBelongToFunction = [&](const uint64_t Addr,
                                   BinaryFunction *TargetBF) -> bool {
     if (BF.containsAddress(Addr))
       return true;
     // Nothing to do if we failed to identify the containing function.
     if (!TargetBF)
       return false;
     // Check if BF is a fragment of TargetBF or vice versa.
-    return (BF.isFragment() && BF.isParentFragment(TargetBF)) ||
-           (TargetBF->isFragment() && TargetBF->isParentFragment(&BF));
+    return BF.isChildOf(*TargetBF) || TargetBF->isChildOf(BF);
   };
 
   ErrorOr<BinarySection &> Section = getSectionForAddress(Address);
   if (!Section)
     return false;
 
   // The upper bound is defined by containing object, section limits, and
   // the next jump table in memory.
registerNameAtAddress(Name, Address, SymbolSize ? SymbolSize : Size,
                         Alignment);
   setSymbolToFunctionMap(BF->getSymbol(), BF);
   return BF;
 }
 
 const MCSymbol *
 BinaryContext::getOrCreateJumpTable(BinaryFunction &Function, uint64_t Address,
                                     JumpTable::JumpTableType Type) {
-  auto isFragmentOf = [](BinaryFunction *Fragment, BinaryFunction *Parent) {
-    return (Fragment->isFragment() && Fragment->isParentFragment(Parent));
-  };
-  (void)isFragmentOf;
-
   // Two fragments of same function access same jump table
   if (JumpTable *JT = getJumpTableContainingAddress(Address)) {
     assert(JT->Type == Type && "jump table types have to match");
     assert(Address == JT->getAddress() && "unexpected non-empty jump table");
 
     // Prevent associating a jump table to a specific fragment twice.
     // This simple check arises from the assumption: no more than 2 fragments.
     if (JT->Parents.size() == 1 && JT->Parents[0] != &Function) {
-      assert((isFragmentOf(JT->Parents[0], &Function) ||
-              isFragmentOf(&Function, JT->Parents[0])) &&
+      assert((JT->Parents[0]->isChildOf(Function) ||
+              Function.isChildOf(*JT->Parents[0])) &&
              "cannot re-use jump table of a different function");
       // Duplicate the entry for the parent function for easy access
       JT->Parents.push_back(&Function);
       if (opts::Verbosity > 2) {
         outs() << "BOLT-INFO: Multiple fragments access same jump table: "
                << JT->Parents[0]->getPrintName() << "; "
                << Function.getPrintName() << "\n";
         JT->print(outs());
if (!opts::Verbosity)
       errs() << ". Use -v=1 to see the list.";
     errs() << '\n';
   }
 }
 
 bool BinaryContext::registerFragment(BinaryFunction &TargetFunction,
                                      BinaryFunction &Function) const {
   assert(TargetFunction.isFragment() && "TargetFunction must be a fragment");
-  if (TargetFunction.isParentFragment(&Function))
+  if (TargetFunction.isChildOf(Function))
     return true;
   TargetFunction.addParentFragment(Function);
   Function.addFragment(TargetFunction);
   if (!HasRelocations) {
     TargetFunction.setSimple(false);
     Function.setSimple(false);
   }
   if (opts::Verbosity >= 1) {
for (const std::pair<BinaryFunction *, uint64_t> &It :
 
     BinaryFunction *TargetFunction =
         getBinaryFunctionContainingAddress(Address);
     if (&Function == TargetFunction)
       continue;
 
     if (TargetFunction) {
       if (TargetFunction->isFragment() &&
-          !TargetFunction->isParentFragment(&Function)) {
+          !TargetFunction->isChildOf(Function)) {
         errs() << "BOLT-WARNING: interprocedural reference between unrelated "
                   "fragments: "
                << Function.getPrintName() << " and "
                << TargetFunction->getPrintName() << '\n';
       }
       if (uint64_t Offset = Address - TargetFunction->getAddress())
         TargetFunction->addEntryPointAtOffset(Offset);
 

bolt/lib/Core/Exceptions.cpp

while (CallSitePtr < CallSiteTableEnd) {
     // Support landing pad to builtin_unreachable
     if (LPAddress < Address || LPAddress > Address + getSize()) {
       BinaryFunction *Fragment =
           BC.getBinaryFunctionContainingAddress(LPAddress);
       assert(Fragment != nullptr &&
              "BOLT-ERROR: cannot find landing pad fragment");
       BC.addInterproceduralReference(this, Fragment->getAddress());
       BC.processInterproceduralReferences();
-      auto isFragmentOf = [](BinaryFunction *Fragment,
-                             BinaryFunction *Parent) -> bool {
-        return (Fragment->isFragment() && Fragment->isParentFragment(Parent));
-      };
-      (void)isFragmentOf;
-      assert((isFragmentOf(this, Fragment) || isFragmentOf(Fragment, this)) &&
+      assert((isChildOf(*Fragment) || Fragment->isChildOf(*this)) &&
              "BOLT-ERROR: cannot have landing pads in different "
              "functions");
       setHasIndirectTargetToSplitFragment(true);
       BC.addFragmentsToSkip(this);
       return;
     }
 
     if (opts::PrintExceptions) {