[llvm-readobj/llvm-readelf]: Dump stack-size entry for all function symbols that have a particular value (fixes PR43245)

[wolfgangp]

Summary

It is possible that several function symbols have the same value, for example as a result of linker optimizations such as collapsing of identical functions into one function body. See PR43245.

This patch fixes readelf/readobj in the following way:
for each stack size entry, dump all functions (not just the first one) with the specified address.

(Note: as part of collapsing the function bodies, the linker has also collapsed the stack size entries).

[jhenderson]

tools/llvm-readobj/ELFDumper.cpp

4758–4760

I think it would be good if we could avoid duplicating this reportWarning call (especially the text part). Perhaps worth a small lambda, or at least pulling the message into a StringRef?

4761

Whilst not strictly necessary, it might be good to return here. I think that would be less likely to run into surprises due to future code changes below it.

[grimar]

tools/llvm-readobj/ELFDumper.cpp

4762

I'd add a early return here:

if (FuncSyms.empty()) {
  reportWarning(
      createError("could not identify function symbol for stack size entry"),
      Obj->getFileName());
  printStackSizeEntry(StackSize, "?");
  return;
}

4779

Perhaps inline FuncName? It would remove one string assignment for the normal case:

for (const SymbolRef &FuncSym : FuncSyms) {
  // A valid SymbolRef has a non-null object file pointer.
  if (FuncSym.BasicSymbolRef::getObject()) {
    // Extract the symbol name.
    Expected<StringRef> FuncNameOrErr = FuncSym.getName();
    if (FuncNameOrErr)
      printStackSizeEntry(StackSize, maybeDemangle(*FuncNameOrErr));
    else
      consumeError(FuncNameOrErr.takeError());
    continue;
  }
  reportWarning(
      createError("could not identify function symbol for stack size entry"),
      Obj->getFileName());
  printStackSizeEntry(StackSize, "?");
}

[grimar]

tools/llvm-readobj/ELFDumper.cpp

4779

Ah, my suggestion will not work for a case when getName() returns an error. Please ignore this comment.

[jhenderson]

One issue that just occurred to me, is what happens if you still have the stack size entry in this case? Something like:

<snip>
Sections:
  - Name: .stack_sizes
    Type: SHT_PROGBITS
    Entries:
      - Address: 0x10
        Size: 32
      - Address: 0x10
        Size: 32
Symbols:
  - Name: foo
    Type: STT_FUNC
    Value: 0x10
  - Name: baz
    Type: STT_FUNC
    Value: 0x10

I might be missing something in the code, but I think your change will result in the stack size entries effectively being printed twice per symbol:

# Printing for first entry:
32 foo
32 baz
# Printing for second entry:
32 foo
32 baz

I think this is undesirable. Perhaps you need to track whether a stack size entry for a given address has been printed yet, and skip it if it has?

[MaskRay]

It is possible that several function symbols have the same value, for example as a result of linker optimizations such as collapsing of identical functions into one function body. See PR43245.

Yes. A simple reproduce:

clang -ffunction-sections -fstack-size-section a.c -c
ld.lld --icf=all a.o -o a

Another type of cases is function aliases (__attribute__((alias(foo)))).

This patch fixes readelf/readobj to dump the stack size for all such functions, not just the first one found in the symbol table.

It may be clearer to restate this: for each stack size entry, dump all functions (not just the first one) with the specified address.

test/tools/llvm-readobj/stack-sizes.test

177

Add another entry with Type: STT_NOTYPE to demonstrate that a non-function symbol is not dumped.

[MaskRay]

tools/llvm-readobj/ELFDumper.cpp

4770

if (Expected<StringRef> FuncNameOrErr = FuncSym.getName())

[wolfgangp]

In D67998#1682076, @jhenderson wrote:

One issue that just occurred to me, is what happens if you still have the stack size entry in this case? Something like:

<snip>

I think this is undesirable. Perhaps you need to track whether a stack size entry for a given address has been printed yet, and skip it if it has?

Yes, good observation. There is also the question what to do if the sizes of 2 different entries with the same address don't match. This should probably elicit a warning.

[jhenderson]

In D67998#1682945, @wolfgangp wrote:

Yes, good observation. There is also the question what to do if the sizes of 2 different entries with the same address don't match. This should probably elicit a warning.

I agree this should probably print a warning, and I think it then should do a best guess print of the stack sizes. I have three options, in rough order of preference for this:

1. Display the entries with symbols in the order they appear in the symbol table, i.e. if foo and bar appear in that order in the symbol table, with the same address, I'd print foo with the first stack size and bar with the second. This is probably a reasonable guess based on what the linker might have done (putting the symbols in order they are discovered, same as the stack sizes entries).
2. Display only the largest entry, but once per symbol with the same address. In practice, this is probably just as good. It doesn't really make sense for two symbols to have the same address but different stack sizes: that would imply that the same bit of code has different possible sizes, which doesn't really make sense.
3. Display the first entry size, for each symbol. This is probably the simplest.

[MaskRay]

In D67998#1683795, @jhenderson wrote:

In D67998#1682945, @wolfgangp wrote:

Yes, good observation. There is also the question what to do if the sizes of 2 different entries with the same address don't match. This should probably elicit a warning.

I agree this should probably print a warning, and I think it then should do a best guess print of the stack sizes. I have three options, in rough order of preference for this:

1. Display the entries with symbols in the order they appear in the symbol table, i.e. if foo and bar appear in that order in the symbol table, with the same address, I'd print foo with the first stack size and bar with the second. This is probably a reasonable guess based on what the linker might have done (putting the symbols in order they are discovered, same as the stack sizes entries).
2. Display only the largest entry, but once per symbol with the same address. In practice, this is probably just as good. It doesn't really make sense for two symbols to have the same address but different stack sizes: that would imply that the same bit of code has different possible sizes, which doesn't really make sense.
3. Display the first entry size, for each symbol. This is probably the simplest.

The warning case should be very rare. The ICF implementation in neither gold nor lld folds sections with different sizes (i.e. functions with different sizes) gold/icf.cc#l756 lld/ELF/ICF.cpp#L305. st_size=0 aliases can sometimes happen for STT_NOTYPE symbols, but I can't find any case for STT_FUNC. Emitting a warnings looks good to me. I think the we can just pick the simplest guessing approach.

[wolfgangp]

1. Rebased with the latest upstream changes.
2. Addressed review comments as follows:
   • Keeping track of stack sizes already dumped so that duplicate entries only are printed once.
   • Issue a warning when a duplicate entry with a different stack size is encountered.
   • Simplified code by collapsing some warning code into a lambda.
   • added the appropriate test cases for the changed functionality and added one for STT_NOTYPE.
   • added an early return in a case where no valid symbol is found.

[wolfgangp]

In D67998#1683795, @jhenderson wrote:

In D67998#1682945, @wolfgangp wrote:

Yes, good observation. There is also the question what to do if the sizes of 2 different entries with the same address don't match. This should probably elicit a warning.

<snip>

1. Display the first entry size, for each symbol. This is probably the simplest.

For some reason, I didn't see your response until I had posted my updated. I basically implemented number 3.

[jhenderson]

test/tools/llvm-readobj/stack-sizes.test

95–100

I think combining the different cases into a single test run is risking confusion. I'd prefer it if each issue were a separate test (i.e. have a basic single-entry only case, a NOBITS case, a multiple entries for the same address case, and one where the sizes conflict).

172–176

It's not clear from anywhere why this symbol exists. It needs commenting at least. See also my comments above.

686

FileCheck has an --input-file switch, which I think is more commonly used instead of redirecting stdin, when the file exists on disk.

717

This looks out-of-line in comparison to the other fields.

735–737

Using a section symbol is rather confusing. Can't this just be another symbol with value 0 in the same section?

Also, I think relocations are a more complex case to the executable one. In particular, you need to handle two symbols in different sections, but with identical values. In these cases, they aren't duplicates (and you need to show that).

tools/llvm-readobj/ELFDumper.cpp

373

Does this map need to be ordered?

4724

I think these warnings need more context - which entry can't you identify a function symbol for here? (Add the offset).

4761

This is marked as done but hasn't been addressed?

4762

Which entries (include the offsets), and what were their sizes?

test/tools/llvm-readobj/stack-sizes.test

- Name:    referenced_by_symbol_foo
     Binding: STB_GLOBAL
   - Name:    referenced_via_section_bar
     Section: .text
     Value:   0x10
     Type:    STT_FUNC
     Binding: STB_GLOBAL
 
 ## Check that we correctly report the stack sizes in an executable (non-relocatable)
-## object file.
+## object file. Furthermore, check that we report stack sizes for functions that
+## share a stack size entry with other functions (e.g. because several functions
+## have been collapsed into a single function body by the linker). Also, check
+## that if we have duplicate stack size entries for a function, we only print one
+## entry. Lastly, check that we issue a warning should the stack sizes mismatch in
+## duplicate entries.
 
 # RUN: yaml2obj --docnum=2 %s > %t02
-# RUN: llvm-readelf --stack-sizes %t02 \
+# RUN: llvm-readelf --stack-sizes %t02 2> %t02-gnu.err \
 # RUN:   | FileCheck %s --check-prefix=EXEC-GNU --strict-whitespace --match-full-lines
-# RUN: llvm-readobj --stack-sizes %t02 | FileCheck %s --check-prefix=EXEC-LLVM
+# RUN: llvm-readobj --stack-sizes %t02 2> %t02-llvm.err | FileCheck %s --check-prefix=EXEC-LLVM
+# RUN: FileCheck %s < %t02-gnu.err --check-prefix=EXEC-ERR -DFILE=%t02
+# RUN: FileCheck %s < %t02-llvm.err --check-prefix=EXEC-ERR -DFILE=%t02
 
 #      EXEC-GNU:         Size     Function
 # EXEC-GNU-NEXT:           16     foo
 # EXEC-GNU-NEXT:           32     bar
+# EXEC-GNU-NEXT:           32     baz
 #  EXEC-GNU-NOT:{{.}}
 
 # EXEC-LLVM:      StackSizes [
 # EXEC-LLVM-NEXT:   Entry {
 # EXEC-LLVM-NEXT:     Function: foo
 # EXEC-LLVM-NEXT:     Size: 0x10
 # EXEC-LLVM-NEXT:   }
 # EXEC-LLVM-NEXT:   Entry {
 # EXEC-LLVM-NEXT:     Function: bar
 # EXEC-LLVM-NEXT:     Size: 0x20
 # EXEC-LLVM-NEXT:   }
+# EXEC-LLVM-NEXT:   Entry {
+# EXEC-LLVM-NEXT:     Function: baz
+# EXEC-LLVM-NEXT:     Size: 0x20
+# EXEC-LLVM-NEXT:   }
 # EXEC-LLVM-NEXT: ]
 
+# EXEC-ERR: warning: '[[FILE]]': mismatching sizes in stack size entries for the same address
+
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .text
     Type:    SHT_PROGBITS
     Flags:   [SHF_ALLOC]
     Size:    16
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
     Entries:
       - Address: 0x10
         Size:    0x10
       - Address: 0x20
         Size:    0x20
+# 2 duplicate entries for address 0x20, one with mismatching size.
+      - Address: 0x20
+        Size:    0x20
+      - Address: 0x20
+        Size:    0x30
     Link:    .text
 Symbols:
   - Name:    foo
     Section: .text
     Value:   0x10
     Type:    STT_FUNC
     Binding: STB_GLOBAL
   - Name:    bar
     Section: .text
     Value:   0x20
     Type:    STT_FUNC
     Binding: STB_GLOBAL
+  - Name:    baz
+    Section: .text
+    Value:   0x20
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+  - Name:    myobj
+    Section: .text
+    Value:   0x20
+    Type:    STT_OBJECT
+    Binding: STB_GLOBAL
 
 ## Check that we report an error when we find relocations whose offsets point outside
 ## of the .stack_sizes section.
 
 # RUN: yaml2obj --docnum=3 %s > %t03
 # RUN: not llvm-readelf --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT -DFILE=%t03
 # RUN: not llvm-readobj --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT -DFILE=%t03
 
 # SHORT: error: '[[FILE]]': found invalid relocation offset into section .stack_sizes while trying to extract a stack size entry

 # MULTIPLE-LLVM-NEXT:   Entry {
 # MULTIPLE-LLVM-NEXT:     Function: foo
 # MULTIPLE-LLVM-NEXT:     Size: 0x10
 # MULTIPLE-LLVM-NEXT:   }
 # MULTIPLE-LLVM-NEXT:   Entry {
 # MULTIPLE-LLVM-NEXT:     Function: bar
 # MULTIPLE-LLVM-NEXT:     Size: 0x20
 # MULTIPLE-LLVM-NEXT:   }
+# MULTIPLE-LLVM-NEXT:   Entry {
+# MULTIPLE-LLVM-NEXT:     Function: baz
+# MULTIPLE-LLVM-NEXT:     Size: 0x20
+# MULTIPLE-LLVM-NEXT:   }
 # MULTIPLE-LLVM-NEXT: ]
 
 ## Check that we do not consider symbols that are not function symbols, even though
 ## a relocation references them. 
 
 # RUN: yaml2obj --docnum=9 %s > %t14
 # RUN: llvm-readelf --stack-sizes %t14 2> %t14-gnu.err | FileCheck %s --check-prefix=NONFUNCTIONSYM-GNU
 # RUN: FileCheck %s < %t14-gnu.err --check-prefix=NONFUNCTIONSYM-ERR -DFILE=%t14
- Name: .stack_sizes
     Type: SHT_PROGBITS
     Content: "00"
   - Name: .rela.stack_sizes
     Type: SHT_RELA
     Info: .stack_sizes
     Relocations:
       - Offset: 0
         Type:   R_X86_64_64
+
+## Check that duplicate stack size entries in relocatable files are not displayed
+## and that they elicit a warning when their sizes don't match.
+
+# RUN: yaml2obj --docnum=13 %s > %t18
+# RUN: llvm-readelf --stack-sizes %t18 2> %t18-gnu.err \
+# RUN:   | FileCheck %s -DFILE=%t18 --check-prefix=DUPLICATE-GNU
+# RUN: llvm-readobj --stack-sizes %t18 2> %t18-llvm.err \
+# RUN:   | FileCheck %s -DFILE=%t18 --check-prefix=DUPLICATE-LLVM
+# RUN: FileCheck %s < %t18-gnu.err --check-prefix=DUPLICATE-ERR -DFILE=%t18
+# RUN: FileCheck %s < %t18-llvm.err --check-prefix=DUPLICATE-ERR -DFILE=%t18
+
+#      DUPLICATE-GNU:         Size     Function
+# DUPLICATE-GNU-NEXT:           16     foo
+#  DUPLICATE-GNU-NOT:{{.}}
+
+# DUPLICATE-LLVM:      StackSizes [
+# DUPLICATE-LLVM-NEXT:   Entry {
+# DUPLICATE-LLVM-NEXT:     Function: foo
+# DUPLICATE-LLVM-NEXT:     Size: 0x10
+# DUPLICATE-LLVM-NEXT:   }
+# DUPLICATE-LLVM-NEXT: ]
+
+# DUPLICATE-ERR: warning: '[[FILE]]': mismatching sizes in stack size entries for the same address
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .text
+    Type: SHT_PROGBITS
+    Size: 8
+  - Name: .stack_sizes
+    Type: SHT_PROGBITS
+    Entries:
+      - Size: 0x10
+      - Size: 0x20
+    Link:    .text
+  - Name: .rela.stack_sizes
+    Type: SHT_RELA
+    Info: .stack_sizes
+    Relocations:
+## Both relocations resolve to the same symbol.
+      - Offset: 0
+        Symbol: .text
+        Type:   R_X86_64_64
+      - Offset: 9
+        Symbol: foo 
+        Type:   R_X86_64_64
+Symbols:
+  - Name:    foo
+    Section: .text
+    Value:   0
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+  - Name:    .text
+    Section: .text
+    Type:    STT_SECTION

tools/llvm-readobj/ELFDumper.cpp

 
 template <class ELFT> class MipsGOTParser;
 
 template <typename ELFT> class DumpStyle {
 public:
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Sym = typename ELFT::Sym;
   using Elf_Addr = typename ELFT::Addr;
+  using StackSizeEntryMap = std::map<uint64_t, uint64_t>;
 
   DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) {
     FileName = this->Dumper->getElfObject()->getFileName();
 
     // Dumper reports all non-critical errors as warnings.
     // It does not print the same warning more than once.
     WarningHandler = [this](const Twine &Msg) {
       if (Warnings.insert(Msg.str()).second)
public:
   virtual void printStackSizes(const ELFObjectFile<ELFT> *Obj) = 0;
   void printNonRelocatableStackSizes(const ELFObjectFile<ELFT> *Obj,
                                      std::function<void()> PrintHeader);
   void printRelocatableStackSizes(const ELFObjectFile<ELFT> *Obj,
                                   std::function<void()> PrintHeader);
   void printFunctionStackSize(const ELFObjectFile<ELFT> *Obj, uint64_t SymValue,
                               SectionRef FunctionSec,
                               const StringRef SectionName, DataExtractor Data,
+                              StackSizeEntryMap &StackSizeEntries,
                               uint64_t *Offset);
   void printStackSize(const ELFObjectFile<ELFT> *Obj, RelocationRef Rel,
                       SectionRef FunctionSec,
                       const StringRef &StackSizeSectionName,
-                      const RelocationResolver &Resolver, DataExtractor Data);
+                      const RelocationResolver &Resolver,
+                      StackSizeEntryMap &StackSizeEntries, DataExtractor Data);
   virtual void printStackSizeEntry(uint64_t Size, StringRef FuncName) = 0;
   virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0;
   virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0;
   const ELFDumper<ELFT> *dumper() const { return Dumper; }
 
 protected:
   std::function<Error(const Twine &Msg)> WarningHandler;
   StringRef FileName;
if (NameOrErr)
     return maybeDemangle(*NameOrErr);
   consumeError(NameOrErr.takeError());
   return "<?>";
 }
 
 template <class ELFT>
 void DumpStyle<ELFT>::printFunctionStackSize(
     const ELFObjectFile<ELFT> *Obj, uint64_t SymValue, SectionRef FunctionSec,
-    const StringRef SectionName, DataExtractor Data, uint64_t *Offset) {
+    const StringRef SectionName, DataExtractor Data,
+    StackSizeEntryMap &StackSizeEntries, uint64_t *Offset) {
   // This function ignores potentially erroneous input, unless it is directly
   // related to stack size reporting.
-  SymbolRef FuncSym;
+
+  auto reportUnknownFunctionSymbol = [](const ELFObjectFile<ELFT> *Obj) {
+    reportWarning(
+        createError("could not identify function symbol for stack size entry"),
+        Obj->getFileName());
+  };
+
+  // Find all the function symbols that match SymValue and are in FunctionSec.
+  std::vector<SymbolRef> FuncSyms;
   for (const ELFSymbolRef &Symbol : Obj->symbols()) {
     Expected<uint64_t> SymAddrOrErr = Symbol.getAddress();
     if (!SymAddrOrErr) {
       consumeError(SymAddrOrErr.takeError());
       continue;
     }
-    if (Symbol.getELFType() == ELF::STT_FUNC && *SymAddrOrErr == SymValue) {
+    if (Symbol.getELFType() == ELF::STT_FUNC && *SymAddrOrErr == SymValue)
       // Check if the symbol is in the right section.
-      if (FunctionSec.containsSymbol(Symbol)) {
-        FuncSym = Symbol;
-        break;
-      }
-    }
+      if (FunctionSec.containsSymbol(Symbol))
+        FuncSyms.push_back(Symbol);
   }
 
-  std::string FuncName = "?";
-  // A valid SymbolRef has a non-null object file pointer.
-  if (FuncSym.BasicSymbolRef::getObject())
-    FuncName = getSymbolName(FuncSym);
-  else
-    reportWarning(
-        createError("could not identify function symbol for stack size entry"),
-        Obj->getFileName());
-
   // Extract the size. The expectation is that Offset is pointing to the right
   // place, i.e. past the function address.
   uint64_t PrevOffset = *Offset;
   uint64_t StackSize = Data.getULEB128(Offset);
   // getULEB128() does not advance Offset if it is not able to extract a valid
   // integer.
   if (*Offset == PrevOffset)
     reportError(
         createStringError(object_error::parse_failed,
                           "could not extract a valid stack size in section %s",
                           SectionName.data()),
         Obj->getFileName());
 
+  // If we have already printed a stack size entry with this SymValue, do not
+  // print it again, but report a warning if the sizes don't match.
+  auto PrevSizeIt = StackSizeEntries.find(SymValue);
+  if (PrevSizeIt != StackSizeEntries.end()) {
+    if (PrevSizeIt->second != StackSize)
+      reportWarning(
+          createError(
+              "mismatching sizes in stack size entries for the same address"),
+          Obj->getFileName());
+    return;
+  }
+  StackSizeEntries.emplace(SymValue, StackSize);
+
+  // If we didn't find any matching symbols, print one entry with an unknown
+  // function symbol name and issue a warning.
+  if (FuncSyms.empty()) {
+    reportUnknownFunctionSymbol(Obj);
+    printStackSizeEntry(StackSize, "?");
+  }
+
+  for (const SymbolRef &FuncSym : FuncSyms) {
+    std::string FuncName = "?";
+    // A valid SymbolRef has a non-null object file pointer.
+    if (FuncSym.BasicSymbolRef::getObject())
+      FuncName = getSymbolName(FuncSym);
+    else
+      reportUnknownFunctionSymbol(Obj);
     printStackSizeEntry(StackSize, FuncName);
   }
+}
 
 template <class ELFT>
 void GNUStyle<ELFT>::printStackSizeEntry(uint64_t Size, StringRef FuncName) {
   OS.PadToColumn(2);
   OS << format_decimal(Size, 11);
   OS.PadToColumn(18);
   OS << FuncName << "\n";
 }
 
 template <class ELFT>
-void DumpStyle<ELFT>::printStackSize(const ELFObjectFile<ELFT> *Obj,
-                                     RelocationRef Reloc,
-                                     SectionRef FunctionSec,
-                                     const StringRef &StackSizeSectionName,
-                                     const RelocationResolver &Resolver,
-                                     DataExtractor Data) {
+void DumpStyle<ELFT>::printStackSize(
+    const ELFObjectFile<ELFT> *Obj, RelocationRef Reloc, SectionRef FunctionSec,
+    const StringRef &StackSizeSectionName, const RelocationResolver &Resolver,
+    StackSizeEntryMap &StackSizeEntries, DataExtractor Data) {
   // This function ignores potentially erroneous input, unless it is directly
   // related to stack size reporting.
   object::symbol_iterator RelocSym = Reloc.getSymbol();
   uint64_t RelocSymValue = 0;
   StringRef FileStr = Obj->getFileName();
   if (RelocSym != Obj->symbol_end()) {
     // Ensure that the relocation symbol is in the function section, i.e. the
     // section where the functions whose stack sizes we are reporting are
reportError(
                           "found invalid relocation offset into section %s "
                           "while trying to extract a stack size entry",
                           StackSizeSectionName.data()),
         FileStr);
 
   uint64_t Addend = Data.getAddress(&Offset);
   uint64_t SymValue = Resolver(Reloc, RelocSymValue, Addend);
   this->printFunctionStackSize(Obj, SymValue, FunctionSec, StackSizeSectionName,
-                               Data, &Offset);
+                               Data, StackSizeEntries, &Offset);
 }
 
 template <class ELFT>
 void DumpStyle<ELFT>::printNonRelocatableStackSizes(
     const ELFObjectFile<ELFT> *Obj, std::function<void()> PrintHeader) {
   // This function ignores potentially erroneous input, unless it is directly
   // related to stack size reporting.
   const ELFFile<ELFT> *EF = Obj->getELFFile();
   StringRef FileStr = Obj->getFileName();
   for (const SectionRef &Sec : Obj->sections()) {
     StringRef SectionName = getSectionName(Sec);
     if (SectionName != ".stack_sizes")
       continue;
     PrintHeader();
     const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl());
     ArrayRef<uint8_t> Contents =
         unwrapOrError(this->FileName, EF->getSectionContents(ElfSec));
     DataExtractor Data(Contents, Obj->isLittleEndian(), sizeof(Elf_Addr));
     // A .stack_sizes section header's sh_link field is supposed to point
     // to the section that contains the functions whose stack sizes are
     // described in it.
     const Elf_Shdr *FunctionELFSec =
         unwrapOrError(this->FileName, EF->getSection(ElfSec->sh_link));
     uint64_t Offset = 0;
+    StackSizeEntryMap StackSizeEntries;
     while (Offset < Contents.size()) {
       // The function address is followed by a ULEB representing the stack
       // size. Check for an extra byte before we try to process the entry.
       if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) {
         reportError(
             createStringError(
                 object_error::parse_failed,
                 "section %s ended while trying to extract a stack size entry",
                 SectionName.data()),
             FileStr);
       }
       uint64_t SymValue = Data.getAddress(&Offset);
       printFunctionStackSize(Obj, SymValue, Obj->toSectionRef(FunctionELFSec),
-                             SectionName, Data, &Offset);
+                             SectionName, Data, StackSizeEntries, &Offset);
     }
   }
 }
 
 template <class ELFT>
 void DumpStyle<ELFT>::printRelocatableStackSizes(
     const ELFObjectFile<ELFT> *Obj, std::function<void()> PrintHeader) {
   const ELFFile<ELFT> *EF = Obj->getELFFile();
for (const auto &StackSizeMapEntry : StackSizeRelocMap) {
     const SectionRef FunctionSec = Obj->toSectionRef(unwrapOrError(
         this->FileName, EF->getSection(StackSizesELFSec->sh_link)));
 
     bool (*IsSupportedFn)(uint64_t);
     RelocationResolver Resolver;
     std::tie(IsSupportedFn, Resolver) = getRelocationResolver(*Obj);
     auto Contents = unwrapOrError(this->FileName, StackSizesSec.getContents());
     DataExtractor Data(Contents, Obj->isLittleEndian(), sizeof(Elf_Addr));
+    StackSizeEntryMap StackSizeEntries;
     for (const RelocationRef &Reloc : RelocSec.relocations()) {
       if (!IsSupportedFn || !IsSupportedFn(Reloc.getType()))
         reportError(createStringError(
                         object_error::parse_failed,
                         "unsupported relocation type in section %s: %s",
                         getSectionName(RelocSec).data(),
                         EF->getRelocationTypeName(Reloc.getType()).data()),
                     Obj->getFileName());
       this->printStackSize(Obj, Reloc, FunctionSec, StackSizeSectionName,
-                           Resolver, Data);
+                           Resolver, StackSizeEntries, Data);
     }
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printStackSizes(const ELFObjectFile<ELFT> *Obj) {
   bool HeaderHasBeenPrinted = false;
   auto PrintHeader = [&]() {