[WIP] Changing CG Profile to relocations based.

[ayermolo]

Summary

This patch combines three patches

1. LLD
2. objdump
3. LLVM.

This is for illustrative purposes, for post on llvm-dev, if it is agreed this is the direction we want to go will break it up in to three different patches.

Changed CG profile symbol index information to be encoded in relocations. This allows post processing tools like strip to be used on object files while preserving correct symbol indices.
Initial pathfinding done by @modimo.

[MaskRay]

lld/ELF/InputFiles.cpp

674

delete braces around one-line simple statements

llvm/tools/llvm-readobj/ELFDumper.cpp

1857

the loop should be skipped if DotCGProfileSecIndex is zero

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

1777

i -> I

6740

Fix clang-tidy warnings around here.

[MaskRay]

This can be abandoned now.

[ayermolo]

Full implementation: https://reviews.llvm.org/D104080

lld/ELF/Driver.cpp

for (StringRef line : args::getLines(mb)) {
 
     if (InputSectionBase *from = findSection(fields[0]))
       if (InputSectionBase *to = findSection(fields[1]))
         config->callGraphProfile[std::make_pair(from, to)] += count;
   }
 }
 
 template <class ELFT> static void readCallGraphsFromObjectFiles() {
+  const uint32_t sizeOfEntry = sizeof(Elf_CGProfile_Impl<ELFT>);
   for (auto file : objectFiles) {
     auto *obj = cast<ObjFile<ELFT>>(file);
+    std::vector<Elf_CGProfile_Impl<ELFT>> cgProfileC(obj->cgProfile.vec());
+    for (uint32_t i = 0, size = obj->cgProfileRela.size(); i < size; i += 2) {
+      const Elf_Rel_Impl<ELFT, true> &relFrom = obj->cgProfileRela[i];
+      const Elf_Rel_Impl<ELFT, true> &relTo = obj->cgProfileRela[i + 1];
+      uint32_t symIndexFrom = relFrom.getSymbol(config->isMips64EL);
+      uint32_t symIndexTo = relTo.getSymbol(config->isMips64EL);
+      uint32_t index = relFrom.r_offset / sizeOfEntry;
+      cgProfileC[index].cgp_from = symIndexFrom;
+      cgProfileC[index].cgp_to = symIndexTo;
+    }
 
-    for (const Elf_CGProfile_Impl<ELFT> &cgpe : obj->cgProfile) {
+    for (const Elf_CGProfile_Impl<ELFT> &cgpe : cgProfileC) {
       auto *fromSym = dyn_cast<Defined>(&obj->getSymbol(cgpe.cgp_from));
       auto *toSym = dyn_cast<Defined>(&obj->getSymbol(cgpe.cgp_to));
       if (!fromSym || !toSym)
         continue;
 
       auto *from = dyn_cast_or_null<InputSectionBase>(fromSym->section);
       auto *to = dyn_cast_or_null<InputSectionBase>(toSym->section);
       if (from && to)

lld/ELF/InputFiles.h

public:
 
   // True if the file defines functions compiled with -fsplit-stack,
   // but had one or more functions with the no_split_stack attribute.
   bool someNoSplitStack = false;
 
   // Pointer to this input file's .llvm_addrsig section, if it has one.
   const Elf_Shdr *addrsigSec = nullptr;
 
-  // SHT_LLVM_CALL_GRAPH_PROFILE table
+  // SHT_LLVM_CALL_GRAPH_PROFILE table.
   ArrayRef<Elf_CGProfile> cgProfile;
+  // SHT_LLVM_CALL_GRAPH_PROFILE relocations.
+  ArrayRef<Elf_Rela> cgProfileRela;
 
   // Get cached DWARF information.
   DWARFCache *getDwarf();
 
 private:
   void initializeSections(bool ignoreComdats);
   void initializeSymbols();
   void initializeJustSymbols();

lld/ELF/InputFiles.cpp

void ObjFile<ELFT>::initializeSections(bool ignoreComdats) {
 
   ArrayRef<Elf_Shdr> objSections = CHECK(obj.sections(), this);
   uint64_t size = objSections.size();
   this->sections.resize(size);
   this->sectionStringTable =
       CHECK(obj.getSectionStringTable(objSections), this);
 
   std::vector<ArrayRef<Elf_Word>> selectedGroups;
+  // SHT_LLVM_CALL_GRAPH_PROFILE Section Index.
+  size_t cgProfileSectionIndex = 0;
 
   for (size_t i = 0, e = objSections.size(); i < e; ++i) {
     if (this->sections[i] == &InputSection::discarded)
       continue;
     const Elf_Shdr &sec = objSections[i];
 
-    if (sec.sh_type == ELF::SHT_LLVM_CALL_GRAPH_PROFILE)
+    if (sec.sh_type == ELF::SHT_LLVM_CALL_GRAPH_PROFILE) {
       cgProfile =
           check(obj.template getSectionContentsAsArray<Elf_CGProfile>(sec));
+      cgProfileSectionIndex = i;
+    }
 
     // SHF_EXCLUDE'ed sections are discarded by the linker. However,
     // if -r is given, we'll let the final link discard such sections.
     // This is compatible with GNU.
     if ((sec.sh_flags & SHF_EXCLUDE) && !config->relocatable) {
       if (sec.sh_type == SHT_LLVM_ADDRSIG) {
         // We ignore the address-significance table if we know that the object
         // file was created by objcopy or ld -r. This is because these tools
void ObjFile<ELFT>::initializeSections(bool ignoreComdats) {
   //    such cases, the relocation section would attempt to reference a target
   //    section that has not yet been created. For simplicity, delay creation of
   //    relocation sections until now.
   for (size_t i = 0, e = objSections.size(); i < e; ++i) {
     if (this->sections[i] == &InputSection::discarded)
       continue;
     const Elf_Shdr &sec = objSections[i];
 
-    if (sec.sh_type == SHT_REL || sec.sh_type == SHT_RELA)
+    if (sec.sh_type == SHT_REL || sec.sh_type == SHT_RELA) {
+      if (sec.sh_info == cgProfileSectionIndex) {
+        cgProfileRela = CHECK(getObj().relas(sec), this);
+      }
       this->sections[i] = createInputSection(sec);
+    }
 
     // A SHF_LINK_ORDER section with sh_link=0 is handled as if it did not have
     // the flag.
     if (!(sec.sh_flags & SHF_LINK_ORDER) || !sec.sh_link)
       continue;
 
     InputSectionBase *linkSec = nullptr;
     if (sec.sh_link < this->sections.size())

llvm/lib/MC/ELFObjectWriter.cpp

for (MCSection &Sec : Asm) {
     if (RelSection) {
       SectionIndexMap[RelSection] = addToSectionTable(RelSection);
       Relocations.push_back(RelSection);
     }
 
     OWriter.TargetObjectWriter->addTargetSectionFlags(Ctx, Section);
   }
 
-  MCSectionELF *CGProfileSection = nullptr;
-  if (!Asm.CGProfile.empty()) {
-    CGProfileSection = Ctx.getELFSection(".llvm.call-graph-profile",
-                                         ELF::SHT_LLVM_CALL_GRAPH_PROFILE,
-                                         ELF::SHF_EXCLUDE, 16);
-    SectionIndexMap[CGProfileSection] = addToSectionTable(CGProfileSection);
-  }
-
   for (MCSectionELF *Group : Groups) {
     // Remember the offset into the file for this section.
     const uint64_t SecStart = align(Group->getAlignment());
 
     const MCSymbol *SignatureSymbol = Group->getGroup();
     assert(SignatureSymbol);
     write(uint32_t(Group->isComdat() ? unsigned(ELF::GRP_COMDAT) : 0));
     for (const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
if (Mode == DwoOnly) {
     if (OWriter.EmitAddrsigSection) {
       uint64_t SecStart = W.OS.tell();
       writeAddrsigSection();
       uint64_t SecEnd = W.OS.tell();
       SectionOffsets[AddrsigSection] = std::make_pair(SecStart, SecEnd);
     }
   }
 
-  if (CGProfileSection) {
-    uint64_t SecStart = W.OS.tell();
-    for (const MCAssembler::CGProfileEntry &CGPE : Asm.CGProfile) {
-      W.write<uint32_t>(CGPE.From->getSymbol().getIndex());
-      W.write<uint32_t>(CGPE.To->getSymbol().getIndex());
-      W.write<uint64_t>(CGPE.Count);
-    }
-    uint64_t SecEnd = W.OS.tell();
-    SectionOffsets[CGProfileSection] = std::make_pair(SecStart, SecEnd);
-  }
-
   {
     uint64_t SecStart = W.OS.tell();
     StrTabBuilder.write(W.OS);
     SectionOffsets[StrtabSection] = std::make_pair(SecStart, W.OS.tell());
   }
 
   const uint64_t SectionHeaderOffset = align(is64Bit() ? 8 : 4);
 
void ELFObjectWriter::recordRelocation(MCAssembler &Asm,
 
   const MCSectionELF *SecA = (SymA && SymA->isInSection())
                                  ? cast<MCSectionELF>(&SymA->getSection())
                                  : nullptr;
   if (!checkRelocation(Ctx, Fixup.getLoc(), &FixupSection, SecA))
     return;
 
   unsigned Type = TargetObjectWriter->getRelocType(Ctx, Target, Fixup, IsPCRel);
-  bool RelocateWithSymbol = shouldRelocateWithSymbol(Asm, RefA, SymA, C, Type);
+  const auto Parent = cast<MCSectionELF>(Fragment->getParent());
+  // Emiting relocation with sybmol for CG Profile to  help with --cg-profile.
+  bool RelocateWithSymbol =
+      shouldRelocateWithSymbol(Asm, RefA, SymA, C, Type) ||
+      (Parent->getType() == ELF::SHT_LLVM_CALL_GRAPH_PROFILE);
   uint64_t Addend = 0;
 
   FixedValue = !RelocateWithSymbol && SymA && !SymA->isUndefined()
                    ? C + Layout.getSymbolOffset(*SymA)
                    : C;
   if (hasRelocationAddend()) {
     Addend = FixedValue;
     FixedValue = 0;

llvm/lib/MC/MCELFStreamer.cpp

if (!S->isInSection()) {
           SRE->getLoc(), Twine("Reference to undefined temporary symbol ") +
                              "`" + S->getName() + "`");
       return;
     }
     S = S->getSection().getBeginSymbol();
     S->setUsedInReloc();
     SRE =
         MCSymbolRefExpr::create(S, SRE->getKind(), getContext(), SRE->getLoc());
-    return;
   }
-  // Not a temporary, referece it as a weak undefined.
-  bool Created;
-  getAssembler().registerSymbol(*S, &Created);
-  if (Created)
-    cast<MCSymbolELF>(S)->setBinding(ELF::STB_WEAK);
+  MCObjectStreamer::emitSymbolValue(S, 4);
 }
 
 void MCELFStreamer::finalizeCGProfile() {
-  for (MCAssembler::CGProfileEntry &E : getAssembler().CGProfile) {
+  MCAssembler &Asm = getAssembler();
+  if (Asm.CGProfile.empty())
+    return;
+  MCSection *CGProfile = getAssembler().getContext().getELFSection(
+      ".llvm.call-graph-profile", ELF::SHT_LLVM_CALL_GRAPH_PROFILE,
+      ELF::SHF_EXCLUDE, 16 /* sizeof(Elf_CGProfile_Impl<>)*/);
+  PushSection();
+  SwitchSection(CGProfile);
+
+  for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
     finalizeCGProfileEntry(E.From);
     finalizeCGProfileEntry(E.To);
+    emitIntValue(E.Count, sizeof(uint64_t));
   }
+  PopSection();
 }
 
 void MCELFStreamer::emitInstToFragment(const MCInst &Inst,
                                        const MCSubtargetInfo &STI) {
   this->MCObjectStreamer::emitInstToFragment(Inst, STI);
   MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
 
   for (auto &Fixup : F.getFixups())

llvm/test/MC/ELF/cgprofile.s

 # CHECK:      Name: .llvm.call-graph-profile
 # CHECK-NEXT: Type: SHT_LLVM_CALL_GRAPH_PROFILE (0x6FFF4C02)
 # CHECK-NEXT: Flags [ (0x80000000)
 # CHECK-NEXT: SHF_EXCLUDE (0x80000000)
 # CHECK-NEXT: ]
 # CHECK-NEXT: Address:
 # CHECK-NEXT: Offset:
 # CHECK-NEXT: Size: 64
-# CHECK-NEXT: Link: 6
+# CHECK-NEXT: Link: 7
 # CHECK-NEXT: Info: 0
 # CHECK-NEXT: AddressAlignment: 1
 # CHECK-NEXT: EntrySize: 16
 # CHECK-NEXT: SectionData (
-# CHECK-NEXT:   0000: 02000000 05000000 20000000 00000000
-# CHECK-NEXT:   0010: 07000000 02000000 0B000000 00000000
-# CHECK-NEXT:   0020: 06000000 03000000 14000000 00000000
-# CHECK-NEXT:   0030: 01000000 05000000 2A000000 00000000
+# CHECK-NEXT:   0000: 00000000 00000000 20000000 00000000
+# CHECK-NEXT:   0010: 00000000 00000000 0B000000 00000000
+# CHECK-NEXT:   0020: 00000000 00000000 14000000 00000000
+# CHECK-NEXT:   0030: 00000000 00000000 2A000000 00000000
 # CHECK-NEXT: )
 
 # CHECK: Symbols [
 # CHECK:      Name: a
 # CHECK-NEXT: Value:
 # CHECK-NEXT: Size:
 # CHECK-NEXT: Binding: Local
 # CHECK-NEXT: Type:

 # CHECK-NEXT: Size:
 # CHECK-NEXT: Binding: Global
 # CHECK-NEXT: Type:
 # CHECK-NEXT: Other:
 # CHECK-NEXT: Section: .test
 # CHECK:      Name: freq
 # CHECK-NEXT: Value:
 # CHECK-NEXT: Size:
-# CHECK-NEXT: Binding: Weak
+# CHECK-NEXT: Binding: Global
 # CHECK-NEXT: Type:
 # CHECK-NEXT: Other:
 # CHECK-NEXT: Section: Undefined
 # CHECK:      CGProfile [
 # CHECK-NEXT:   CGProfileEntry {
 # CHECK-NEXT:     From: a
 # CHECK-NEXT:     To: b
 # CHECK-NEXT:     Weight: 32

llvm/tools/llvm-readobj/ELFDumper.cpp

protected:
   DynRegionInfo DynSymTabShndxRegion;
   DynRegionInfo DynamicTable;
   StringRef DynamicStringTable;
   const Elf_Hash *HashTable = nullptr;
   const Elf_GnuHash *GnuHashTable = nullptr;
   const Elf_Shdr *DotSymtabSec = nullptr;
   const Elf_Shdr *DotDynsymSec = nullptr;
   const Elf_Shdr *DotCGProfileSec = nullptr;
+  const Elf_Shdr *DotCGProfileSecRela = nullptr;
   const Elf_Shdr *DotAddrsigSec = nullptr;
   DenseMap<const Elf_Shdr *, ArrayRef<Elf_Word>> ShndxTables;
   Optional<uint64_t> SONameOffset;
   Optional<DenseMap<uint64_t, std::vector<uint32_t>>> AddressToIndexMap;
 
   const Elf_Shdr *SymbolVersionSection = nullptr;   // .gnu.version
   const Elf_Shdr *SymbolVersionNeedSection = nullptr; // .gnu.version_r
   const Elf_Shdr *SymbolVersionDefSection = nullptr; // .gnu.version_d
: ObjDumper(Writer, O.getFileName()), ObjF(O), Obj(O.getELFFile()),
       FileName(O.getFileName()), DynRelRegion(O, *this),
       DynRelaRegion(O, *this), DynRelrRegion(O, *this),
       DynPLTRelRegion(O, *this), DynSymTabShndxRegion(O, *this),
       DynamicTable(O, *this) {
   if (!O.IsContentValid())
     return;
 
   typename ELFT::ShdrRange Sections = cantFail(Obj.sections());
-  for (const Elf_Shdr &Sec : Sections) {
+  uint32_t DotCGProfileSecIndex = 0;
+  for (unsigned i = 0, Size = Sections.size(); i < Size; ++i) {
+    const Elf_Shdr &Sec = Sections[i];
     switch (Sec.sh_type) {
     case ELF::SHT_SYMTAB:
       if (!DotSymtabSec)
         DotSymtabSec = &Sec;
       break;
     case ELF::SHT_DYNSYM:
       if (!DotDynsymSec)
         DotDynsymSec = &Sec;
case ELF::SHT_GNU_verdef:
       if (!SymbolVersionDefSection)
         SymbolVersionDefSection = &Sec;
       break;
     case ELF::SHT_GNU_verneed:
       if (!SymbolVersionNeedSection)
         SymbolVersionNeedSection = &Sec;
       break;
     case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
-      if (!DotCGProfileSec)
+      if (!DotCGProfileSec) {
         DotCGProfileSec = &Sec;
+        DotCGProfileSecIndex = i;
+      }
       break;
     case ELF::SHT_LLVM_ADDRSIG:
       if (!DotAddrsigSec)
         DotAddrsigSec = &Sec;
       break;
     }
   }
 
+  // Following LLD lead and doing a seperate loop in case relocation section
+  // comes before section it applies to.
+  for (const Elf_Shdr &Sec : Sections) {
+    if (Sec.sh_info == DotCGProfileSecIndex) {
+      DotCGProfileSecRela = &Sec;
+      break;
+    }
+  }
+
   loadDynamicTable();
 }
 
 template <typename ELFT> void ELFDumper<ELFT>::parseDynamicTable() {
   auto toMappedAddr = [&](uint64_t Tag, uint64_t VAddr) -> const uint8_t * {
     auto MappedAddrOrError = Obj.toMappedAddr(VAddr, [&](const Twine &Msg) {
       this->reportUniqueWarning(Msg);
       return Error::success();
template <class ELFT> void LLVMELFDumper<ELFT>::printHashHistograms() {
   W.startLine() << "Hash Histogram not implemented!\n";
 }
 
 template <class ELFT> void LLVMELFDumper<ELFT>::printCGProfile() {
   ListScope L(W, "CGProfile");
   if (!this->DotCGProfileSec)
     return;
 
+  std::vector<Elf_CGProfile> CGProfileVec;
   Expected<ArrayRef<Elf_CGProfile>> CGProfileOrErr =
       this->Obj.template getSectionContentsAsArray<Elf_CGProfile>(
           *this->DotCGProfileSec);
   if (!CGProfileOrErr) {
     this->reportUniqueWarning(
         "unable to dump the SHT_LLVM_CALL_GRAPH_PROFILE section: " +
         toString(CGProfileOrErr.takeError()));
     return;
   }
 
-  for (const Elf_CGProfile &CGPE : *CGProfileOrErr) {
+  CGProfileVec = *CGProfileOrErr;
+  if (this->DotCGProfileSecRela) {
+    Expected<Elf_Rela_Range> CGProfileRelaOrError =
+        this->Obj.relas(*this->DotCGProfileSecRela);
+    if (!CGProfileRelaOrError) {
+      this->reportUniqueWarning(
+          "unable to dump the SHT_LLVM_CALL_GRAPH_PROFILE section: " +
+          toString(CGProfileOrErr.takeError()) + "with relocations.");
+      return;
+    }
+
+    const uint32_t sizeOfEntry = sizeof(Elf_CGProfile_Impl<ELFT>);
+    for (uint32_t i = 0, size = CGProfileRelaOrError->size(); i < size;
+         i += 2) {
+      const Elf_Rel_Impl<ELFT, true> &relFrom = (*CGProfileRelaOrError)[i];
+      const Elf_Rel_Impl<ELFT, true> &relTo = (*CGProfileRelaOrError)[i + 1];
+      uint32_t symIndexFrom = relFrom.getSymbol(this->Obj.isMips64EL());
+      uint32_t symIndexTo = relTo.getSymbol(this->Obj.isMips64EL());
+      uint32_t index = relFrom.r_offset / sizeOfEntry;
+      CGProfileVec[index].cgp_from = symIndexFrom;
+      CGProfileVec[index].cgp_to = symIndexTo;
+    }
+  }
+
+  for (const Elf_CGProfile &CGPE : CGProfileVec) {
     DictScope D(W, "CGProfileEntry");
     W.printNumber("From", this->getStaticSymbolName(CGPE.cgp_from),
                   CGPE.cgp_from);
     W.printNumber("To", this->getStaticSymbolName(CGPE.cgp_to),
                   CGPE.cgp_to);
     W.printNumber("Weight", CGPE.cgp_weight);
   }
 }