[LLD][LLVM] CG Graph profile using relocations

[ayermolo]

Summary

Currently when .llvm.call-graph-profile is created by llvm it explicitly encodes the symbol indices. This section is basically a black box for post processing tools. For example, if we run strip -s on the object files the symbol table changes, but indices in that section do not. In non-visible behavior indices point to wrong symbols. The visible behavior indices point outside of Symbol table: "invalid symbol index".

This patch changes the format by using R_*_NONE relocations to indicate the from/to symbols. The Frequency (Weight) will still be in the .llvm.call-graph-profile, but symbol information will be in relocation section. In LLD information from both sections is used to reconstruct call graph profile. Relocations themselves will never be applied.

With this approach post processing tools that handle relocations correctly work for this section also. Tools can add/remove symbols and as long as they handle relocation sections with this approach information stays correct.

Doing a quick experiment with clang-13.
The size went up from 107KB to 322KB, aggregate of all the input sections. Size of clang-13 binary is ~118MB. For users of -fprofile-use/-fprofile-sample-use the size of object files will go up slightly, it will not impact final binary size.

[ayermolo]

Fixed up some build and clang-tidy issues.

[jhenderson]

The size went up from 107KB to 322KB, aggregate of all the input sections.

That sounds like a lot (3x increase). How does this impact link times?

Is this patch intended to be reviewed as-is, or is this still illustrative?

[ayermolo]

In D104080#2812525, @jhenderson wrote:

The size went up from 107KB to 322KB, aggregate of all the input sections.

That sounds like a lot (3x increase). How does this impact link times?

Is this patch intended to be reviewed as-is, or is this still illustrative?

Sorry, yes reviewed as-is.
The increase is driven by couple of things. This is for ELF64 so to/from total goes from 8 bytes to 16 bytes. I am also using RELA which adds another 8 bytes for addend. @MaskRay suggested using REL, but looking at the code where it's chooses, it seems like there is just one global flag for the writer. Not sure if this is on purpose or just for ease of implementation. If anyone has insights would love to hear it.
I did timings on clang.
Old:
0:01.16 real, 1.07 user, 6.63 sys, 0 amem, 685040 mmem
0:01.23 real, 1.17 user, 8.87 sys, 0 amem, 689600 mmem
0:01.17 real, 1.15 user, 7.19 sys, 0 amem, 690520 mmem

New
0:01.10 real, 1.11 user, 6.46 sys, 0 amem, 690772 mmem
0:01.10 real, 1.10 user, 7.25 sys, 0 amem, 685932 mmem
0:01.09 real, 1.09 user, 6.28 sys, 0 amem, 685900 mmem

user time went up negligibly, real time and sys time are noise.
Relocation sections do not participate in actual relocations, and it's just a linear scan through memory to process them. I doubt it will have significant impact on linking times with bigger binaries.

[MaskRay]

lld/ELF/Driver.cpp

870

uint32_t

871

uint32_t

lld/ELF/InputFiles.cpp

681

remove braces around one-line simple statement

llvm/lib/MC/MCELFStreamer.cpp

498

it's ugly, but you can use .reloc xxx, BFD_RELOC_NONE, sym

llvm/lib/Target/AVR/MCTargetDesc/AVRAsmBackend.h

53 ↗

(On Diff #351333)

unreachable doesn't need return

[jhenderson]

Are call graph sections expected in fully linked output?

llvm/lib/MC/MCELFStreamer.cpp

511

llvm/test/tools/llvm-readobj/ELF/call-graph-profile.test

41–51

We usually line up the values in a block to make it a little more readable.

llvm/test/tools/obj2yaml/ELF/call-graph-profile-section.yaml

34

obj2yaml doesn't care about the relocation section. The code for converting the section to yaml should be independent of the relocations as far as I understand it. I'd remove the relocations to avoid confusing the test. This should allow you then to remove most of the other changes in this test too.

57–58

We're not matching whitespace exactly, so I'd minimise the extra, much like it was before, so that the key and value are closer. This tends to be a little bit more readable. Same goes throughout.

llvm/test/tools/yaml2obj/ELF/call-graph-profile-section.yaml

48

Don't check the SectionData of the relocation section. In fact, don't bother having a relocation section at all - this isn't relevant to how yaml2obj generates the call graph section.

llvm/tools/llvm-readobj/ELFDumper.cpp

1783

1853–1860

This code will only allow one .cg_profile section per object, which may or may not be appropriate (it's true that this was the case before, but was it correct then?). Either way, we already have printRelocatableStackSizes which finds all .stack_sizes sections and their corresponding relocation sections. Maybe rather than having two similar pieces of code that do basically the same thing, but in different ways, we should combine them?

6703–6704

Seems like it should be some sort of warning and print a partial profile section when the relocations can't be found.

6718–6719

Error and warning messages shouldn't end with . as per the coding standards.

I'd actually rephrase this: "unable to load relocations for SHT_LLVM_CALL_GRAPH_PROFILE section: " + toString(CGProfileOrErr.takeError())

This error case needs a test case.

In a similar vein to my earlier comment, we might want to include the section index of the call graph section in this message, so that if there is more than one such section, we can easily identify the problematic one.

6722–6723

Seems like this shouldn't be an assert, but a proper warning? If you create a broken object with the wrong number of relocations, this assertion will fire.

6730

Match the return type of size().

[ayermolo]

llvm/lib/MC/MCELFStreamer.cpp

498

This will reduce the scope of changes in this patch, but then new backend creator will need to know of this trick. I don't know the history of BFD_RELOC_NONE. Is it expected for architectures that have _NONE to have the mapping?
. .Case("BFD_RELOC_NONE", ELF::R_<arch>_NONE)

llvm/lib/Target/AVR/MCTargetDesc/AVRAsmBackend.h

53 ↗

(On Diff #351333)

I was following example of fixupNeedsRelaxation. Will remove.

llvm/tools/llvm-readobj/ELFDumper.cpp

1853–1860

Hmm, well from my understanding if it comes from clang side it should be one per object file. I guess someone can construct object with multiple ones, using say yaml2obj, but what would be practical point of it? LLD right now doesn't support that scenario.
I looked in to printRelocatableStackSizes, not sure there is enough code worth combining, but seems like a good way to keep all the code related to printing cg profile in one place. Let me refactor and see what comes out of it.

6722–6723

I can change it to warning, but then will need to add a check not to execute a loop.

[ayermolo]

llvm/test/tools/yaml2obj/ELF/call-graph-profile-section.yaml

48

I think relocation is needed in this case. Check is done with llvm-readobj --cg-profile. Unless that flag can be dropped?

[jhenderson]

llvm/test/tools/yaml2obj/ELF/call-graph-profile-section.yaml

48

The llvm-readobj check of the cg-profile data is a nice-to-have to confirm that our tools are self-consistent. However, I'm not sure it's really necessary, since we have a dedicated llvm-readobj test that uses the yaml output, which covers this sort of case.

llvm/tools/llvm-readobj/ELFDumper.cpp

1853–1860

I was thinking the factored out code would be something like:

std::vector<std::pair<Elf_Shdr*, Elf_Shdr*>> getSectionAndRelocations(std::function<bool(Elf_Shdr*)> IsMatch) {/*...*/}

where each of the different users would provide their own predicate (i.e. name or type check in the cg profile and stack sizes cases). Types in the example are just a rough idea. In the cgprofile case, we can just pick one pair from the vector.

6722–6723

This is what I had in mind, and is similar to the pattern elsewhere:

if (CGProfileRelaOrError->size() != (CGProfileOrErr->size() * 2)) {
  reportUniqueWarning(...);
  return;
}

[ayermolo]

llvm/tools/llvm-readobj/ELFDumper.cpp

1853–1860

Ah yeah, after I re-wrote printCGProfile yesterday evening, I see your point. The loop ended up being basically same as in printRelocatableStackSizes, except for checks. Will refactor it in to helper function. Also made it so that relocation section is optional. Will print warning if it's missing, but continue output weights. So some of the yaml tests can be cleaned up.

[ayermolo]

Incorporated feedback. Notable chagnes is refactor of printCGProfile to be more self contained, and support potential multiple call graph sections. printRelocatableStackSizes was chagned to use same helper function.

[ayermolo]

small description test fix

[ayermolo]

small fix

[ayermolo]

somehow missed a test.

[jhenderson]

llvm/lib/MC/MCELFStreamer.cpp

511

This hasn't been addressed properly: the = at the end of the comment in my inline edit is important, as clang-format interprets such a pattern differently (note that if you add the equals sign and then reformat, the space between the comment and 8 will disappear.

llvm/test/tools/llvm-readobj/ELF/call-graph-profile.test

130

161

211

llvm/test/tools/yaml2obj/ELF/call-graph-profile-section.yaml

83–84

I think you can drop this entire test case, since the YAML no longer refers to symbols for the call graph section.

102–103

Ditto: we no longer refer to symbols directly in the YAML for this section, so drop this case.

llvm/tools/llvm-readobj/ELFDumper.cpp

6732–6733

Get rid of the unnecessary "with relocations".

6740

The style is no capital for the first letter of warnings.

6745

6747

The return type of Rel.getSymbol(...) is already uint32_t, so no need for the trailing return type to be explicitly specified.

[ayermolo]

Addressed comments.

[ayermolo]

nit fixes

[ayermolo]

llvm/lib/MC/MCELFStreamer.cpp

511

ah, sorry missed the =.

llvm/tools/llvm-readobj/ELFDumper.cpp

6747

Also modified lambda in lld driver to follow the same style.

[jhenderson]

No more comments from me - I'm happy with the changes outside LLD, although haven't looked in depth at those within the LLD code. I also don't use the CG profile stuff or pretend to really follow it, so @MaskRay should sign off on that side of things.

[ayermolo]

In D104080#2832487, @jhenderson wrote:

No more comments from me - I'm happy with the changes outside LLD, although haven't looked in depth at those within the LLD code. I also don't use the CG profile stuff or pretend to really follow it, so @MaskRay should sign off on that side of things.

Thanks! @MaskRay any further feedback?

[MaskRay]

Mostly looks good.

lld/ELF/Driver.cpp

866–875

This can happen so assert is not appropriate. You can use if (...) fatal

llvm/include/llvm/MC/MCAsmBackend.h

88 ↗

(On Diff #353454)

Delete

llvm/lib/MC/MCELFStreamer.cpp

498

Is it expected for architectures that have _NONE to have the mapping? . .Case("BFD_RELOC_NONE", ELF::R_<arch>_NONE)

Yes. In GNU as, BFD_RELOC_NONE is generic and can be used on all targets. I have added BFD_RELOC_NONE to many LLVM targets. Note: .llvm.call-graph-profile is used by -fprofile-use=. The targets which don't support BFD_RELOC_NONE are not used by people for PGO. (If they do use PGO, adding the support should be trivial anyway.)

It probably makes sense to save the return value in a variable and assert it is None. I find that an unknown BFD_RELOC_NONE does not cause an error.

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

677 ↗

(On Diff #353454)

This function and its friends can all be deleted.

llvm/tools/llvm-readobj/ELFDumper.cpp

6752

I != Size is probably more common in LLVM code

[MaskRay]

You can mention that this does increase -fprofile-use= object file sizes a bit but probably don't matter.

For instrumentation PGO users, -fprofile-generate= object files are much larger than -fprofile-use=, so -fprofile-use= slightly size increases don't matter.
For sample PGO users, this may increase the peak object file sizes a bit, but doesn't matter as your measurement for clang-13 shows.

Test Plan:
ninja check all, manual rtesting

This should be deleted when committing.

The size went up from 107KB to 322KB, aggregate of all the input sections.

How large is your clang-13? ~100MiB? Then this increase looks neligible.

[ayermolo]

llvm/lib/MC/MCELFStreamer.cpp

498

ok, will remove getNoneRelcationName(), and use BFD_RELOC_NONE here. Thanks for the background.

[ayermolo]

addressign feedback

[ayermolo]

lld/ELF/Driver.cpp

866–875

What is general guideline for fatal vs assert in llvm? I looked at Coding Standard, and didn't see anything (might have missed it)

[ayermolo]

somehow random file made it in to diff, probably clang format related.

[MaskRay]

lld/ELF/Driver.cpp

866–875

My personal guideline is:

assert is for ensuring an invariant doesn't break - it shouldn't break even for malicious user input.

If you know some user input would crash, prefer a proper error reporting mechanism, in lld errorOrWarn/fatal/error. In LLVM internal code you can find many report_fatal_error(similar to assert, just with diagnostic even when assertions is disabled). Many are lazy examples which are not good references.

867

drop trailing period

Don't capitalize

[MaskRay]

LG baring the comment

[ayermolo]

Addressed last comment.

[jrtc27]

lld/ELF/InputFiles.cpp

681

What if it's SHT_REL? This won't fail nicely, it'll give an error about sh_entsize not matching. You should either handle SHT_REL properly (i.e. support it) or not even attempt to get an Elf_Rela for it.

[ayermolo]

Changed lld to handle call graph as RELA only, and emits warning for REL.

[ayermolo]

lld/ELF/InputFiles.cpp

681

Something like this?

[lebedev.ri]

Patch description is non-descriptive, does not provide any motivation as to why this is wanted e.g.

[jrtc27]

lld/ELF/InputFiles.cpp

681

Why not error?

[ayermolo]

lld/ELF/InputFiles.cpp

681

With error it will prevent binary from being linked. I thought warning would be more appropriate so that result will still be a valid binary minus this optimization. I can change to error if you and @MaskRay think that is more appropriate.

[ayermolo]

lld/ELF/InputFiles.cpp

681

With error it will prevent binary from being linked. I thought warning would be more appropriate so that result will still be a valid binary minus this optimization. I can change to error if you and @MaskRay think that is more appropriate.

readCallGraphsFromObjectFiles will also need to be modified, otherwise it will fatal there due to obj->cgProfileRela.size() != obj->cgProfile.size() * 2

[MaskRay]

lld/ELF/InputFiles.cpp

681

Why doesn't SHT_REL work?

A warning is appropriate, as it is an optional optimization anyway.

[MaskRay]

For example, if we run strip -s on the object files the symbol table changes, but indices in that section do not.

The description needs to mention what would happen with the old format.

We propose to change this section to use relocations. The Frequency will still be in the .llvm.call-graph-profile, but symbol information will be in relocation section. In LLD information from both sections is used to reconstruct call graph profile. Relocations themselves will never be applied.

We propose => This patch changes the format by using R_*_NONE relocations to indicate the from/to symbols.

With this approach post processing tools that handle relocations correctly work for this section also.

I think you might want to say adding/removing symbols?

[ayermolo]

lld/ELF/InputFiles.cpp

681

I didn't think SHT_REL is a common case/used. For X86 only I386 and IAMCU use REL, looking at some of the other architectures it's either ON by default or in case of MIPS enabled for 64 bit.

bool HasRelocationAddend = TT.isArch64Bit();
  return std::make_unique<MipsELFObjectWriter>(OSABI, HasRelocationAddend,
                                                IsN64);

I didn't want to over-complicate the implementation un-necessary, but might have been wrong about it. Should I add support?

[MaskRay]

lld/ELF/InputFiles.cpp

681

32-bit arm uses REL so it is not that uncommon. x86-32 does matter less these days and I don't know who want to use -fprofile-use for it. You can leave REL as-is. I can fix it afterwards.

The description needs to be fixed, though.

[ayermolo]

Modified readCallGraphsFromObjectFiles to continue if cgProfileRela is empty. In line with just printing warning if relocaiton is REL.

[ayermolo]

rebased on latest.

[wenlei]

@ayermolo is oof for a few days and asked me to commit this for him. I will do that shortly.

[echristo]

In D104080#2835108, @MaskRay wrote:

You can mention that this does increase -fprofile-use= object file sizes a bit but probably don't matter.

For instrumentation PGO users, -fprofile-generate= object files are much larger than -fprofile-use=, so -fprofile-use= slightly size increases don't matter.
For sample PGO users, this may increase the peak object file sizes a bit, but doesn't matter as your measurement for clang-13 shows.

Test Plan:
ninja check all, manual rtesting

This should be deleted when committing.

The size went up from 107KB to 322KB, aggregate of all the input sections.

How large is your clang-13? ~100MiB? Then this increase looks neligible.

I've noticed some increases in object size over here. What's the percentage increase you're expecting here in object file sizes?

[ayermolo]

In D104080#2883347, @echristo wrote:

In D104080#2835108, @MaskRay wrote:

You can mention that this does increase -fprofile-use= object file sizes a bit but probably don't matter.

For instrumentation PGO users, -fprofile-generate= object files are much larger than -fprofile-use=, so -fprofile-use= slightly size increases don't matter.
For sample PGO users, this may increase the peak object file sizes a bit, but doesn't matter as your measurement for clang-13 shows.

Test Plan:
ninja check all, manual rtesting

This should be deleted when committing.

The size went up from 107KB to 322KB, aggregate of all the input sections.

How large is your clang-13? ~100MiB? Then this increase looks neligible.

I've noticed some increases in object size over here. What's the percentage increase you're expecting here in object file sizes?

So original implementation was 16-bytes (2x4 bytes for index, 8 bytes for Weight). After this @MaskRay changed it to REL implementation. So that's 40 bytes (2x16 bytes for index in relocation form + 8 bytes for Weight).
When I measured with RELA approach on clang-13 it went from 107KB to 322KB in 118MB binary. With REL, current implementation, that's around 230KB out of 118MB. Now this is final binary size so proportion, in aggregate, of object files will be smaller.

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() {
+  auto getIndex = [&](ObjFile<ELFT> *obj, uint32_t index) {
+    const Elf_Rel_Impl<ELFT, true> &rel = obj->cgProfileRela[index];
+    return rel.getSymbol(config->isMips64EL);
+  };
+
   for (auto file : objectFiles) {
     auto *obj = cast<ObjFile<ELFT>>(file);
-
-    for (const Elf_CGProfile_Impl<ELFT> &cgpe : obj->cgProfile) {
-      auto *fromSym = dyn_cast<Defined>(&obj->getSymbol(cgpe.cgp_from));
-      auto *toSym = dyn_cast<Defined>(&obj->getSymbol(cgpe.cgp_to));
+    if (obj->cgProfileRela.empty())
+      continue;
+    if (obj->cgProfileRela.size() != obj->cgProfile.size() * 2)
+      fatal("number of relocations doesn't match Weights");
+    for (uint32_t i = 0, size = obj->cgProfile.size(); i < size; ++i) {
+      const Elf_CGProfile_Impl<ELFT> &cgpe = obj->cgProfile[i];
+      uint32_t fromIndex = getIndex(obj, i * 2);
+      uint32_t toIndex = getIndex(obj, i * 2 + 1);
+      auto *fromSym = dyn_cast<Defined>(&obj->getSymbol(fromIndex));
+      auto *toSym = dyn_cast<Defined>(&obj->getSymbol(toIndex));
       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)
         config->callGraphProfile[{from, to}] += cgpe.cgp_weight;
     }

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 (cgProfileSectionIndex && sec.sh_info == cgProfileSectionIndex) {
+      if (sec.sh_type == SHT_RELA)
+        cgProfileRela = CHECK(getObj().relas(sec), this);
+      else
+        warn(toString(this) + ": unsupported call graph section type");
+    }
+
     if (sec.sh_type == SHT_REL || sec.sh_type == SHT_RELA)
       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())
       linkSec = this->sections[sec.sh_link];

llvm/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
   // Experimental support for SHT_RELR sections. For details, see proposal
   // at https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
   SHT_RELR = 19,         // Relocation entries; only offsets.
   SHT_LOOS = 0x60000000, // Lowest operating system-specific type.
   // Android packed relocation section types.
   // https://android.googlesource.com/platform/bionic/+/6f12bfece5dcc01325e0abba56a46b1bcf991c69/tools/relocation_packer/src/elf_file.cc#37
   SHT_ANDROID_REL = 0x60000001,
   SHT_ANDROID_RELA = 0x60000002,
-  SHT_LLVM_ODRTAB = 0x6fff4c00,             // LLVM ODR table.
-  SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01,     // LLVM Linker Options.
-  SHT_LLVM_CALL_GRAPH_PROFILE = 0x6fff4c02, // LLVM Call Graph Profile.
-  SHT_LLVM_ADDRSIG = 0x6fff4c03, // List of address-significant symbols
+  SHT_LLVM_ODRTAB = 0x6fff4c00,         // LLVM ODR table.
+  SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01, // LLVM Linker Options.
+  SHT_LLVM_ADDRSIG = 0x6fff4c03,        // List of address-significant symbols
                                         // for safe ICF.
   SHT_LLVM_DEPENDENT_LIBRARIES =
       0x6fff4c04,                    // LLVM Dependent Library Specifiers.
   SHT_LLVM_SYMPART = 0x6fff4c05,     // Symbol partition specification.
   SHT_LLVM_PART_EHDR = 0x6fff4c06,   // ELF header for loadable partition.
   SHT_LLVM_PART_PHDR = 0x6fff4c07,   // Phdrs for loadable partition.
   SHT_LLVM_BB_ADDR_MAP = 0x6fff4c08, // LLVM Basic Block Address Map.
+  SHT_LLVM_CALL_GRAPH_PROFILE = 0x6fff4c09, // LLVM Call Graph Profile.
   // Android's experimental support for SHT_RELR sections.
   // https://android.googlesource.com/platform/bionic/+/b7feec74547f84559a1467aca02708ff61346d2a/libc/include/elf.h#512
   SHT_ANDROID_RELR = 0x6fffff00,   // Relocation entries; only offsets.
   SHT_GNU_ATTRIBUTES = 0x6ffffff5, // Object attributes.
   SHT_GNU_HASH = 0x6ffffff6,       // GNU-style hash table.
   SHT_GNU_verdef = 0x6ffffffd,     // GNU version definitions.
   SHT_GNU_verneed = 0x6ffffffe,    // GNU version references.
   SHT_GNU_versym = 0x6fffffff,     // GNU symbol versions table.

llvm/include/llvm/MC/MCELFStreamer.h

public:
   void emitBundleUnlock() override;
 
 private:
   bool isBundleLocked() const;
   void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
   void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
 
   void fixSymbolsInTLSFixups(const MCExpr *expr);
-  void finalizeCGProfileEntry(const MCSymbolRefExpr *&S);
+  void finalizeCGProfileEntry(const MCSymbolRefExpr *&S, uint64_t Offset);
   void finalizeCGProfile();
 
   /// Merge the content of the fragment \p EF into the fragment \p DF.
   void mergeFragment(MCDataFragment *, MCDataFragment *);
 
   bool SeenIdent = false;
 
   /// BundleGroups - The stack of fragments holding the bundle-locked

llvm/include/llvm/Object/ELFTypes.h

public:
   Elf_Note_Impl<ELFT> operator*() const {
     assert(Nhdr && "dereferenced ELF note end iterator");
     return Elf_Note_Impl<ELFT>(*Nhdr);
   }
 };
 
 template <class ELFT> struct Elf_CGProfile_Impl {
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
-  Elf_Word cgp_from;
-  Elf_Word cgp_to;
   Elf_Xword cgp_weight;
 };
 
 // MIPS .reginfo section
 template <class ELFT>
 struct Elf_Mips_RegInfo;
 
 template <support::endianness TargetEndianness>

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct DependentLibrariesSection : Section {
   };
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::DependentLibraries;
   }
 };
 
 // Represents the call graph profile section entry.
-struct CallGraphEntry {
-  // The symbol of the source of the edge.
-  StringRef From;
-  // The symbol index of the destination of the edge.
-  StringRef To;
+struct CallGraphEntryWeight {
   // The weight of the edge.
   uint64_t Weight;
 };
 
 struct CallGraphProfileSection : Section {
-  Optional<std::vector<CallGraphEntry>> Entries;
+  Optional<std::vector<CallGraphEntryWeight>> Entries;
 
   CallGraphProfileSection() : Section(ChunkKind::CallGraphProfile) {}
 
   std::vector<std::pair<StringRef, bool>> getEntries() const override {
     return {{"Entries", Entries.hasValue()}};
   };
 
   static bool classof(const Chunk *S) {

 } // end namespace ELFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry::BBEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::LinkerOption)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntryWeight)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)

 template <> struct MappingTraits<ELFYAML::VernauxEntry> {
   static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
 };
 
 template <> struct MappingTraits<ELFYAML::LinkerOption> {
   static void mapping(IO &IO, ELFYAML::LinkerOption &Sym);
 };
 
-template <> struct MappingTraits<ELFYAML::CallGraphEntry> {
-  static void mapping(IO &IO, ELFYAML::CallGraphEntry &E);
+template <> struct MappingTraits<ELFYAML::CallGraphEntryWeight> {
+  static void mapping(IO &IO, ELFYAML::CallGraphEntryWeight &E);
 };
 
 template <> struct MappingTraits<ELFYAML::Relocation> {
   static void mapping(IO &IO, ELFYAML::Relocation &Rel);
 };
 
 template <> struct MappingTraits<ELFYAML::ARMIndexTableEntry> {
   static void mapping(IO &IO, ELFYAML::ARMIndexTableEntry &E);

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

void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
   }
 
   case MCExpr::Unary:
     fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
     break;
   }
 }
 
-void MCELFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) {
+void MCELFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE,
+                                           uint64_t Offset) {
   const MCSymbol *S = &SRE->getSymbol();
   if (S->isTemporary()) {
     if (!S->isInSection()) {
       getContext().reportError(
           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;
+    SRE = MCSymbolRefExpr::create(S, MCSymbolRefExpr::VK_None, getContext(),
+                                  SRE->getLoc());
   }
-  // Not a temporary, referece it as a weak undefined.
-  bool Created;
-  getAssembler().registerSymbol(*S, &Created);
-  if (Created)
-    cast<MCSymbolELF>(S)->setBinding(ELF::STB_WEAK);
+  const MCConstantExpr *MCOffset = MCConstantExpr::create(Offset, getContext());
+  MCObjectStreamer::visitUsedExpr(*SRE);
+  if (Optional<std::pair<bool, std::string>> Err =
+          MCObjectStreamer::emitRelocDirective(
+              *MCOffset, "BFD_RELOC_NONE", SRE, SRE->getLoc(),
+              *getContext().getSubtargetInfo()))
+    report_fatal_error("Relocation for CG Profile could not be created: " +
+                       Err->second);
 }
 
 void MCELFStreamer::finalizeCGProfile() {
-  for (MCAssembler::CGProfileEntry &E : getAssembler().CGProfile) {
-    finalizeCGProfileEntry(E.From);
-    finalizeCGProfileEntry(E.To);
+  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, /*sizeof(Elf_CGProfile_Impl<>)=*/8);
+  PushSection();
+  SwitchSection(CGProfile);
+  uint64_t Offset = 0;
+  for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
+    finalizeCGProfileEntry(E.From, Offset++);
+    finalizeCGProfileEntry(E.To, Offset++);
+    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/lib/ObjectYAML/ELFEmitter.cpp

 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ELFTypes.h"
 #include "llvm/ObjectYAML/DWARFEmitter.h"
 #include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/LEB128.h"

 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::CallGraphProfileSection &Section,
     ContiguousBlobAccumulator &CBA) {
   if (!Section.Entries)
     return;
 
-  for (const ELFYAML::CallGraphEntry &E : *Section.Entries) {
-    unsigned From = toSymbolIndex(E.From, Section.Name, /*IsDynamic=*/false);
-    unsigned To = toSymbolIndex(E.To, Section.Name, /*IsDynamic=*/false);
-
-    CBA.write<uint32_t>(From, ELFT::TargetEndianness);
-    CBA.write<uint32_t>(To, ELFT::TargetEndianness);
+  for (const ELFYAML::CallGraphEntryWeight &E : *Section.Entries) {
     CBA.write<uint64_t>(E.Weight, ELFT::TargetEndianness);
-    SHeader.sh_size += 16;
+    SHeader.sh_size += sizeof(object::Elf_CGProfile_Impl<ELFT>);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::HashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   if (!Section.Bucket)

llvm/lib/ObjectYAML/ELFYAML.cpp

 
 void MappingTraits<ELFYAML::LinkerOption>::mapping(IO &IO,
                                                    ELFYAML::LinkerOption &Opt) {
   assert(IO.getContext() && "The IO context is not initialized");
   IO.mapRequired("Name", Opt.Key);
   IO.mapRequired("Value", Opt.Value);
 }
 
-void MappingTraits<ELFYAML::CallGraphEntry>::mapping(
-    IO &IO, ELFYAML::CallGraphEntry &E) {
+void MappingTraits<ELFYAML::CallGraphEntryWeight>::mapping(
+    IO &IO, ELFYAML::CallGraphEntryWeight &E) {
   assert(IO.getContext() && "The IO context is not initialized");
-  IO.mapRequired("From", E.From);
-  IO.mapRequired("To", E.To);
   IO.mapRequired("Weight", E.Weight);
 }
 
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
 
 } // end namespace yaml
 
 } // end namespace llvm

llvm/test/MC/ELF/cgprofile.s

a: .word b
 
   .globl late
 late:
 late2: .word 0
 late3:
 .L.local:
 
 # CHECK:      Name: .llvm.call-graph-profile
-# CHECK-NEXT: Type: SHT_LLVM_CALL_GRAPH_PROFILE (0x6FFF4C02)
+# CHECK-NEXT: Type: SHT_LLVM_CALL_GRAPH_PROFILE (0x6FFF4C09)
 # 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: Size: 32
+# CHECK-NEXT: Link: 7
 # CHECK-NEXT: Info: 0
 # CHECK-NEXT: AddressAlignment: 1
-# CHECK-NEXT: EntrySize: 16
+# CHECK-NEXT: EntrySize: 8
 # 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: 20000000 00000000 0B000000 00000000
+# CHECK-NEXT:   0010: 14000000 00000000 2A000000 00000000
+# CHECK-NEXT: )
+
+# CHECK:      Name: .rela.llvm.call-graph-profile (28)
+# CHECK-NEXT: Type: SHT_RELA (0x4)
+# CHECK-NEXT: Flags [ (0x0)
+# CHECK-NEXT: ]
+# CHECK-NEXT: Address: 0x0
+# CHECK-NEXT: Offset: 0x140
+# CHECK-NEXT: Size: 192
+# CHECK-NEXT: Link: 7
+# CHECK-NEXT: Info: 5
+# CHECK-NEXT: AddressAlignment: 8
+# CHECK-NEXT: EntrySize: 24
+# CHECK-NEXT: SectionData (
+# CHECK-NEXT:   0000: 00000000 00000000 00000000 02000000
+# CHECK-NEXT:   0010: 00000000 00000000 01000000 00000000
+# CHECK-NEXT:   0020: 00000000 05000000 00000000 00000000
+# CHECK-NEXT:   0030: 02000000 00000000 00000000 07000000
+# CHECK-NEXT:   0040: 00000000 00000000 03000000 00000000
+# CHECK-NEXT:   0050: 00000000 02000000 00000000 00000000
+# CHECK-NEXT:   0060: 04000000 00000000 00000000 06000000
+# CHECK-NEXT:   0070: 00000000 00000000 05000000 00000000
+# CHECK-NEXT:   0080: 00000000 03000000 00000000 00000000
+# CHECK-NEXT:   0090: 06000000 00000000 00000000 01000000
+# CHECK-NEXT:   00A0: 00000000 00000000 07000000 00000000
+# CHECK-NEXT:   00B0: 00000000 05000000 00000000 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/test/Object/multiple-sections.yaml

 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -a --cg-profile --addrsig %t.o | FileCheck %s
 
 # Test that multiple sections with the same type does not trigger an error.
 
 # CHECK: ElfHeader {
 # CHECK: VersionSymbols [
 # CHECK: VersionDefinitions [
 # CHECK: VersionRequirements [
 # CHECK: CGProfile [
+# CHECK: CGProfile [
 # CHECK: Addrsig [
 
 --- !ELF
-FileHeader:      
+FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
-Sections:        
+Sections:
   - Name:            .symtab2
     Type:            SHT_SYMTAB
     Link:            .strtab
     Content:         ''
     EntSize:         24
   - Name:            .versym
     Type:            SHT_GNU_versym
     Entries:         [ 0 ]
- Name:            .verneed
     Dependencies:
   - Name:            .verneed2
     Type:            SHT_GNU_verneed
     Info:            0x0000000000000000
     Dependencies:
   - Name:            .llvm.call-graph-profile
     Type:            SHT_LLVM_CALL_GRAPH_PROFILE
     Content:         ''
-    EntSize:         16
+    EntSize:         8
   - Name:            .llvm.call-graph-profile2
     Type:            SHT_LLVM_CALL_GRAPH_PROFILE
     Content:         ''
-    EntSize:         16
+    EntSize:         8
   - Name:            .llvm_addrsig
     Type:            SHT_LLVM_ADDRSIG
     Content:         ''
   - Name:            .llvm_addrsig2
     Type:            SHT_LLVM_ADDRSIG
     Content:         ''
-Symbols:         
+Symbols:
   - Name:            f
 DynamicSymbols: []
 ...

llvm/test/tools/llvm-readobj/ELF/call-graph-profile.test

 
 # GNU: GNUStyle::printCGProfile not implemented
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
+  Machine: EM_X86_64
 Sections:
   - Name: .llvm.call-graph-profile
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Entries:
-      - From:   foo
-        To:     bar
-        Weight: 89
-      - From:   bar
-        To:     foo
-        Weight: 98
+      - Weight: 89
+      - Weight: 98
     EntSize: [[ENTSIZE=<none>]]
+  - Name: .rela.llvm.call-graph-profile
+    Type: SHT_RELA
+    Info: .llvm.call-graph-profile
+    Relocations:
+      - Symbol: foo
+        Type:   R_X86_64_NONE
+      - Offset: 0x1
+        Symbol: bar
+        Type:   R_X86_64_NONE
+      - Offset: 0x2
+        Symbol: bar
+        Type:   R_X86_64_NONE
+      - Offset: 0x3
+        Symbol: foo
+        Type:   R_X86_64_NONE
 Symbols:
   - Name: foo
   - Name: bar
 
 ## Check we report a warning when unable to get the content of the SHT_LLVM_CALL_GRAPH_PROFILE section.
 # RUN: yaml2obj %s -DENTSIZE=0xF -o %t2.o
 # RUN: llvm-readobj %t2.o --cg-profile 2>&1 | FileCheck %s -DFILE=%t2.o --check-prefix=LLVM-ERR
 # RUN: llvm-readelf %t2.o --cg-profile | FileCheck %s --check-prefix=GNU
 
-# LLVM-ERR:      CGProfile [
-# LLVM-ERR-NEXT: warning: '[[FILE]]': unable to dump the SHT_LLVM_CALL_GRAPH_PROFILE section: section [index 1] has invalid sh_entsize: expected 16, but got 15
-# LLVM-ERR-NEXT: ]
+# LLVM-ERR: warning: '[[FILE]]': unable to load the SHT_LLVM_CALL_GRAPH_PROFILE section: section [index 1] has invalid sh_entsize: expected 8, but got 15
 
 ## Check we report a warning when unable to dump a name of a symbol.
 # RUN: yaml2obj %s --docnum=2 -o %t3.o
 # RUN: llvm-readobj %t3.o --cg-profile 2>&1 | FileCheck %s -DFILE=%t3.o --check-prefix=LLVM-BROKEN-SYM
 # RUN: llvm-readelf %t3.o --cg-profile | FileCheck %s --check-prefix=GNU
 
 # LLVM-BROKEN-SYM:      CGProfile [
 # LLVM-BROKEN-SYM-NEXT:   CGProfileEntry {
 # LLVM-BROKEN-SYM-NEXT:     From: A (1)
 # LLVM-BROKEN-SYM-NEXT: warning: '[[FILE]]': unable to read the name of symbol with index 2: st_name (0xff) is past the end of the string table of size 0x5
 # LLVM-BROKEN-SYM-NEXT:     To: <?> (2)
 # LLVM-BROKEN-SYM-NEXT:     Weight: 10
 # LLVM-BROKEN-SYM-NEXT:   }
 # LLVM-BROKEN-SYM-NEXT:   CGProfileEntry {
 # LLVM-BROKEN-SYM-NEXT:     From: <?> (2)
 # LLVM-BROKEN-SYM-NEXT:     To: B (3)
 # LLVM-BROKEN-SYM-NEXT:     Weight: 20
 # LLVM-BROKEN-SYM-NEXT:   }
 # LLVM-BROKEN-SYM-NEXT:   CGProfileEntry {
 # LLVM-BROKEN-SYM-NEXT:     From: (0)
-# LLVM-BROKEN-SYM-NEXT: warning: '[[FILE]]': unable to read the name of symbol with index 4: unable to get symbol from section [index 3]: invalid symbol index (4)
+# LLVM-BROKEN-SYM-NEXT: warning: '[[FILE]]': unable to read the name of symbol with index 4: unable to get symbol from section [index 4]: invalid symbol index (4)
 # LLVM-BROKEN-SYM-NEXT:     To: <?> (4)
 # LLVM-BROKEN-SYM-NEXT:     Weight: 20
 # LLVM-BROKEN-SYM-NEXT:   }
 # LLVM-BROKEN-SYM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
+  Machine: EM_X86_64
 Sections:
   - Name: .llvm.call-graph-profile
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Entries:
-      - From:   1
-        To:     2
-        Weight: 10
-      - From:   2
-        To:     3
-        Weight: 20
-      - From:   0x0 ## Null symbol.
-        To:     0x4 ## This index goes past the end of the symbol table.
-        Weight: 20
+      - Weight: 10
+      - Weight: 20
+      - Weight: 20
+  - Name: .rela.llvm.call-graph-profile
+    Type: SHT_RELA
+    Info: .llvm.call-graph-profile
+    Relocations:
+      - Symbol: 1
+        Type:   R_X86_64_NONE
+      - Offset: 0x1
+        Symbol: 2
+        Type:   R_X86_64_NONE
+      - Offset: 0x2
+        Symbol: 2
+        Type:   R_X86_64_NONE
+      - Offset: 0x3
+        Symbol: 3
+        Type:   R_X86_64_NONE
+      - Offset: 0x4
+        Symbol: 0x0 ## Null symbol.
+        Type:   R_X86_64_NONE
+      - Offset: 0x5
+        Symbol: 0x4 ## This index goes past the end of the symbol table.
+        Type:   R_X86_64_NONE
   - Name:    .strtab
     Type:    SHT_STRTAB
     Content: "0041004200" ## '\0', 'A', '\0', 'B', '\0'
 Symbols:
   - StName: 1    ## 'A'
   - StName: 0xFF ## An arbitrary currupted index in the string table.
   - StName: 3    ## 'B'
+
+## Check we report a warning when a relocation section is not present.
+# RUN: yaml2obj %s --docnum=3 -o %t4.o
+# RUN: llvm-readobj %t4.o --cg-profile 2>&1 | FileCheck %s -DFILE=%t4.o --check-prefix=LLVM-NO-RELOC
+# RUN: llvm-readobj %t4.o --elf-cg-profile 2>&1 | FileCheck %s -DFILE=%t4.o --check-prefix=LLVM-NO-RELOC
+
+# LLVM-NO-RELOC:      warning: '[[FILE]]': relocation section for a call graph section doesn't exist
+# LLVM-NO-RELOC-NEXT: CGProfile [
+# LLVM-NO-RELOC-NEXT:  CGProfileEntry {
+# LLVM-NO-RELOC-NEXT:    Weight: 89
+# LLVM-NO-RELOC-NEXT:  }
+# LLVM-NO-RELOC-NEXT:  CGProfileEntry {
+# LLVM-NO-RELOC-NEXT:    Weight: 98
+# LLVM-NO-RELOC-NEXT:  }
+# LLVM-NO-RELOC-NEXT: ]
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name: .llvm.call-graph-profile
+    Type: SHT_LLVM_CALL_GRAPH_PROFILE
+    Entries:
+      - Weight: 89
+      - Weight: 98
+    EntSize: [[ENTSIZE=<none>]]
+Symbols:
+  - Name: foo
+  - Name: bar
+
+## Check we report a warning when the number of relocation section entries does not match the number of call graph entries.
+# RUN: yaml2obj %s --docnum=4 -o %t5.o
+# RUN: llvm-readobj %t5.o --cg-profile 2>&1 | FileCheck %s -DFILE=%t5.o --check-prefix=LLVM-RELOC-GRAPH-NOT-MATCH
+# RUN: llvm-readobj %t5.o --elf-cg-profile 2>&1 | FileCheck %s -DFILE=%t5.o --check-prefix=LLVM-RELOC-GRAPH-NOT-MATCH
+
+# LLVM-RELOC-GRAPH-NOT-MATCH:      warning: '[[FILE]]': number of from/to pairs does not match number of frequencies
+# LLVM-RELOC-GRAPH-NOT-MATCH-NEXT: CGProfile [
+# LLVM-RELOC-GRAPH-NOT-MATCH-NEXT:  CGProfileEntry {
+# LLVM-RELOC-GRAPH-NOT-MATCH-NEXT:    Weight: 89
+# LLVM-RELOC-GRAPH-NOT-MATCH-NEXT:  }
+# LLVM-RELOC-GRAPH-NOT-MATCH-NEXT:  CGProfileEntry {
+# LLVM-RELOC-GRAPH-NOT-MATCH-NEXT:    Weight: 98
+# LLVM-RELOC-GRAPH-NOT-MATCH-NEXT:  }
+# LLVM-RELOC-GRAPH-NOT-MATCH-NEXT: ]
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .llvm.call-graph-profile
+    Type: SHT_LLVM_CALL_GRAPH_PROFILE
+    Entries:
+      - Weight: 89
+      - Weight: 98
+    EntSize: [[ENTSIZE=<none>]]
+  - Name: .rela.llvm.call-graph-profile
+    Type: SHT_RELA
+    Info: .llvm.call-graph-profile
+    Relocations:
+      - Symbol: foo
+        Type:   R_X86_64_NONE
+      - Offset: 0x1
+        Symbol: bar
+        Type:   R_X86_64_NONE
+      - Offset: 0x2
+        Symbol: bar
+        Type:   R_X86_64_NONE
+      - Offset: 0x3
+        Symbol: foo
+        Type:   R_X86_64_NONE
+      - Offset: 0x4
+        Symbol: foo
+        Type:   R_X86_64_NONE
+Symbols:
+  - Name: foo
+  - Name: bar
+
+## Check we report a warning when a relocation section cant't be loaded.
+# RUN: yaml2obj %s --docnum=5 -o %t6.o
+# RUN: llvm-readobj %t6.o --cg-profile 2>&1 | FileCheck %s -DFILE=%t6.o --check-prefix=LLVM-RELOC-WRONG-SIZE
+# RUN: llvm-readobj %t6.o --elf-cg-profile 2>&1 | FileCheck %s -DFILE=%t6.o --check-prefix=LLVM-RELOC-WRONG-SIZE
+
+# LLVM-RELOC-WRONG-SIZE:      warning: '[[FILE]]': unable to load relocations for SHT_LLVM_CALL_GRAPH_PROFILE section: section [index 2] has invalid sh_entsize: expected 24, but got 32
+# LLVM-RELOC-WRONG-SIZE-NEXT: CGProfile [
+# LLVM-RELOC-WRONG-SIZE-NEXT:  CGProfileEntry {
+# LLVM-RELOC-WRONG-SIZE-NEXT:    Weight: 89
+# LLVM-RELOC-WRONG-SIZE-NEXT:  }
+# LLVM-RELOC-WRONG-SIZE-NEXT:  CGProfileEntry {
+# LLVM-RELOC-WRONG-SIZE-NEXT:    Weight: 98
+# LLVM-RELOC-WRONG-SIZE-NEXT:  }
+# LLVM-RELOC-WRONG-SIZE-NEXT: ]
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .llvm.call-graph-profile
+    Type: SHT_LLVM_CALL_GRAPH_PROFILE
+    Entries:
+      - Weight: 89
+      - Weight: 98
+    EntSize: [[ENTSIZE=<none>]]
+  - Name: .rela.llvm.call-graph-profile
+    Type: SHT_RELA
+    Info: .llvm.call-graph-profile
+    Relocations:
+      - Symbol: foo
+        Type:   R_X86_64_NONE
+      - Offset: 0x1
+        Symbol: bar
+        Type:   R_X86_64_NONE
+      - Offset: 0x2
+        Symbol: bar
+        Type:   R_X86_64_NONE
+      - Offset: 0x3
+        Symbol: foo
+        Type:   R_X86_64_NONE
+    EntSize: 32
+Symbols:
+  - Name: foo
+  - Name: bar

llvm/test/tools/llvm-readobj/ELF/demangle.test

- Name: .rela.text.foo
     Info: .text.foo
     Relocations:
       - Offset: 0x10
         Symbol: _Z3fooc
         Type:   R_X86_64_PC32
   - Name: .llvm.call-graph-profile
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Link: .symtab
-    EntSize: 16
-    Content: "01000000020000002000000000000000"
+    EntSize: 8
+    Content: "2000000000000000"
+  - Name: .rela.llvm.call-graph-profile
+    Type: SHT_RELA
+    Info: .llvm.call-graph-profile
+    Relocations:
+      - Symbol: 1
+        Type:   R_X86_64_NONE
+      - Offset: 0x1
+        Symbol: 2
+        Type:   R_X86_64_NONE
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Link: .symtab
     Content: "0102"
 Symbols:
   - Name:    _Z3fooc
     Type:    STT_FUNC
     Section: .text.foo

llvm/test/tools/obj2yaml/ELF/call-graph-profile-section.yaml

 # RUN: yaml2obj -D BITS=32 -D ENCODE=MSB %s -o %t.be32
 # RUN: obj2yaml %t.be32 | FileCheck %s --check-prefix=BASIC
 
 # BASIC:      Sections:
 # BASIC-NEXT:   - Name: .llvm.call-graph-profile
 # BASIC-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # BASIC-NEXT:     Link: .symtab
 # BASIC-NEXT:     Entries:
-# BASIC-NEXT:       - From:   foo
-# BASIC-NEXT:         To:     bar
-# BASIC-NEXT:         Weight: 89
-# BASIC-NEXT:       - From:   bar
-# BASIC-NEXT:         To:     foo
-# BASIC-NEXT:         Weight: 98
+# BASIC-NEXT:       - Weight: 89
+# BASIC-NEXT:       - Weight: 98
 # BASIC-NEXT: Symbols:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2[[ENCODE]]
   Type:  ET_DYN
 Sections:
   - Name: .llvm.call-graph-profile
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Entries:
-      - From:   1
-        To:     2
-        Weight: 89
-      - From:   2
-        To:     1
-        Weight: 98
+      - Weight: 89
+      - Weight: 98
 Symbols:
   - Name: foo
   - Name: bar
 
 ## Check how we handle broken cases.
 
 # RUN: yaml2obj --docnum=2 %s -o %t.invalid
 # RUN: obj2yaml %t.invalid | FileCheck %s --check-prefix=INVALID
 
 # INVALID:      --- !ELF
 # INVALID-NEXT: FileHeader:
 # INVALID-NEXT:   Class: ELFCLASS32
 # INVALID-NEXT:   Data:  ELFDATA2MSB
 # INVALID-NEXT:   Type:  ET_DYN
 # INVALID-NEXT: Sections:
 # INVALID-NEXT:   - Name: .empty
 # INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link: .symtab
-# INVALID-NEXT:   - Name: .multiple.16.valid
+# INVALID-NEXT:   - Name: .multiple.8.valid
 # INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     Entries:
-# INVALID-NEXT:       - From:   foo
-# INVALID-NEXT:         To:     bar
 # INVALID-NEXT:         Weight: 3
-# INVALID-NEXT:   - Name: .non.multiple.16
+# INVALID-NEXT:   - Name: .non.multiple.8
 # INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link: .symtab
-# INVALID-NEXT:     Content: '0000000100000002000000000000000300'
-# INVALID-NEXT:   - Name: .multiple.16.invalid
+# INVALID-NEXT:     Content: '000000000000000300'
+# INVALID-NEXT:   - Name: .multiple.8.invalid
 # INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link: .symtab
-# INVALID-NEXT:     Content: 00112233445566778899AABBCCDDEEFF
-# INVALID-NEXT:   - Name: .unknown.symbol.1
-# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link: .symtab
-# INVALID-NEXT:     Content: 000000FF000000020000000000000003
-# INVALID-NEXT:   - Name: .unknown.symbol.2
-# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link: .symtab
-# INVALID-NEXT:     Content: 00000001000000FF0000000000000003
+# INVALID-NEXT:     Content: 008899AABBCCDDEEFF
 # INVALID-NEXT:   - Name: .link.to.symtable
 # INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     Entries:
-# INVALID-NEXT:       - From:   foo
-# INVALID-NEXT:         To:     bar
-# INVALID-NEXT:         Weight: 0
+# INVALID-NEXT:       - Weight: 0
 # INVALID-NEXT:   - Name: .link.to.non.symtable.1
 # INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Content: '00000001000000020000000000000000'
+# INVALID-NEXT:     Entries:
+# INVALID-NEXT:           - Weight: 0
 # INVALID-NEXT:   - Name: .link.to.non.symtable.2
 # INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link: .empty
-# INVALID-NEXT:     Content: '00000001000000020000000000000000'
+# INVALID-NEXT:     Entries:
+# INVALID-NEXT:      - Weight: 0
 # INVALID-NEXT:   - Name:    .zero.entry.size
 # INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link:    .symtab
 # INVALID-NEXT:     EntSize: 0x0
 # INVALID-NEXT:     Entries:
-# INVALID-NEXT:       - From:   foo
-# INVALID-NEXT:         To:     bar
-# INVALID-NEXT:         Weight: 0
+# INVALID-NEXT:       - Weight: 0
 # INVALID-NEXT:   - Name: .invalid.entry.size
 # INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     EntSize: 0x1
 # INVALID-NEXT:     Entries:
-# INVALID-NEXT:       - From:   foo
-# INVALID-NEXT:         To:     bar
-# INVALID-NEXT:         Weight: 0
+# INVALID-NEXT:       - Weight: 0
 # INVALID-NEXT: Symbols:
 # INVALID-NEXT:   - Name: foo
 # INVALID-NEXT:   - Name: bar
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2MSB
   Type:  ET_DYN
 Sections:
 ## Case 1: Content is empty.
   - Name: .empty
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 ## Case 2: Check that we use the "Entries" property to dump the data when it
 ##         has a size that is a multiple of 16 and is valid (it is possible to match
 ##         symbol indexes to symbols), but fallback to dumping the whole section
 ##         using the "Content" property otherwise.
 ## TODO: Teach yaml2obj to accept 'Size' key for SHT_LLVM_CALL_GRAPH_PROFILE
 ##       sections and use Entries for cases below.
-  - Name: .multiple.16.valid
-    Type: SHT_LLVM_CALL_GRAPH_PROFILE
-    Content: "00000001000000020000000000000003"
-  - Name: .non.multiple.16
+  - Name: .multiple.8.valid
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
-    Content: "0000000100000002000000000000000300"
-  - Name: .multiple.16.invalid
+    Content: "0000000000000003"
+  - Name: .non.multiple.8
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
-    Content: "00112233445566778899AABBCCDDEEFF"
-## Case 3: Check we use the "Content" property when unable to match a
-##         symbol index to a symbol.
-  - Name: .unknown.symbol.1
+    Content: "000000000000000300"
+  - Name: .multiple.8.invalid
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
-    Entries:
-      - From:   0xff
-        To:     2
-        Weight: 3
-  - Name: .unknown.symbol.2
-    Type: SHT_LLVM_CALL_GRAPH_PROFILE
-    Entries:
-      - From:   1
-        To:     0xff
-        Weight: 3
+    Content: "008899AABBCCDDEEFF"
 ## Case 4: Check we use the "Content" property when a linked section
 ##         is not a symbol table.
   - Name: .link.to.symtable
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Entries:
-      - From:   1
-        To:     2
-        Weight: 0
+      - Weight: 0
   - Name: .link.to.non.symtable.1
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Link: 0
     Entries:
-      - From:   1
-        To:     2
-        Weight: 0
+      - Weight: 0
   - Name: .link.to.non.symtable.2
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Link: 1
     Entries:
-      - From:   1
-        To:     2
-        Weight: 0
+      - Weight: 0
 ## Case 5: Check we can dump a section that has a sh_entsize that is not a multiple of 16.
 ##         Check that in these cases we print the "EntSize" key.
   - Name: .zero.entry.size
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     EntSize: 0
     Entries:
-      - From:   1
-        To:     2
-        Weight: 0
+      - Weight: 0
   - Name: .invalid.entry.size
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     EntSize: 1
     Entries:
-      - From:   1
-        To:     2
-        Weight: 0
+      - Weight: 0
 Symbols:
   - Name: foo
   - Name: bar

llvm/test/tools/yaml2obj/ELF/call-graph-profile-section.yaml

 ## Test how we create SHT_LLVM_CALL_GRAPH_PROFILE sections.
 
 ## Test that the content of SHT_LLVM_CALL_GRAPH_PROFILE sections
 ## for 32/64-bit little/big endian targets is correct.
 # RUN: yaml2obj --docnum=1 -D BITS=64 -D ENCODE=LSB %s -o %t.le64
 # RUN: llvm-readobj --cg-profile --sections --section-data %t.le64 | FileCheck %s --check-prefixes=BASIC,BASIC-LE
-# RUN: yaml2obj --docnum=1 -D BITS=64 -D ENCODE=MSB %s -o %t.be64                      
+# RUN: yaml2obj --docnum=1 -D BITS=64 -D ENCODE=MSB %s -o %t.be64
 # RUN: llvm-readobj --cg-profile --sections --section-data %t.be64 | FileCheck %s --check-prefixes=BASIC,BASIC-BE
-# RUN: yaml2obj --docnum=1 -D BITS=32 -D ENCODE=LSB %s -o %t.le32                      
+# RUN: yaml2obj --docnum=1 -D BITS=32 -D ENCODE=LSB %s -o %t.le32
 # RUN: llvm-readobj --cg-profile --sections --section-data %t.le32 | FileCheck %s --check-prefixes=BASIC,BASIC-LE
-# RUN: yaml2obj --docnum=1 -D BITS=32 -D ENCODE=MSB %s -o %t.be32                      
+# RUN: yaml2obj --docnum=1 -D BITS=32 -D ENCODE=MSB %s -o %t.be32
 # RUN: llvm-readobj --cg-profile --sections --section-data %t.be32 | FileCheck %s --check-prefixes=BASIC,BASIC-BE
 
 # BASIC:        Name: .llvm.call-graph-profile
 # BASIC-NEXT:   Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # BASIC-NEXT:   Flags [
 # BASIC-NEXT:   ]
 # BASIC-NEXT:   Address: 0x0
 # BASIC-NEXT:   Offset:
-# BASIC-NEXT:   Size: 32
+# BASIC-NEXT:   Size: 16
 ## Check that we link SHT_LLVM_CALL_GRAPH_PROFILE section with .symtab by default.
 # BASIC-NEXT:   Link: [[SYMTABNDX:.*]]
 # BASIC-NEXT:   Info: 0
 # BASIC-NEXT:   AddressAlignment: 0
 ## Check that the entry size is set to 16 by default.
-# BASIC-NEXT:   EntrySize: 16
+# BASIC-NEXT:   EntrySize: 8
 # BASIC-NEXT:   SectionData (
-# BASIC-LE-NEXT:  0000: 01000000 02000000 59000000 00000000
-# BASIC-LE-NEXT:  0010: 02000000 01000000 62000000 00000000
-# BASIC-BE-NEXT:  0000: 00000001 00000002 00000000 00000059
-# BASIC-BE-NEXT:  0010: 00000002 00000001 00000000 00000062
+# BASIC-LE-NEXT:  0000: 59000000 00000000 62000000 00000000
+# BASIC-BE-NEXT:  0000: 00000000 00000059 00000000 00000062
 # BASIC-NEXT:   )
 # BASIC-NEXT: }
 # BASIC-NEXT: Section {
-# BASIC-NEXT:   Index: [[SYMTABNDX]]
-# BASIC-NEXT:   Name: .symtab
+# BASIC-NEXT:  Index: [[SYMTABNDX]]
+# BASIC-NEXT:  Name: .symtab
 
 # BASIC:      CGProfile [
 # BASIC-NEXT:   CGProfileEntry {
-# BASIC-NEXT:     From: foo (1)
-# BASIC-NEXT:     To: bar (2)
 # BASIC-NEXT:     Weight: 89
 # BASIC-NEXT:   }
 # BASIC-NEXT:   CGProfileEntry {
-# BASIC-NEXT:     From: bar (2)
-# BASIC-NEXT:     To: foo (1)
 # BASIC-NEXT:     Weight: 98
 # BASIC-NEXT:   }
 # BASIC-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2[[ENCODE]]
   Type:  ET_DYN
 Sections:
   - Name: .llvm.call-graph-profile
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Entries:
-      - From:   1
-        To:     2
-        Weight: 89
-      - From:   2
-        To:     1
-        Weight: 98
+      - Weight: 89
+      - Weight: 98
 Symbols:
   - Name: foo
   - Name: bar
 
 ## Check we can set arbitrary sh_link and sh_entsize values.
 ## Check we can specify none of "Content", "Entries", and "Size" tags.
 # RUN: yaml2obj --docnum=2 %s -o %t.link
 # RUN: llvm-readelf --sections %t.link | FileCheck %s --check-prefix=LINK
Sections:
   - Name:    .llvm.foo
     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
     Link:    0x0
     EntSize: 0
   - Name:    .llvm.bar
     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
     Link:    0xFF
     EntSize: 0xFF
 
-## Check we can refer to symbols by name.
-# RUN: yaml2obj --docnum=3 %s -o %t.sym
-# RUN: llvm-readobj --cg-profile %t.sym | FileCheck %s --check-prefix=SYMBOL-NAMES
-
-# SYMBOL-NAMES:      CGProfile [
-# SYMBOL-NAMES-NEXT:   CGProfileEntry {
-# SYMBOL-NAMES-NEXT:     From: foo (1)
-# SYMBOL-NAMES-NEXT:     To: bar (2)
-# SYMBOL-NAMES-NEXT:     Weight: 10
-# SYMBOL-NAMES-NEXT:   }
-# SYMBOL-NAMES-NEXT:   CGProfileEntry {
-# SYMBOL-NAMES-NEXT:     From: foo (1)
-# SYMBOL-NAMES-NEXT:     To: foo (3)
-# SYMBOL-NAMES-NEXT:     Weight: 30
-# SYMBOL-NAMES-NEXT:   }
-# SYMBOL-NAMES-NEXT: ]
-
---- !ELF
-FileHeader:
-  Class:  ELFCLASS64
-  Data:   ELFDATA2LSB
-  Type:   ET_DYN
-Sections:
-  - Name: .llvm.call-graph-profile
-    Type: SHT_LLVM_CALL_GRAPH_PROFILE
-    Entries:
-## Case 1: Test we can use symbol names to describe an entry.
-      - From:   foo
-        To:     bar
-        Weight: 10
-## Case 2: Test we can refer to symbols with suffixes.
-      - From:   foo
-        To:     'foo (1)'
-        Weight: 30
-Symbols:
-  - Name: foo
-  - Name: bar
-  - Name: 'foo (1)'
-
 ## Check we can describe SHT_LLVM_CALL_GRAPH_PROFILE sections using the "Content" tag.
-# RUN: yaml2obj --docnum=4 %s -o %t.content
+# RUN: yaml2obj --docnum=3 %s -o %t.content
 # RUN: llvm-readobj --sections --section-data %t.content | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      Name: .llvm.call-graph-profile
 # CONTENT:      SectionData (
 # CONTENT-NEXT:   0000: 11223344 |
 # CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:    .llvm.call-graph-profile
     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
     Content: "11223344"
 
-## Check we can't reference unknown symbols by name.
-# RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=UNKNOWN-NAME
-# RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=UNKNOWN-NAME
-# UNKNOWN-NAME: error: unknown symbol referenced: 'bar' by YAML section '.llvm.call-graph-profile'
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2LSB
-  Type:  ET_DYN
-Sections:
-  - Name: .llvm.call-graph-profile
-    Type: SHT_LLVM_CALL_GRAPH_PROFILE
-## The first symbol is valid, but the second is unknown.
-    Entries:
-      - From:   foo
-        To:     bar
-        Weight: 10
-Symbols:
-  - Name: foo
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2LSB
-  Type:  ET_DYN
-Sections:
-  - Name: .llvm.call-graph-profile
-    Type: SHT_LLVM_CALL_GRAPH_PROFILE
-## The first symbol is unknown, but the second is valid.
-    Entries:
-      - From:   bar
-        To:     foo
-        Weight: 10
-Symbols:
-  - Name: foo
-
-## Check we can specify arbitrary symbol indexes for an SHT_LLVM_CALL_GRAPH_PROFILE section entry.
-# RUN: yaml2obj --docnum=7 %s -o %t.unk
-# RUN: llvm-readobj --sections --section-data %t.unk | FileCheck %s --check-prefix=UNKNOWN-INDEX
-
-# UNKNOWN-INDEX:      Name: .llvm.call-graph-profile
-# UNKNOWN-INDEX:      SectionData (
-# UNKNOWN-INDEX-NEXT:   0000: 01000000 02000000 03000000 00000000 |
-# UNKNOWN-INDEX-NEXT: )
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2LSB
-  Type:  ET_DYN
-Sections:
-  - Name: .llvm.call-graph-profile
-    Type: SHT_LLVM_CALL_GRAPH_PROFILE
-    Entries:
-      - From:   1
-        To:     2
-        Weight: 3
-
 ## Check we can use the "Content" key with the "Size" key when the size is greater
 ## than or equal to the content size.
 
-# RUN: not yaml2obj --docnum=8 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN: not yaml2obj --docnum=4 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
 
 # CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:    .llvm.foo
     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
     Link:    0x1
     EntSize: 0x2
     Size:    [[SIZE=<none>]]
     Content: [[CONTENT=<none>]]
     Entries: [[ENTRIES=<none>]]
 
-# RUN: yaml2obj --docnum=8 -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: yaml2obj --docnum=4 -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
 # RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
 # RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
 
-# RUN: yaml2obj --docnum=8 -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: yaml2obj --docnum=4 -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
 # RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
 # RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"
 
 # CHECK-CONTENT:      Name: .llvm.foo
 # CHECK-CONTENT-NEXT: Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # CHECK-CONTENT-NEXT: Flags [
 # CHECK-CONTENT-NEXT: ]
 # CHECK-CONTENT-NEXT: Address:
 # CHECK-CONTENT-NEXT: Offset:
 # CHECK-CONTENT-NEXT: Size:
 # CHECK-CONTENT-NEXT: Link: 1
 # CHECK-CONTENT-NEXT: Info:
 # CHECK-CONTENT-NEXT: AddressAlignment:
 # CHECK-CONTENT-NEXT: EntrySize: 2
 # CHECK-CONTENT-NEXT: SectionData (
 # CHECK-CONTENT-NEXT:   0000: [[DATA]] |
 # CHECK-CONTENT-NEXT: )
 
 ## Check we can use the "Size" key alone to create the section.
 
-# RUN: yaml2obj --docnum=8 -DSIZE=3 %s -o %t.size.o
+# RUN: yaml2obj --docnum=4 -DSIZE=3 %s -o %t.size.o
 # RUN: llvm-readobj --sections --section-data %t.size.o | \
 # RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="000000"
 
 ## Check we can use the "Content" key alone to create the section.
 
-# RUN: yaml2obj --docnum=8 -DCONTENT="'112233'" %s -o %t.content.o
+# RUN: yaml2obj --docnum=4 -DCONTENT="'112233'" %s -o %t.content.o
 # RUN: llvm-readobj --sections --section-data %t.content.o | \
 # RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="112233"
 
 ## Check we can't use the "Entries" key together with the "Content" or "Size" keys.
 
-# RUN: not yaml2obj --docnum=8 -DSIZE=0 -DENTRIES="[]" %s 2>&1 | \
+# RUN: not yaml2obj --docnum=4 -DSIZE=0 -DENTRIES="[]" %s 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
-# RUN: not yaml2obj --docnum=8 -DCONTENT="'00'" -DENTRIES="[]" %s 2>&1 | \
+# RUN: not yaml2obj --docnum=4 -DCONTENT="'00'" -DENTRIES="[]" %s 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
 
 # ENTRIES-ERR: error: "Entries" cannot be used with "Content" or "Size"

llvm/test/tools/yaml2obj/ELF/section-headers-exclude.yaml

Excluded:
       - Name: .symtab
 
 ## Case G: check we do not link SHT_LLVM_CALL_GRAPH_PROFILE/SHT_LLVM_ADDRSIG/SHT_GROUP/SHT_REL[A] sections
 ##         with .symtab implicitly when the latter is excluded.
 # RUN: yaml2obj %s --docnum=15 -o %t7
 # RUN: llvm-readelf %t7 --section-headers | FileCheck %s --check-prefix=LINK-IMPLICIT
 
 # LINK-IMPLICIT:      [Nr] Name          Type                    Address          Off    Size   ES Flg Lk Inf Al
-# LINK-IMPLICIT:      [ 1] .cgp          LLVM_CALL_GRAPH_PROFILE 0000000000000000 000040 000000 10      0   0  0
+# LINK-IMPLICIT:      [ 1] .cgp          LLVM_CALL_GRAPH_PROFILE 0000000000000000 000040 000000 08      0   0  0
 # LINK-IMPLICIT-NEXT: [ 2] .llvm_addrsig LLVM_ADDRSIG            0000000000000000 000040 000000 00      0   0  0
 # LINK-IMPLICIT-NEXT: [ 3] .group        GROUP                   0000000000000000 000040 000000 04      0   0  0
 # LINK-IMPLICIT-NEXT: [ 4] .rela         RELA                    0000000000000000 000040 000000 18      0   0  0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB

llvm/tools/llvm-readobj/ELFDumper.cpp

void printStackSize(const Relocation<ELFT> &R, const Elf_Shdr &RelocSec,
                       unsigned Ndx, const Elf_Shdr *SymTab,
                       const Elf_Shdr *FunctionSec, const Elf_Shdr &StackSizeSec,
                       const RelocationResolver &Resolver, DataExtractor Data);
   virtual void printStackSizeEntry(uint64_t Size, StringRef FuncName) = 0;
 
   void printRelocatableStackSizes(std::function<void()> PrintHeader);
   void printNonRelocatableStackSizes(std::function<void()> PrintHeader);
 
+  /// Retrieves sections with corresponding relocation sections based on
+  /// IsMatch.
+  void getSectionAndRelocations(
+      std::function<bool(const Elf_Shdr &)> IsMatch,
+      llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> &SecToRelocMap);
+
   const object::ELFObjectFile<ELFT> &ObjF;
   const ELFFile<ELFT> &Obj;
   StringRef FileName;
 
   Expected<DynRegionInfo> createDRI(uint64_t Offset, uint64_t Size,
                                     uint64_t EntSize) {
     if (Offset + Size < Offset || Offset + Size > Obj.getBufSize())
       return createError("offset (0x" + Twine::utohexstr(Offset) +
protected:
   Optional<DynRegionInfo> DynSymRegion;
   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 *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()),
       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) {
     switch (Sec.sh_type) {
     case ELF::SHT_SYMTAB:
       if (!DotSymtabSec)
         DotSymtabSec = &Sec;
       break;
     case ELF::SHT_DYNSYM:
       if (!DotDynsymSec)
         DotDynsymSec = &Sec;
 
for (const Elf_Shdr &Sec : Sections) {
     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)
-        DotCGProfileSec = &Sec;
-      break;
     case ELF::SHT_LLVM_ADDRSIG:
       if (!DotAddrsigSec)
         DotAddrsigSec = &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();
     });
     if (!MappedAddrOrError) {
       this->reportUniqueWarning("unable to parse DT_" +
                                 Obj.getDynamicTagAsString(Tag) + ": " +
                                 llvm::toString(MappedAddrOrError.takeError()));
       return nullptr;
     }
     return MappedAddrOrError.get();
while (Offset < Contents.size()) {
       if (!printFunctionStackSize(SymValue, /*FunctionSec=*/None, Sec, Data,
                                   &Offset))
         break;
     }
   }
 }
 
 template <class ELFT>
-void ELFDumper<ELFT>::printRelocatableStackSizes(
-    std::function<void()> PrintHeader) {
-  // Build a map between stack size sections and their corresponding relocation
-  // sections.
-  llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> StackSizeRelocMap;
+void ELFDumper<ELFT>::getSectionAndRelocations(
+    std::function<bool(const Elf_Shdr &)> IsMatch,
+    llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> &SecToRelocMap) {
   for (const Elf_Shdr &Sec : cantFail(Obj.sections())) {
-    StringRef SectionName;
-    if (Expected<StringRef> NameOrErr = Obj.getSectionName(Sec))
-      SectionName = *NameOrErr;
-    else
-      consumeError(NameOrErr.takeError());
-
-    // A stack size section that we haven't encountered yet is mapped to the
-    // null section until we find its corresponding relocation section.
-    if (SectionName == ".stack_sizes")
-      if (StackSizeRelocMap
-              .insert(std::make_pair(&Sec, (const Elf_Shdr *)nullptr))
+    if (IsMatch(Sec))
+      if (SecToRelocMap.insert(std::make_pair(&Sec, (const Elf_Shdr *)nullptr))
               .second)
         continue;
 
-    // Check relocation sections if they are relocating contents of a
-    // stack sizes section.
     if (Sec.sh_type != ELF::SHT_RELA && Sec.sh_type != ELF::SHT_REL)
       continue;
 
     Expected<const Elf_Shdr *> RelSecOrErr = Obj.getSection(Sec.sh_info);
     if (!RelSecOrErr) {
       reportUniqueWarning(describe(Sec) +
                           ": failed to get a relocated section: " +
                           toString(RelSecOrErr.takeError()));
       continue;
     }
-
     const Elf_Shdr *ContentsSec = *RelSecOrErr;
-    if (this->getPrintableSectionName(**RelSecOrErr) != ".stack_sizes")
-      continue;
-
-    // Insert a mapping from the stack sizes section to its relocation section.
-    StackSizeRelocMap[ContentsSec] = &Sec;
-  }
+    if (IsMatch(*ContentsSec))
+      SecToRelocMap[ContentsSec] = &Sec;
+  }
 
+template <class ELFT>
+void ELFDumper<ELFT>::printRelocatableStackSizes(
+    std::function<void()> PrintHeader) {
+  // Build a map between stack size sections and their corresponding relocation
+  // sections.
+  llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> StackSizeRelocMap;
+  auto IsMatch = [&](const Elf_Shdr &Sec) -> bool {
+    StringRef SectionName;
+    if (Expected<StringRef> NameOrErr = Obj.getSectionName(Sec))
+      SectionName = *NameOrErr;
+    else
+      consumeError(NameOrErr.takeError());
+
+    return SectionName == ".stack_sizes";
+  };
+  getSectionAndRelocations(IsMatch, StackSizeRelocMap);
+
   for (const auto &StackSizeMapEntry : StackSizeRelocMap) {
     PrintHeader();
     const Elf_Shdr *StackSizesELFSec = StackSizeMapEntry.first;
     const Elf_Shdr *RelocSec = StackSizeMapEntry.second;
 
     // Warn about stack size sections without a relocation section.
     if (!RelocSec) {
       reportWarning(createError(".stack_sizes (" + describe(*StackSizesELFSec) +
for (const VerNeed &VN : *V) {
     }
   }
 }
 
 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;
+  llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> SecToRelocMap;
+
+  auto IsMatch = [](const Elf_Shdr &Sec) -> bool {
+    return Sec.sh_type == ELF::SHT_LLVM_CALL_GRAPH_PROFILE;
+  };
+  this->getSectionAndRelocations(IsMatch, SecToRelocMap);
+
+  for (const auto &CGMapEntry : SecToRelocMap) {
+    const Elf_Shdr *CGSection = CGMapEntry.first;
+    const Elf_Shdr *CGRelSection = CGMapEntry.second;
 
     Expected<ArrayRef<Elf_CGProfile>> CGProfileOrErr =
-      this->Obj.template getSectionContentsAsArray<Elf_CGProfile>(
-          *this->DotCGProfileSec);
+        this->Obj.template getSectionContentsAsArray<Elf_CGProfile>(*CGSection);
     if (!CGProfileOrErr) {
       this->reportUniqueWarning(
-        "unable to dump the SHT_LLVM_CALL_GRAPH_PROFILE section: " +
+          "unable to load the SHT_LLVM_CALL_GRAPH_PROFILE section: " +
           toString(CGProfileOrErr.takeError()));
       return;
     }
 
-  for (const Elf_CGProfile &CGPE : *CGProfileOrErr) {
+    Elf_Rela_Range CGProfileRela;
+    bool UseReloc = (CGRelSection != nullptr);
+    if (UseReloc) {
+      Expected<Elf_Rela_Range> CGProfileRelaOrError =
+          this->Obj.relas(*CGRelSection);
+      if (!CGProfileRelaOrError) {
+        this->reportUniqueWarning("unable to load relocations for "
+                                  "SHT_LLVM_CALL_GRAPH_PROFILE section: " +
+                                  toString(CGProfileRelaOrError.takeError()));
+        UseReloc = false;
+      } else
+        CGProfileRela = *CGProfileRelaOrError;
+
+      if (UseReloc && CGProfileRela.size() != (CGProfileOrErr->size() * 2)) {
+        this->reportUniqueWarning(
+            "number of from/to pairs does not match number of frequencies");
+        UseReloc = false;
+      }
+    } else
+      this->reportUniqueWarning(
+          "relocation section for a call graph section doesn't exist");
+
+    auto GetIndex = [&](uint32_t Index) {
+      const Elf_Rel_Impl<ELFT, true> &Rel = CGProfileRela[Index];
+      return Rel.getSymbol(this->Obj.isMips64EL());
+    };
+
+    ListScope L(W, "CGProfile");
+    for (uint32_t I = 0, Size = CGProfileOrErr->size(); I != Size; ++I) {
+      const Elf_CGProfile &CGPE = (*CGProfileOrErr)[I];
       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);
+      if (UseReloc) {
+        uint32_t From = GetIndex(I * 2);
+        uint32_t To = GetIndex(I * 2 + 1);
+        W.printNumber("From", this->getStaticSymbolName(From), From);
+        W.printNumber("To", this->getStaticSymbolName(To), To);
+      }
       W.printNumber("Weight", CGPE.cgp_weight);
     }
   }
+}
 
 template <class ELFT> void LLVMELFDumper<ELFT>::printBBAddrMaps() {
   bool IsRelocatable = this->Obj.getHeader().e_type == ELF::ET_REL;
   for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
     if (Sec.sh_type != SHT_LLVM_BB_ADDR_MAP)
       continue;
     Optional<const Elf_Shdr *> FunctionSec = None;
     if (IsRelocatable)

llvm/tools/obj2yaml/elf2yaml.cpp

ELFDumper<ELFT>::dumpCallGraphProfileSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::CallGraphProfileSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(*Shdr);
   if (!ContentOrErr)
     return ContentOrErr.takeError();
   ArrayRef<uint8_t> Content = *ContentOrErr;
-
+  const uint32_t SizeOfEntry = ELFYAML::getDefaultShEntSize<ELFT>(
+      Obj.getHeader().e_machine, S->Type, S->Name);
   // Dump the section by using the Content key when it is truncated.
   // There is no need to create either "Content" or "Entries" fields when the
   // section is empty.
-  if (Content.empty() || Content.size() % 16 != 0) {
+  if (Content.empty() || Content.size() % SizeOfEntry != 0) {
     if (!Content.empty())
       S->Content = yaml::BinaryRef(Content);
     return S.release();
   }
 
-  std::vector<ELFYAML::CallGraphEntry> Entries(Content.size() / 16);
+  std::vector<ELFYAML::CallGraphEntryWeight> Entries(Content.size() /
+                                                     SizeOfEntry);
   DataExtractor Data(Content, Obj.isLE(), /*AddressSize=*/0);
   DataExtractor::Cursor Cur(0);
-  auto ReadEntry = [&](ELFYAML::CallGraphEntry &E) {
-    uint32_t FromSymIndex = Data.getU32(Cur);
-    uint32_t ToSymIndex = Data.getU32(Cur);
+  auto ReadEntry = [&](ELFYAML::CallGraphEntryWeight &E) {
     E.Weight = Data.getU64(Cur);
     if (!Cur) {
       consumeError(Cur.takeError());
       return false;
     }
-
-    Expected<StringRef> From = getSymbolName(Shdr->sh_link, FromSymIndex);
-    Expected<StringRef> To = getSymbolName(Shdr->sh_link, ToSymIndex);
-    if (From && To) {
-      E.From = *From;
-      E.To = *To;
-      return true;
-    }
-    consumeError(From.takeError());
-    consumeError(To.takeError());
-    return false;
   };
 
-  for (ELFYAML::CallGraphEntry &E : Entries) {
+  for (ELFYAML::CallGraphEntryWeight &E : Entries) {
     if (ReadEntry(E))
       continue;
     S->Content = yaml::BinaryRef(Content);
     return S.release();
   }
 
   S->Entries = std::move(Entries);
   return S.release();