[BOLT][NFC] Extract handleInterproceduralReference

[Amir]

update

bolt/include/bolt/Core/BinaryContext.h

void addAdrpAddRelocAArch64(BinaryFunction &BF, MCInst &LoadLowBits,
                               MCInst &LoadHiBits, uint64_t Target);
 
   /// Return true if AARch64 veneer was successfully matched at a given
   /// \p Address and register veneer binary function if \p MatchOnly
   /// argument is false.
   bool handleAArch64Veneer(uint64_t Address, bool MatchOnly = false);
 
   /// Resolve inter-procedural dependencies from
+  void handleInterproceduralReference(BinaryFunction &BF,
+                                      const uint64_t Address);
   void processInterproceduralReferences();
 
   /// Skip functions with all parent and child fragments transitively.
   void skipMarkedFragments();
 
   /// Perform any necessary post processing on the symbol table after
   /// function disassembly is complete.  This processing fixes top
   /// level data holes and makes sure the symbol table is valid.

bolt/lib/Core/BinaryContext.cpp

bool BinaryContext::handleAArch64Veneer(uint64_t Address, bool MatchOnly) {
   return Ret;
 }
 
 void BinaryContext::processInterproceduralReferences() {
   for (const std::pair<BinaryFunction *, uint64_t> &It :
        InterproceduralReferences) {
     BinaryFunction &Function = *It.first;
     uint64_t Address = It.second;
-    if (!Address || Function.isIgnored())
-      continue;
+    handleInterproceduralReference(Function, Address);
+  }
+
+  InterproceduralReferences.clear();
+}
+
+void BinaryContext::handleInterproceduralReference(BinaryFunction &Function,
+                                                   const uint64_t Address) {
+    return;
 
-    BinaryFunction *TargetFunction =
-        getBinaryFunctionContainingAddress(Address);
-    if (&Function == TargetFunction)
-      continue;
+  BinaryFunction *TargetFunction = getBinaryFunctionContainingAddress(Address);
+    return;
 
-    if (TargetFunction) {
-      if (TargetFunction->isFragment() &&
-          !registerFragment(*TargetFunction, 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);
 
-      continue;
-    }
+    return;
 
-    // Check if address falls in function padding space - this could be
-    // unmarked data in code. In this case adjust the padding space size.
-    ErrorOr<BinarySection &> Section = getSectionForAddress(Address);
-    assert(Section && "cannot get section for referenced address");
 
-    if (!Section->isText())
-      continue;
+    return;
 
-    // PLT requires special handling and could be ignored in this context.
-    StringRef SectionName = Section->getName();
-    if (SectionName == ".plt" || SectionName == ".plt.got")
-      continue;
+    return;
 
-    // Check if it is aarch64 veneer written at Address
-    if (isAArch64() && handleAArch64Veneer(Address))
-      continue;
+    return;
 
-    if (opts::processAllFunctions()) {
-      errs() << "BOLT-ERROR: cannot process binaries with unmarked "
-             << "object in code at address 0x" << Twine::utohexstr(Address)
-             << " belonging to section " << SectionName << " in current mode\n";
-      exit(1);
-    }
 
-    TargetFunction = getBinaryFunctionContainingAddress(Address,
-                                                        /*CheckPastEnd=*/false,
-                                                        /*UseMaxSize=*/true);
-    // We are not going to overwrite non-simple functions, but for simple
-    // ones - adjust the padding size.
-    if (TargetFunction && TargetFunction->isSimple()) {
-      errs() << "BOLT-WARNING: function " << *TargetFunction
-             << " has an object detected in a padding region at address 0x"
-             << Twine::utohexstr(Address) << '\n';
-      TargetFunction->setMaxSize(TargetFunction->getSize());
-    }
-  }
 
-  InterproceduralReferences.clear();
-}
-
 void BinaryContext::postProcessSymbolTable() {
   fixBinaryDataHoles();
   bool Valid = true;
   for (auto &Entry : BinaryDataMap) {
     BinaryData *BD = Entry.second;
     if ((BD->getName().startswith("SYMBOLat") ||
          BD->getName().startswith("DATAat")) &&
         !BD->getParent() && !BD->getSize() && !BD->isAbsolute() &&