[llvm-readobj] Display multiple function names for stack size entries

[gbreynoo]

Summary

The current implementation of displaying .stack_size information presumes that each entry represents a single function but this is not always the case. For example with the use of ICF multiple functions can be represented with the same code, meaning that the address found in a .stack_size entry corresponds to multiple function symbols.
This change allows multiple function names to be displayed when appropriate.

[gbreynoo]

See https://bugs.llvm.org/show_bug.cgi?id=43245 which I believe was incorrectly marked as fixed, as the behaviour described in the bug ticket is still present.

I want to note here, in the case of --elf-output-style=GNU this change should not be disruptive for the usual use case in which only one function symbol corresponds to an entry. However the --elf-output-style=LLVM output requires these symbols to be displayed as a list, meaning in the usual use case a list of size one will be output for each .stack_size entry.

This change touches printBBAddrMaps due to implementation but should see no behaviour difference.

[gbreynoo]

I realise a number of other tests require updating due to the change in output, I'll fix them up once an agreement has been made regarding this change.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/stack-sizes-multiple-symbols.test

1 ↗

(On Diff #358219)

It probably makes more sense to add this test case to the existing stack-sizes.test test.

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

180

Multiple symbols with the same value is not specific to executables, so combining these test cases sounds like it risks confusion. It probably makes more sense to just take the multiple symbols case you've written in a separate file and add it to this file.

llvm/tools/llvm-readobj/ELFDumper.cpp

65

What's this for?

305–308

Make sure to clang-format new/modified code.

5814

Nit: fix all the clang-tidy warnings.

5825

Use ArrayRef for passing around vectors by reference. Same elsewhere.

5831

Use StringRef, not const std::string &.

[gbreynoo]

• Fixed a test
• Correct use of clang-tidy
• Use ArrayRef where appropriate

[gbreynoo]

I also folded the new stack-size test into the existing one as requested.

llvm/tools/llvm-readobj/ELFDumper.cpp

65

This is for use of std::accumulate

[jhenderson]

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

893–895

Use ## for comments in test files.

llvm/tools/llvm-readobj/ELFDumper.cpp

5814

Ping: this hasn't been addressed.

5831

Ping: this hasn't been addressed (nor has the adjacent clang-tidy issue).

[gbreynoo]

Apologies for the noise, I missed a filecheck prefix.

[gbreynoo]

llvm/tools/llvm-readobj/ELFDumper.cpp

5829

After some offline discussion around the inefficiency of the previous implementation, the use of join makes more sense here.

[MaskRay]

I agree that functions is more suitable. That may happen with ICF.

[jhenderson]

LGTM, with one nit.

llvm/tools/llvm-readobj/ELFDumper.cpp

65

I believe you can now remove this include?

[gbreynoo]

llvm/tools/llvm-readobj/ELFDumper.cpp

65

Good catch, I've removed it.

llvm/test/Object/BPF/yaml2obj-elf-bpf-rel.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj -r --stack-sizes %t | FileCheck %s
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section (3) .rel.text {
 # CHECK-NEXT:     0x0 R_BPF_64_64 g
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section (5) .rel.stack_sizes {
 # CHECK-NEXT:     0x0 R_BPF_64_ABS64 .text
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK:      StackSizes [
 # CHECK-NEXT:   Entry {
-# CHECK-NEXT:     Function: test
+# CHECK-NEXT:     Functions: [test]
 # CHECK-NEXT:     Size: 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB

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

 ## Check that we correctly display the contents of the .stack_sizes section
 ## in a relocatable object file.
 
 # RUN: yaml2obj --docnum=1 %s -o %t01
 # RUN: llvm-readelf --stack-sizes %t01 \
 # RUN:   | FileCheck %s --check-prefix=RELOC-GNU --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --stack-sizes %t01 | FileCheck %s --check-prefix=RELOC-LLVM
 
-#      RELOC-GNU:         Size     Function
+#      RELOC-GNU:         Size     Functions
 # RELOC-GNU-NEXT:           16     referenced_by_symbol_foo
 # RELOC-GNU-NEXT:           32     referenced_via_section_bar
 # RELOC-GNU-NEXT:            8     separate_text_section_baz
 #  RELOC-GNU-NOT:{{.}}
 
 # RELOC-LLVM:      StackSizes [
 # RELOC-LLVM-NEXT:   Entry {
-# RELOC-LLVM-NEXT:     Function: referenced_by_symbol_foo
+# RELOC-LLVM-NEXT:     Functions: [referenced_by_symbol_foo]
 # RELOC-LLVM-NEXT:     Size: 0x10
 # RELOC-LLVM-NEXT:   }
 # RELOC-LLVM-NEXT:   Entry {
-# RELOC-LLVM-NEXT:     Function: referenced_via_section_bar
+# RELOC-LLVM-NEXT:     Functions: [referenced_via_section_bar]
 # RELOC-LLVM-NEXT:     Size: 0x20
 # RELOC-LLVM-NEXT:   }
 # RELOC-LLVM-NEXT:   Entry {
-# RELOC-LLVM-NEXT:     Function: separate_text_section_baz
+# RELOC-LLVM-NEXT:     Functions: [separate_text_section_baz]
 # RELOC-LLVM-NEXT:     Size: 0x8
 # RELOC-LLVM-NEXT:   }
 # RELOC-LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB

 
 # RUN: yaml2obj --docnum=1 %s -DSYMTABOFFSET=0xffffeeee -o %t01.broken.symtab
 # RUN: llvm-readelf --stack-sizes %t01.broken.symtab 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t01.broken.symtab --check-prefix=SYMTAB-GNU --implicit-check-not=warning:
 # RUN: llvm-readobj --stack-sizes %t01.broken.symtab 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t01.broken.symtab --check-prefix=SYMTAB-LLVM --implicit-check-not=warning:
 
 # SYMTAB-GNU:      Stack Sizes:
-# SYMTAB-GNU-NEXT:          Size     Function
+# SYMTAB-GNU-NEXT:          Size     Functions
 # SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 0 in SHT_RELA section with index 5: unable to read an entry with index 3 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to read the symbol table: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-GNU-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 3
 # SYMTAB-GNU-NEXT:            16     ?
 # SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 5: unable to read an entry with index 2 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-GNU-NEXT:            32     ?
 # SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 0 in SHT_RELA section with index 6: unable to read an entry with index 1 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-GNU-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 4
 # SYMTAB-GNU-NEXT:             8     ?
 
 # SYMTAB-LLVM:      StackSizes [
 # SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 0 in SHT_RELA section with index 5: unable to read an entry with index 3 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to read the symbol table: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 3
 # SYMTAB-LLVM-NEXT:   Entry {
-# SYMTAB-LLVM-NEXT:     Function: ?
+# SYMTAB-LLVM-NEXT:     Functions: [?]
 # SYMTAB-LLVM-NEXT:     Size: 0x10
 # SYMTAB-LLVM-NEXT:   }
 # SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 5: unable to read an entry with index 2 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-LLVM-NEXT:   Entry {
-# SYMTAB-LLVM-NEXT:     Function: ?
+# SYMTAB-LLVM-NEXT:     Functions: [?]
 # SYMTAB-LLVM-NEXT:     Size: 0x20
 # SYMTAB-LLVM-NEXT:   }
 # SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 0 in SHT_RELA section with index 6: unable to read an entry with index 1 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 4
 # SYMTAB-LLVM-NEXT:   Entry {
-# SYMTAB-LLVM-NEXT:     Function: ?
+# SYMTAB-LLVM-NEXT:     Functions: [?]
 # SYMTAB-LLVM-NEXT:     Size: 0x8
 # SYMTAB-LLVM-NEXT:   }
 # SYMTAB-LLVM-NEXT: ]
 
 ## In this case we have a function symbol with an invalid section index.
 ## Document what we dump.
 
 # RUN: yaml2obj --docnum=1 %s -DSEC1="<none>" -DSEC1INDEX=0xFF -o %t01.broken.sym
 # RUN: llvm-readelf --stack-sizes %t01.broken.sym 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t01.broken.sym --check-prefix=SYM-GNU --implicit-check-not=warning:
 # RUN: llvm-readobj --stack-sizes %t01.broken.sym 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t01.broken.sym --check-prefix=SYM-LLVM --implicit-check-not=warning:
 
 # SYM-GNU:      Stack Sizes:
-# SYM-GNU-NEXT:          Size     Function
+# SYM-GNU-NEXT:          Size     Functions
 # SYM-GNU-NEXT: warning: '[[FILE]]': unable to get address of symbol 'separate_text_section_baz': invalid section index: 255
 # SYM-GNU-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 3
 # SYM-GNU-NEXT:            16     ?
 # SYM-GNU-NEXT:            32     ?
 # SYM-GNU-NEXT: warning: '[[FILE]]': cannot identify the section for relocation symbol 'separate_text_section_baz': invalid section index: 255
 # SYM-GNU-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 4
 # SYM-GNU-NEXT:             8     ?
 
 # SYM-LLVM:      StackSizes [
 # SYM-LLVM-NEXT: warning: '[[FILE]]': unable to get address of symbol 'separate_text_section_baz': invalid section index: 255
 # SYM-LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 3
 # SYM-LLVM-NEXT:   Entry {
-# SYM-LLVM-NEXT:     Function: ?
+# SYM-LLVM-NEXT:     Functions: [?]
 # SYM-LLVM-NEXT:     Size: 0x10
 # SYM-LLVM-NEXT:   }
 # SYM-LLVM-NEXT:   Entry {
-# SYM-LLVM-NEXT:     Function: ?
+# SYM-LLVM-NEXT:     Functions: [?]
 # SYM-LLVM-NEXT:     Size: 0x20
 # SYM-LLVM-NEXT:   }
 # SYM-LLVM-NEXT: warning: '[[FILE]]': cannot identify the section for relocation symbol 'separate_text_section_baz': invalid section index: 255
 # SYM-LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 4
 # SYM-LLVM-NEXT:   Entry {
-# SYM-LLVM-NEXT:     Function: ?
+# SYM-LLVM-NEXT:     Functions: [?]
 # SYM-LLVM-NEXT:     Size: 0x8
 # SYM-LLVM-NEXT:   }
 # SYM-LLVM-NEXT: ]
 
 ## Check that we correctly report the stack sizes in an executable (non-relocatable)
 ## object file. This also shows that the sh_link field is ignored in this situation
 ## without warning.
 
 # RUN: yaml2obj --docnum=2 %s -o %t02
 # RUN: llvm-readelf --stack-sizes %t02 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=EXEC-GNU --strict-whitespace \
 # RUN:                  --match-full-lines --implicit-check-not=warning:
 # RUN: llvm-readobj --stack-sizes %t02 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=EXEC-LLVM --implicit-check-not=warning:
 
-#      EXEC-GNU:         Size     Function
+#      EXEC-GNU:         Size     Functions
 # EXEC-GNU-NEXT:           16     other
 # EXEC-GNU-NEXT:           32     other_end
 # EXEC-GNU-NEXT:           48     bar
 #  EXEC-GNU-NOT:{{.}}
 
 # EXEC-LLVM:      StackSizes [
 # EXEC-LLVM-NEXT:   Entry {
-# EXEC-LLVM-NEXT:     Function: other
+# EXEC-LLVM-NEXT:     Functions: [other]
 # EXEC-LLVM-NEXT:     Size: 0x10
 # EXEC-LLVM-NEXT:   }
 # EXEC-LLVM-NEXT:   Entry {
-# EXEC-LLVM-NEXT:     Function: other_end
+# EXEC-LLVM-NEXT:     Functions: [other_end]
 # EXEC-LLVM-NEXT:     Size: 0x20
 # EXEC-LLVM-NEXT:   }
 # EXEC-LLVM-NEXT:   Entry {
-# EXEC-LLVM-NEXT:     Function: bar
+# EXEC-LLVM-NEXT:     Functions: [bar]
 # EXEC-LLVM-NEXT:     Size: 0x30
 # EXEC-LLVM-NEXT:   }
 # EXEC-LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
- Name:    undefined
     Type:    STT_FUNC
     Binding: STB_GLOBAL
   ## sh_link of .stack_sizes is ignored for non-reloctable objects.
   - Name:    other
     Section: .text
     Value:   0
     Type:    STT_FUNC
     Binding: STB_GLOBAL
-  ## If two symbols have the same value, the first is picked, regardless of
-  ## the sh_link value of the .stack_sizes section.
   - Name:    other_end
     Section: .text
     Value:   0x10
     Type:    STT_FUNC
     Binding: STB_GLOBAL
-  - Name:    foo
-    Section: .text2
-    Value:   0x10
-    Type:    STT_FUNC
-    Binding: STB_GLOBAL
   - Name:    bar
     Section: .text2
     Value:   0x20
     Type:    STT_FUNC
     Binding: STB_GLOBAL
 
 ## Check that we report a warning when we find relocations whose offsets point outside
 ## of the .stack_sizes section.
 
 # RUN: yaml2obj --docnum=3 %s -o %t03
 # RUN: llvm-readelf --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT-GNU -DFILE=%t03
 # RUN: llvm-readobj --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT-LLVM -DFILE=%t03
 
 # SHORT-GNU:      Stack Sizes:
-# SHORT-GNU-NEXT:  Size     Function
+# SHORT-GNU-NEXT:  Size     Functions
 # SHORT-GNU-NEXT:     8     foo
 # SHORT-GNU-NEXT: warning: '[[FILE]]': found invalid relocation offset (0x1) into SHT_PROGBITS section with index 2 while trying to extract a stack size entry
 # SHORT-GNU-NEXT:     8     foo
 
 # SHORT-LLVM:     StackSizes [
 # SHORT-LLVM-NEXT:   Entry {
-# SHORT-LLVM-NEXT:     Function: foo
+# SHORT-LLVM-NEXT:     Functions: [foo]
 # SHORT-LLVM-NEXT:     Size: 0x8
 # SHORT-LLVM-NEXT:   }
 # SHORT-LLVM-NEXT: warning: '[[FILE]]': found invalid relocation offset (0x1) into SHT_PROGBITS section with index 2 while trying to extract a stack size entry
 # SHORT-LLVM-NEXT:   Entry {
-# SHORT-LLVM-NEXT:     Function: foo
+# SHORT-LLVM-NEXT:     Functions: [foo]
 # SHORT-LLVM-NEXT:     Size: 0x8
 # SHORT-LLVM-NEXT:   }
 # SHORT-LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB

 # RUN: llvm-readelf --stack-sizes %t04 2> %t04-gnu.err | FileCheck %s --check-prefix=WRONGSECTION-GNU
 # RUN: FileCheck %s < %t04-gnu.err --check-prefix=WRONGSECTION-ERR -DFILE=%t04
 # RUN: llvm-readobj --stack-sizes %t04 2> %t04-llvm.err | FileCheck %s --check-prefix=WRONGSECTION-LLVM
 # RUN: FileCheck %s < %t04-llvm.err --check-prefix=WRONGSECTION-ERR -DFILE=%t04
 
 # RUN: llvm-readelf --stack-sizes --demangle %t04 2>&1 | FileCheck %s --check-prefix=WRONGSECTION-DEMANGLE-ERR -DFILE=%t04
 # RUN: llvm-readobj --stack-sizes --demangle %t04 2>&1 | FileCheck %s --check-prefix=WRONGSECTION-DEMANGLE-ERR -DFILE=%t04
 
-# WRONGSECTION-GNU:      Size Function
+# WRONGSECTION-GNU:      Size Functions
 # WRONGSECTION-GNU-NEXT: 8 _Z3foof
 
 # WRONGSECTION-LLVM:      StackSizes [
 # WRONGSECTION-LLVM-NEXT:   Entry {
-# WRONGSECTION-LLVM-NEXT:     Function: _Z3foof
+# WRONGSECTION-LLVM-NEXT:     Functions: [_Z3foof]
 # WRONGSECTION-LLVM-NEXT:     Size: 0x8
 # WRONGSECTION-LLVM-NEXT:   }
 # WRONGSECTION-LLVM-NEXT: ]
 
 # WRONGSECTION-ERR:           warning: '[[FILE]]': relocation symbol '_Z3foof' is not in the expected section
 # WRONGSECTION-DEMANGLE-ERR:  warning: '[[FILE]]': relocation symbol 'foo(float)' is not in the expected section
 
 --- !ELF

 
 # RUN: yaml2obj --docnum=5 %s -o %t05
 # RUN: llvm-readelf --stack-sizes %t05 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=SUDDENEND-GNU -DFILE=%t05
 # RUN: llvm-readobj --stack-sizes %t05 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=SUDDENEND-LLVM -DFILE=%t05
 
 # SUDDENEND-GNU:      Stack Sizes:
-# SUDDENEND-GNU-NEXT:  Size     Function
+# SUDDENEND-GNU-NEXT:  Size     Functions
 # SUDDENEND-GNU-NEXT:     8     foo
 # SUDDENEND-GNU-NEXT: warning: '[[FILE]]': SHT_PROGBITS section with index 2 ended while trying to extract a stack size entry
 # SUDDENEND-GNU-NEXT:     8     foo
 # SUDDENEND-GNU-NEXT: warning: '[[FILE]]': SHT_PROGBITS section with index 3 ended while trying to extract a stack size entry
 
 # SUDDENEND-LLVM:      StackSizes [
 # SUDDENEND-LLVM-NEXT:   Entry {
-# SUDDENEND-LLVM-NEXT:     Function: foo
+# SUDDENEND-LLVM-NEXT:     Functions: [foo]
 # SUDDENEND-LLVM-NEXT:     Size: 0x8
 # SUDDENEND-LLVM-NEXT:   }
 # SUDDENEND-LLVM-NEXT: warning: '[[FILE]]': SHT_PROGBITS section with index 2 ended while trying to extract a stack size entry
 # SUDDENEND-LLVM-NEXT:   Entry {
-# SUDDENEND-LLVM-NEXT:     Function: foo
+# SUDDENEND-LLVM-NEXT:     Functions: [foo]
 # SUDDENEND-LLVM-NEXT:     Size: 0x8
 # SUDDENEND-LLVM-NEXT:   }
 # SUDDENEND-LLVM-NEXT: warning: '[[FILE]]': SHT_PROGBITS section with index 3 ended while trying to extract a stack size entry
 # SUDDENEND-LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64

 
 # RUN: yaml2obj --docnum=7 %s -o %t07
 # RUN: llvm-readelf --stack-sizes %t07 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t07 --check-prefix=BADSECTION-OUT-GNU --implicit-check-not=warning:
 # RUN: llvm-readobj --stack-sizes %t07 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t07 --check-prefix=BADSECTION-OUT-LLVM --implicit-check-not=warning:
 
 # BADSECTION-OUT-GNU:      Stack Sizes:
-# BADSECTION-OUT-GNU-NEXT:          Size     Function
+# BADSECTION-OUT-GNU-NEXT:          Size     Functions
 # BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': cannot identify the section for relocation symbol '_Z3foof': invalid section index: 10
 # BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': unable to get address of symbol '_Z3foof': invalid section index: 10
 # BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 2
 # BADSECTION-OUT-GNU-NEXT:             8     ?
 # BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 3: unable to read an entry with index 255 from SHT_SYMTAB section with index 4: can't read an entry at 0x17e8: it goes past the end of the section (0x30)
 # BADSECTION-OUT-GNU-NEXT:            22     ?
 # BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 3: unable to read an entry with index 255 from SHT_SYMTAB section with index 4: can't read an entry at 0x17e8: it goes past the end of the section (0x30)
 # BADSECTION-OUT-GNU-NEXT:            36     ?
 
 # BADSECTION-OUT-LLVM:      StackSizes [
 # BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': cannot identify the section for relocation symbol '_Z3foof': invalid section index: 10
 # BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': unable to get address of symbol '_Z3foof': invalid section index: 10
 # BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 2
 # BADSECTION-OUT-LLVM-NEXT:   Entry {
-# BADSECTION-OUT-LLVM-NEXT:     Function: ?
+# BADSECTION-OUT-LLVM-NEXT:     Functions: [?]
 # BADSECTION-OUT-LLVM-NEXT:     Size: 0x8
 # BADSECTION-OUT-LLVM-NEXT:   }
 # BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 3: unable to read an entry with index 255 from SHT_SYMTAB section with index 4: can't read an entry at 0x17e8: it goes past the end of the section (0x30)
 # BADSECTION-OUT-LLVM-NEXT:   Entry {
-# BADSECTION-OUT-LLVM-NEXT:     Function: ?
+# BADSECTION-OUT-LLVM-NEXT:     Functions: [?]
 # BADSECTION-OUT-LLVM-NEXT:     Size: 0x16
 # BADSECTION-OUT-LLVM-NEXT:   }
 # BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 3: unable to read an entry with index 255 from SHT_SYMTAB section with index 4: can't read an entry at 0x17e8: it goes past the end of the section (0x30)
 # BADSECTION-OUT-LLVM-NEXT:   Entry {
-# BADSECTION-OUT-LLVM-NEXT:     Function: ?
+# BADSECTION-OUT-LLVM-NEXT:     Functions: [?]
 # BADSECTION-OUT-LLVM-NEXT:     Size: 0x24
 # BADSECTION-OUT-LLVM-NEXT:   }
 # BADSECTION-OUT-LLVM-NEXT: ]
 
 # RUN: llvm-readelf --stack-sizes --demangle %t07 2>&1 | FileCheck %s --check-prefix=BADSECTION-DEMANGLE-ERR -DFILE=%t07
 # RUN: llvm-readobj --stack-sizes --demangle %t07 2>&1 | FileCheck %s --check-prefix=BADSECTION-DEMANGLE-ERR -DFILE=%t07
 
 # BADSECTION-DEMANGLE-ERR: warning: '[[FILE]]': cannot identify the section for relocation symbol 'foo(float)'

 ## a corresponding relocation section.
 
 # RUN: yaml2obj --docnum=8 %s -o %t08
 # RUN: llvm-readelf --stack-sizes %t08 2> %t08-gnu.err | FileCheck %s --check-prefix=NORELOCSECTION-OUT-GNU
 # RUN: FileCheck %s < %t08-gnu.err --check-prefix=NORELOCSECTION-ERR -DFILE=%t08
 # RUN: llvm-readobj --stack-sizes %t08 2> %t08-llvm.err | FileCheck %s --check-prefix=NORELOCSECTION-OUT-LLVM
 # RUN: FileCheck %s < %t08-llvm.err --check-prefix=NORELOCSECTION-ERR -DFILE=%t08
 
-# NORELOCSECTION-OUT-GNU:     Size Function
+# NORELOCSECTION-OUT-GNU:     Size Functions
 # NORELOCSECTION-OUT-GNU-NOT: {{.}}
 
 # NORELOCSECTION-OUT-LLVM:      StackSizes [
 # NORELOCSECTION-OUT-LLVM-NEXT: ]
 
 # NORELOCSECTION-ERR: warning: '[[FILE]]': .stack_sizes (SHT_PROGBITS section with index 2) does not have a corresponding relocation section
 
 --- !ELF

 # RUN:   | FileCheck %s --check-prefixes=MULTIPLE-LLVM,OBJECT -DFILE1=%t01 -DFILE2=%t02
 # RUN: llvm-readobj --stack-sizes %t1.a \
 # RUN:   | FileCheck %s --check-prefixes=MULTIPLE-LLVM,ARCHIVE -DFILE=%t1.a
 
 #        OBJECT:File: [[FILE1]]
 #       ARCHIVE:File: [[FILE]]({{.*01}})
 
 #      MULTIPLE-GNU:Stack Sizes:
-# MULTIPLE-GNU-NEXT:         Size     Function
+# MULTIPLE-GNU-NEXT:         Size     Functions
 # MULTIPLE-GNU-NEXT:           16     referenced_by_symbol_foo
 # MULTIPLE-GNU-NEXT:           32     referenced_via_section_bar
 # MULTIPLE-GNU-NEXT:            8     separate_text_section_baz
 # MULTIPLE-GNU-EMPTY:
 
 # MULTIPLE-LLVM:      StackSizes [
 # MULTIPLE-LLVM-NEXT:   Entry {
-# MULTIPLE-LLVM-NEXT:     Function: referenced_by_symbol_foo
+# MULTIPLE-LLVM-NEXT:     Functions: [referenced_by_symbol_foo]
 # MULTIPLE-LLVM-NEXT:     Size: 0x10
 # MULTIPLE-LLVM-NEXT:   }
 # MULTIPLE-LLVM-NEXT:   Entry {
-# MULTIPLE-LLVM-NEXT:     Function: referenced_via_section_bar
+# MULTIPLE-LLVM-NEXT:     Functions: [referenced_via_section_bar]
 # MULTIPLE-LLVM-NEXT:     Size: 0x20
 # MULTIPLE-LLVM-NEXT:   }
 # MULTIPLE-LLVM-NEXT:   Entry {
-# MULTIPLE-LLVM-NEXT:     Function: separate_text_section_baz
+# MULTIPLE-LLVM-NEXT:     Functions: [separate_text_section_baz]
 # MULTIPLE-LLVM-NEXT:     Size: 0x8
 # MULTIPLE-LLVM-NEXT:   }
 # MULTIPLE-LLVM-NEXT: ]
 
 #        OBJECT:File: [[FILE2]]
 #       ARCHIVE:File: [[FILE]]({{.*02}})
 
 # MULTIPLE-GNU-EMPTY:
 # MULTIPLE-GNU-NEXT:Stack Sizes:
-# MULTIPLE-GNU-NEXT:         Size     Function
+# MULTIPLE-GNU-NEXT:         Size     Functions
 # MULTIPLE-GNU-NEXT:           16     other
 # MULTIPLE-GNU-NEXT:           32     other_end
 # MULTIPLE-GNU-NEXT:           48     bar
 
 # MULTIPLE-LLVM:      StackSizes [
 # MULTIPLE-LLVM-NEXT:   Entry {
-# MULTIPLE-LLVM-NEXT:     Function: other
+# MULTIPLE-LLVM-NEXT:     Functions: [other]
 # MULTIPLE-LLVM-NEXT:     Size: 0x10
 # MULTIPLE-LLVM-NEXT:   }
 # MULTIPLE-LLVM-NEXT:   Entry {
-# MULTIPLE-LLVM-NEXT:     Function: other_end
+# MULTIPLE-LLVM-NEXT:     Functions: [other_end]
 # MULTIPLE-LLVM-NEXT:     Size: 0x20
 # MULTIPLE-LLVM-NEXT:   }
 # MULTIPLE-LLVM-NEXT:   Entry {
-# MULTIPLE-LLVM-NEXT:     Function: bar
+# MULTIPLE-LLVM-NEXT:     Functions: [bar]
 # MULTIPLE-LLVM-NEXT:     Size: 0x30
 # 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 -o %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
 # RUN: llvm-readobj --stack-sizes %t14 2> %t14-llvm.err | FileCheck %s --check-prefix=NONFUNCTIONSYM-LLVM
 # RUN: FileCheck %s < %t14-llvm.err --check-prefix=NONFUNCTIONSYM-ERR -DFILE=%t14
 
 # NONFUNCTIONSYM-GNU:     Stack Sizes:
 # NONFUNCTIONSYM-GNU:     0 ?
 
 # NONFUNCTIONSYM-LLVM:      StackSizes [
 # NONFUNCTIONSYM-LLVM-NEXT:   Entry {
-# NONFUNCTIONSYM-LLVM-NEXT:     Function: ?
+# NONFUNCTIONSYM-LLVM-NEXT:     Functions: [?]
 # NONFUNCTIONSYM-LLVM-NEXT:     Size: 0x0
 # NONFUNCTIONSYM-LLVM-NEXT:   }
 # NONFUNCTIONSYM-LLVM-NEXT: ]
 
 # NONFUNCTIONSYM-ERR: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 2
 
 --- !ELF
 FileHeader:

 ## Check that we report a warning when we find an unsupported relocation
 ## in the section that contains the stack size entries' relocations.
 
 # RUN: yaml2obj --docnum=10 %s -o %t15
 # RUN: llvm-readelf --stack-sizes %t15 2>&1 | FileCheck %s --check-prefix=UNSUPPRELOC-GNU -DFILE=%t15
 # RUN: llvm-readobj --stack-sizes %t15 2>&1 | FileCheck %s --check-prefix=UNSUPPRELOC-LLVM -DFILE=%t15
 
 # UNSUPPRELOC-GNU:      Stack Sizes:
-# UNSUPPRELOC-GNU-NEXT:   Size     Function
+# UNSUPPRELOC-GNU-NEXT:   Size     Functions
 # UNSUPPRELOC-GNU-NEXT: warning: '[[FILE]]': SHT_RELA section with index 3 contains an unsupported relocation with index 0: R_X86_64_RELATIVE
 # UNSUPPRELOC-GNU-NEXT:      0     foo
 # UNSUPPRELOC-GNU-NEXT: warning: '[[FILE]]': SHT_RELA section with index 3 contains an unsupported relocation with index 2: R_X86_64_RELATIVE
 
 # UNSUPPRELOC-LLVM:      StackSizes [
 # UNSUPPRELOC-LLVM-NEXT: warning: '[[FILE]]': SHT_RELA section with index 3 contains an unsupported relocation with index 0: R_X86_64_RELATIVE
 # UNSUPPRELOC-LLVM-NEXT:   Entry {
-# UNSUPPRELOC-LLVM-NEXT:     Function: foo
+# UNSUPPRELOC-LLVM-NEXT:     Functions: [foo]
 # UNSUPPRELOC-LLVM-NEXT:     Size: 0x0
 # UNSUPPRELOC-LLVM-NEXT:   }
 # UNSUPPRELOC-LLVM-NEXT: warning: '[[FILE]]': SHT_RELA section with index 3 contains an unsupported relocation with index 2: R_X86_64_RELATIVE
 # UNSUPPRELOC-LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64

 
 # RUN: llvm-ar rc %t2.a %t04 %t01
 # RUN: llvm-readelf --stack-sizes %t2.a 2>&1 | FileCheck %s --check-prefix=ARCHIVEWARN-GNU \
 # RUN:   -DFILE=%t2.a --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --stack-sizes %t2.a 2>&1 | FileCheck %s --check-prefix=ARCHIVEWARN-LLVM -DFILE=%t2.a
 
 #      ARCHIVEWARN-GNU:File: [[FILE]]({{.*04}})
 #      ARCHIVEWARN-GNU:Stack Sizes:
-# ARCHIVEWARN-GNU-NEXT:         Size     Function
+# ARCHIVEWARN-GNU-NEXT:         Size     Functions
 #      ARCHIVEWARN-GNU:{{.*}}: warning: '{{.*04}}': relocation symbol '_Z3foof' is not in the expected section
 #      ARCHIVEWARN-GNU:            8     _Z3foof
 #      ARCHIVEWARN-GNU:File: [[FILE]]({{.*01}})
 #      ARCHIVEWARN-GNU:Stack Sizes:
-# ARCHIVEWARN-GNU-NEXT:         Size     Function
+# ARCHIVEWARN-GNU-NEXT:         Size     Functions
 # ARCHIVEWARN-GNU-NEXT:           16     referenced_by_symbol_foo
 # ARCHIVEWARN-GNU-NEXT:           32     referenced_via_section_bar
 # ARCHIVEWARN-GNU-NEXT:            8     separate_text_section_baz
 #  ARCHIVEWARN-GNU-NOT:{{.}}
 
 
 # ARCHIVEWARN-LLVM:      File: [[FILE]]({{.*04}})
 # ARCHIVEWARN-LLVM:      StackSizes [
 # ARCHIVEWARN-LLVM:      warning: '{{.*04}}': relocation symbol '_Z3foof' is not in the expected section
 # ARCHIVEWARN-LLVM-NEXT:   Entry {
-# ARCHIVEWARN-LLVM-NEXT:     Function: _Z3foof
+# ARCHIVEWARN-LLVM-NEXT:     Functions: [_Z3foof]
 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x8
 # ARCHIVEWARN-LLVM-NEXT:   }
 # ARCHIVEWARN-LLVM-NEXT: ]
 # ARCHIVEWARN-LLVM:      File: [[FILE]]({{.*01}})
 # ARCHIVEWARN-LLVM:      StackSizes [
 # ARCHIVEWARN-LLVM-NEXT:   Entry {
-# ARCHIVEWARN-LLVM-NEXT:     Function: referenced_by_symbol_foo
+# ARCHIVEWARN-LLVM-NEXT:     Functions: [referenced_by_symbol_foo]
 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x10
 # ARCHIVEWARN-LLVM-NEXT:   }
 # ARCHIVEWARN-LLVM-NEXT:   Entry {
-# ARCHIVEWARN-LLVM-NEXT:     Function: referenced_via_section_bar
+# ARCHIVEWARN-LLVM-NEXT:     Functions: [referenced_via_section_bar]
 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x20
 # ARCHIVEWARN-LLVM-NEXT:   }
 # ARCHIVEWARN-LLVM-NEXT:   Entry {
-# ARCHIVEWARN-LLVM-NEXT:     Function: separate_text_section_baz
+# ARCHIVEWARN-LLVM-NEXT:     Functions: [separate_text_section_baz]
 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x8
 # ARCHIVEWARN-LLVM-NEXT:   }
 # ARCHIVEWARN-LLVM-NEXT: ]
 
 ## Check that we demangle function names when requested.
 
 # RUN: yaml2obj --docnum=11 %s -o %t16
 # RUN: llvm-readelf --stack-sizes --demangle %t16 | FileCheck %s --check-prefix=DEMANGLE-GNU
 # RUN: llvm-readobj --stack-sizes --demangle %t16 | FileCheck %s --check-prefix=DEMANGLE-LLVM
 
 # DEMANGLE-GNU:  16 foo(float)
-# DEMANGLE-LLVM: Function: foo(float)
+# DEMANGLE-LLVM: Functions: [foo(float)]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:    .text
- Name: .rela.stack_sizes
     Link: 0
     Info: 0xFF
     Relocations: []
   - Name: .rela.stack_sizes (1)
     Type: SHT_RELA
     Link: 0
     Info: 0xFF
     Relocations: []
+    
+## Check that that we see multiple symbols output in cases when multiple symbols
+## share the same stack size entry, for example when use of ICF means two functions
+## are represented by the same code.
+    
+# RUN: yaml2obj --docnum=14 %s -o %t19
+# RUN: llvm-readelf --stack-sizes %t19 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=MULTIPLE-SYMBOLS-GNU
+# RUN: llvm-readobj --stack-sizes %t19 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=MULTIPLE-SYMBOLS-LLVM
+
+#      GNU:         Size     Functions
+# MULTIPLE-SYMBOLS-GNU:           16     foo, bar
+# MULTIPLE-SYMBOLS-GNU-NOT:{{.}}
+
+# MULTIPLE-SYMBOLS-LLVM:      StackSizes [
+# MULTIPLE-SYMBOLS-LLVM-NEXT:   Entry {
+# MULTIPLE-SYMBOLS-LLVM-NEXT:     Functions: [foo, bar]
+# MULTIPLE-SYMBOLS-LLVM-NEXT:     Size: 0x10
+# MULTIPLE-SYMBOLS-LLVM-NEXT:   }
+# MULTIPLE-SYMBOLS-LLVM-NEXT: ]
+# MULTIPLE-SYMBOLS-LLVM-NOT:{{.}}
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:    .text
+    Type:    SHT_PROGBITS
+    Flags:   [SHF_ALLOC]
+    Size:    16
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Entries:
+      - Address: 0x0
+        Size:    0x10
+    Link:    .text
+Symbols:
+  - Name:    foo
+    Section: .text
+    Value:   0x0
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+  - Name:    bar
+    Section: .text
+    Value:   0x0
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL

llvm/tools/llvm-readobj/ELFDumper.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <iterator>
 #include <memory>
+#include <numeric>
 #include <string>
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace ELF;
 
getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab,
                   StringRef *StrTab, const Elf_Shdr **SymTabSec) const;
   StringRef getPrintableSectionName(const Elf_Shdr &Sec) const;
 
   std::vector<GroupSection> getGroups();
 
   // Returns the function symbol index for the given address. Matches the
   // symbol's section with FunctionSec when specified.
   // Returns None if no function symbol can be found for the address or in case
   // it is not defined in the specified section.
-  Optional<uint32_t>
-  getSymbolIndexForFunctionAddress(uint64_t SymValue,
+  SmallVector<uint32_t>
+  getSymbolIndexesForFunctionAddress(uint64_t SymValue,
                                      Optional<const Elf_Shdr *> FunctionSec);
   bool printFunctionStackSize(uint64_t SymValue,
                               Optional<const Elf_Shdr *> FunctionSec,
                               const Elf_Shdr &StackSizeSec, DataExtractor Data,
                               uint64_t *Offset);
   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;
+  virtual void printStackSizeEntry(uint64_t Size,
+                                   ArrayRef<std::string> FuncNames) = 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,
private:
 
   std::string getSymbolSectionNdx(const Elf_Sym &Symbol, unsigned SymIndex,
                                   DataRegion<Elf_Word> ShndxTable) const;
   void printProgramHeaders() override;
   void printSectionMapping() override;
   void printGNUVersionSectionProlog(const typename ELFT::Shdr &Sec,
                                     const Twine &Label, unsigned EntriesNum);
 
-  void printStackSizeEntry(uint64_t Size, StringRef FuncName) override;
+  void printStackSizeEntry(uint64_t Size,
+                           ArrayRef<std::string> FuncNames) override;
 
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsABIFlags() override;
 };
 
 template <typename ELFT> class LLVMELFDumper : public ELFDumper<ELFT> {
 public:
private:
   void printSymbolSection(const Elf_Sym &Symbol, unsigned SymIndex,
                           DataRegion<Elf_Word> ShndxTable) const;
   void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
                    DataRegion<Elf_Word> ShndxTable,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool /*NonVisibilityBitsUsed*/) const override;
   void printProgramHeaders() override;
   void printSectionMapping() override {}
-  void printStackSizeEntry(uint64_t Size, StringRef FuncName) override;
+  void printStackSizeEntry(uint64_t Size,
+                           ArrayRef<std::string> FuncNames) override;
 
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsABIFlags() override;
 
   ScopedPrinter &W;
 };
 
template <class ELFT> void GNUELFDumper<ELFT>::printDependentLibs() {
   };
 
   this->printDependentLibsHelper(OnSectionStart, OnLibEntry);
   if (SectionStarted)
     PrintSection();
 }
 
 template <class ELFT>
-Optional<uint32_t> ELFDumper<ELFT>::getSymbolIndexForFunctionAddress(
+SmallVector<uint32_t> ELFDumper<ELFT>::getSymbolIndexesForFunctionAddress(
     uint64_t SymValue, Optional<const Elf_Shdr *> FunctionSec) {
+  SmallVector<uint32_t> SymbolIndexes;
   if (!this->AddressToIndexMap.hasValue()) {
     // Populate the address to index map upon the first invocation of this
     // function.
     this->AddressToIndexMap.emplace();
     if (this->DotSymtabSec) {
       if (Expected<Elf_Sym_Range> SymsOrError =
               Obj.symbols(this->DotSymtabSec)) {
         uint32_t Index = (uint32_t)-1;
         for (const Elf_Sym &Sym : *SymsOrError) {
           ++Index;
 
           if (Sym.st_shndx == ELF::SHN_UNDEF || Sym.getType() != ELF::STT_FUNC)
             continue;
 
           Expected<uint64_t> SymAddrOrErr =
               ObjF.toSymbolRef(this->DotSymtabSec, Index).getAddress();
           if (!SymAddrOrErr) {
             std::string Name = this->getStaticSymbolName(Index);
             reportUniqueWarning("unable to get address of symbol '" + Name +
                                 "': " + toString(SymAddrOrErr.takeError()));
-            return None;
+            return SymbolIndexes;
           }
 
           (*this->AddressToIndexMap)[*SymAddrOrErr].push_back(Index);
         }
       } else {
         reportUniqueWarning("unable to read the symbol table: " +
                             toString(SymsOrError.takeError()));
       }
     }
   }
 
   auto Symbols = this->AddressToIndexMap->find(SymValue);
   if (Symbols == this->AddressToIndexMap->end())
-    return None;
+    return SymbolIndexes;
 
   for (uint32_t Index : Symbols->second) {
     // Check if the symbol is in the right section. FunctionSec == None
     // means "any section".
     if (FunctionSec) {
       const Elf_Sym &Sym = *cantFail(Obj.getSymbol(this->DotSymtabSec, Index));
       if (Expected<const Elf_Shdr *> SecOrErr =
               Obj.getSection(Sym, this->DotSymtabSec,
                              this->getShndxTable(this->DotSymtabSec))) {
         if (*FunctionSec != *SecOrErr)
           continue;
       } else {
         std::string Name = this->getStaticSymbolName(Index);
         // Note: it is impossible to trigger this error currently, it is
         // untested.
         reportUniqueWarning("unable to get section of symbol '" + Name +
                             "': " + toString(SecOrErr.takeError()));
-        return None;
+        return SymbolIndexes;
       }
     }
 
-    return Index;
+    SymbolIndexes.push_back(Index);
   }
-  return None;
+
+  return SymbolIndexes;
 }
 
 template <class ELFT>
 bool ELFDumper<ELFT>::printFunctionStackSize(
     uint64_t SymValue, Optional<const Elf_Shdr *> FunctionSec,
     const Elf_Shdr &StackSizeSec, DataExtractor Data, uint64_t *Offset) {
-  Optional<uint32_t> FuncSymIndex =
-      this->getSymbolIndexForFunctionAddress(SymValue, FunctionSec);
-  std::string FuncName = "?";
-  if (!FuncSymIndex)
+  SmallVector<uint32_t> FuncSymIndexes =
+      this->getSymbolIndexesForFunctionAddress(SymValue, FunctionSec);
+  if (FuncSymIndexes.empty())
     reportUniqueWarning(
         "could not identify function symbol for stack size entry in " +
         describe(StackSizeSec));
-  else
-    FuncName = this->getStaticSymbolName(*FuncSymIndex);
 
   // Extract the size. The expectation is that Offset is pointing to the right
   // place, i.e. past the function address.
   Error Err = Error::success();
   uint64_t StackSize = Data.getULEB128(Offset, &Err);
   if (Err) {
     reportUniqueWarning("could not extract a valid stack size from " +
                         describe(StackSizeSec) + ": " +
                         toString(std::move(Err)));
     return false;
   }
-  printStackSizeEntry(StackSize, FuncName);
+
+  if (FuncSymIndexes.empty()) {
+    printStackSizeEntry(StackSize, {"?"});
+  } else {
+    SmallVector<std::string> FuncSymNames;
+    for (uint32_t Index : FuncSymIndexes)
+      FuncSymNames.push_back(this->getStaticSymbolName(Index));
+    printStackSizeEntry(StackSize, FuncSymNames);
+  }
+
   return true;
 }
 
 template <class ELFT>
 void GNUELFDumper<ELFT>::printStackSizeEntry(uint64_t Size,
-                                             StringRef FuncName) {
+                                             ArrayRef<std::string> FuncNames) {
   OS.PadToColumn(2);
   OS << format_decimal(Size, 11);
   OS.PadToColumn(18);
-  OS << FuncName << "\n";
+
+  std::string AllNames = std::accumulate(
+      std::next(FuncNames.begin()), FuncNames.end(), FuncNames.front(),
+      [](StringRef AllNames, StringRef FuncNames) {
+        return AllNames.str() + ", " + FuncNames.str();
+      });
+
+  OS << AllNames << "\n";
 }
 
 template <class ELFT>
 void ELFDumper<ELFT>::printStackSize(const Relocation<ELFT> &R,
                                      const Elf_Shdr &RelocSec, unsigned Ndx,
                                      const Elf_Shdr *SymTab,
                                      const Elf_Shdr *FunctionSec,
                                      const Elf_Shdr &StackSizeSec,
void GNUELFDumper<ELFT>::printStackSizes() {
   bool HeaderHasBeenPrinted = false;
   auto PrintHeader = [&]() {
     if (HeaderHasBeenPrinted)
       return;
     OS << "\nStack Sizes:\n";
     OS.PadToColumn(9);
     OS << "Size";
     OS.PadToColumn(18);
-    OS << "Function\n";
+    OS << "Functions\n";
     HeaderHasBeenPrinted = true;
   };
 
   // For non-relocatable objects, look directly for sections whose name starts
   // with .stack_sizes and process the contents.
   if (this->Obj.getHeader().e_type == ELF::ET_REL)
     this->printRelocatableStackSizes(PrintHeader);
   else
for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
     if (!BBAddrMapOrErr) {
       this->reportUniqueWarning("unable to dump " + this->describe(Sec) + ": " +
                                 toString(BBAddrMapOrErr.takeError()));
       continue;
     }
     for (const Elf_BBAddrMap &AM : *BBAddrMapOrErr) {
       DictScope D(W, "Function");
       W.printHex("At", AM.Addr);
-      Optional<uint32_t> FuncSymIndex =
-          this->getSymbolIndexForFunctionAddress(AM.Addr, FunctionSec);
+      SmallVector<uint32_t> FuncSymIndex =
+          this->getSymbolIndexesForFunctionAddress(AM.Addr, FunctionSec);
       std::string FuncName = "<?>";
-      if (FuncSymIndex == None)
+      if (FuncSymIndex.empty())
         this->reportUniqueWarning(
             "could not identify function symbol for address (0x" +
             Twine::utohexstr(AM.Addr) + ") in " + this->describe(Sec));
       else
-        FuncName = this->getStaticSymbolName(*FuncSymIndex);
+        FuncName = this->getStaticSymbolName(FuncSymIndex.front());
       W.printString("Name", FuncName);
 
       ListScope L(W, "BB entries");
       for (const typename Elf_BBAddrMap::BBEntry &BBE : AM.BBEntries) {
         DictScope L(W);
         W.printHex("Offset", BBE.Offset);
         W.printHex("Size", BBE.Size);
         W.printBoolean("HasReturn", BBE.HasReturn);
template <class ELFT> void LLVMELFDumper<ELFT>::printStackSizes() {
   ListScope L(W, "StackSizes");
   if (this->Obj.getHeader().e_type == ELF::ET_REL)
     this->printRelocatableStackSizes([]() {});
   else
     this->printNonRelocatableStackSizes([]() {});
 }
 
 template <class ELFT>
-void LLVMELFDumper<ELFT>::printStackSizeEntry(uint64_t Size, StringRef FuncName) {
+void LLVMELFDumper<ELFT>::printStackSizeEntry(uint64_t Size,
+                                              ArrayRef<std::string> FuncNames) {
   DictScope D(W, "Entry");
-  W.printString("Function", FuncName);
+  W.printList("Functions", FuncNames);
   W.printHex("Size", Size);
 }
 
 template <class ELFT>
 void LLVMELFDumper<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) {
   auto PrintEntry = [&](const Elf_Addr *E) {
     W.printHex("Address", Parser.getGotAddress(E));
     W.printNumber("Access", Parser.getGotOffset(E));