[llvm-readelf] Dump the stack sizes sections with --stack-sizes

[wolfgangp]

Summary

This is a GNU-style implementation of the --stack-sizes option. It dumps the stack sizes sections in the format
StackSizes:

Size        Function

<Stacksize> <FunctionName>

...                      ...

LLVM style dumping is not implemented yet.

[grimar]

The first comments are below.

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

31

This needs a comment I think, i.e. what does this content describe.

41

##

114

You do not need the last line.
We usually either separate the comment from RUN: with just an empry line (though sometimes not, just be consistent).

164

Please align like you did above.

187

Do you need section symbol?

287

##

296

We usually use 2>&1. I am not sure it worth to chech the output separatelly here.

324

I'd expect to see "# MULTIPLE:" lines right here. You can probably test ARCHIVE just separatelly.

360

Again, probably I'd not test errors separatelly. (i.e. would use 2>&1)

393

Add a description?

396

Perhaps you should print the relocation name too.

llvm/tools/llvm-readobj/ELFDumper.cpp

4324

This looks worrying. Why do you need this?

4343

This probably need a test (I think I didn't see one for testing demangled names)

4345

Why?

4387

Why?

4407

Why?

4425

This method is very long. If there is any way to make it shorter, that would be great.

4442

Seems you can use ELFObjectFile::toDRI() to hide work with DRI.p and move this out to make it static helper probably?

4495

Its a bit strange to see using here. You use SectionMap only once
and it is not common do do in the missle of function I think.
I'd just remove.

4559

Supports probably not a very good name for function. May be IsSupportedFn?

5460

I think it worth adding the llvm-readobj calls to your test case too. So that it will be visible what result we have and what is the place to change when we implement this.

[grimar]

llvm/tools/llvm-readobj/ELFDumper.cpp

4495

"do do in the missle of function" -> "to do in the middle of function"

[wolfgangp]

• Undertook some refactoring of the change with the following motivation: The printStackSize* methods do mostly extracting and validating, printing the output is only a minor part. Yet they were methods of the GNUStyle class, which would have made it more difficult to implement LLVM style dumping. So I moved them mostly into the base class (DumpStyle), and delegated the printing mostly to a new method printStackSizeEntry(), which is style specific.
• Addressed the formatting comments
• Added 2 test cases (demangling and verifiying the 'not implemented' message we get from llvm-readobj.
• Explained the rationale using consumeError().

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

187

No, it's not needed.

296

It was suggested by a different reviewer to check the output as well. If you do not feel strongly about it, I would like to keep it in place.

324

I collapsed the 2 test cases and removed some unnecessary yaml2obj invocations.
I'd like to intertwine the ARCHIVE and MULTIPLE check lines to check the proper
ordering. Please let me know if that's OK.

360

Testing the output separately was suggested by someone else. Please let me know if you feel strongly about it.

llvm/tools/llvm-readobj/ELFDumper.cpp

4324

I am scanning the symbol table to figure out which function symbol the stack size entry corresponds to. Symbol.getAddress() returns an 'Expected', which means that it may possibly return an error. I need to test the Expected and once I do that, and an error has been returned, the 'Expected' interface mandates that we do something with this error, i.e. either report it (by calling takeError()) or ignore it (by calling consumeError()). If we don't do that, the 'Expected' destructor asserts and we get a compiler crash.

As far as choosing whether to report or consume the error, I have decided that unless the error is directly related to stack size dumping, I would rather ignore it and leave the reporting to other aspects of dumping, e.g. when explicitly dumping the symbol table. Hence the consumeError() here.

This also goes for all the other occurrences of consumeError().

4345

Please see my comment above.

4387

Please see my comment above.

4407

Please see my comment above.

4425

This morphed into a somewhat larger refactoring. I will explain this in detail in the commit message.

4442

I extracted it into a helper due to the refactoring, but unfortunately ELFObjectFile::toDRI() is protected, so I can't use it here. Now, this could be refactored, but I don't want to lump it into the same patch.

4559

But it's so cool to be able to say

if (Supports(...))

Well, if you insist...

[rupprecht]

I'm not familiar with the .stack_sizes functionality in general, but it seems useful & could have saved me countless hours of debugging (large stack frames => stack overflows in recursive parsers) if I knew more about how it worked.

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

9–13

Out of curiousity, how did you decide on this format? Does this number of columns line up with other readelf options? (There is no GNU readelf --stack-size option I'm aware of that this could be emulating).

llvm/tools/llvm-readobj/ELFDumper.cpp

391–397

Why two methods with the same name? It's confusing trying to figure out what is calling what.

4324

I think this is fine, but instead of just having the comment for this one consumeError call, it might be better to have one at the top of each method that explains the blanket exception

4442

Why is this check here? This check happens before the method is called.

If you want to keep it in (I'm not sure I care either way), put it in an assert instead.

4460

Should true be Obj->isLittleEndian()?

4497–4502

I may just be missing something obvious, but I don't see why this wildly differs from the previous method. Why does the previous method go through all these hoops:

const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl());
Expected<StringRef> NameOrErr = EF->getSectionName(ElfSec);
// Ignore sections whose name we cannot find.
if (!NameOrErr) {
  consumeError(NameOrErr.takeError());
  continue;
}
StringRef SectionName = *NameOrErr;
if (!SectionName.startswith(".stack_sizes"))

... but then this one skips all that and just calls getName(SectionName)?

llvm/tools/llvm-readobj/llvm-readobj.cpp

58

--stack-sizes is not a GNU readelf options, so I don't think it should be implied when running llvm-readelf -a

737–740

(I guess my comment earlier actually applies here)

[grimar]

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

296

Sure, NP.

324

Looks good.

llvm/tools/llvm-readobj/ELFDumper.cpp

4555

So you're using RelocSectionName only for the error reporting.
And reportError is no return function, so it is called only once.
Then you can just move these lines right to the place where you construct the error.

4559

Well, may be other reviewers have a different opinion here. Supports just doesn't look like a function name for me.

[wolfgangp]

Addressed review comments:

• renamed one of the printStackSize() functions.
• removed superfluous check for nonrelocatable object
• Used SectionRef::getName() instead of the explicit sequence to extract a section name.
• Fixed the calls to the DataExtractor() constructor to use Obj->isLittleEndian()
• Added some comments to explain the error handling policy.
• Moved a SectionName variable definition closer to the use point.

Not resolved:
Left the question about whether --stack-sizes should be include in --all open. This is still a discussion point.

[rupprecht]

In D65313#1609287, @wolfgangp wrote:

Left the question about whether --stack-sizes should be include in --all open. This is still a discussion point.

Do you have a discussion going on somewhere you can link to?

Personally, I think it's neat & wouldn't mind it being included as part of --all for personal use, but generally we want to make llvm-readelf as close to GNU readelf as possible. (This has been feedback given at llvm dev meetings too).

Maybe it could be part of --all only when invoked as llvm-readobj? Though it doesn't make much since *now* because this only has the GNU-style dumper implemented, and in fact prints a warning for the LLVM style -- but in the future, we could do that.

[wolfgangp]

In D65313#1611137, @rupprecht wrote:

In D65313#1609287, @wolfgangp wrote:

Left the question about whether --stack-sizes should be include in --all open. This is still a discussion point.

Do you have a discussion going on somewhere you can link to?

Not really. I'd like to ask @jhenderson for input on this, but your argument below about being as close to GNU readelf as possible sounds convincing.

Personally, I think it's neat & wouldn't mind it being included as part of --all for personal use, but generally we want to make llvm-readelf as close to GNU readelf as possible. (This has been feedback given at llvm dev meetings too).

Maybe it could be part of --all only when invoked as llvm-readobj? Though it doesn't make much since *now* because this only has the GNU-style dumper implemented, and in fact prints a warning for the LLVM style -- but in the future, we could do that.

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

9–13

I settled on this format in consultation with @jhenderson . Basically to maximize readability: The size is right-justified in its column, the function name left-justified. That leaves some room on the left for larger stack sizes and room on the right for long function names (or signatures). Other readelf options weren't really under consideration.

Any suggestions are of course welcome.

llvm/tools/llvm-readobj/ELFDumper.cpp

391–397

My design thought was that one was called from a relocatable context, and the other from a non-relocatable context, so the relocatable one (the one with the 'Rel' parameter), would resolve the relocation and delegate the rest to the non-relocation function. There is no reason for them to have the same name, though. I'll change it.

4324

Added a comment to each function where consumeError() is used.

4442

Thanks, oversight during a refactor.

4497–4502

You're not missing anything, I didn't discover until later that SectionRef::getName() encapsulates what I'm doing in the segment above and forgot to update it. Thanks for pointing this out.

llvm/tools/llvm-readobj/llvm-readobj.cpp

58

I have no particularly strong opinion on this, but since the stack size functionality originated in LLVM, it's not surprising that GNU readelf would not support it. However, it does seem reasonable to include it with an 'all' option, unless the goal is exact compatibility with GNU.

[grimar]

llvm/tools/llvm-readobj/ELFDumper.cpp

4403

3 comments/suggestions:

1. Instead of manually constructing the message with a file name, you can use the same approach as already used now for reporting a errors.

i.e. just introduce a method:

void reportWarning(StringRef Input, Error Err) {
  if (Input == "-")
    Input = "<stdin>";
  warn(createFileError(Input, std::move(Err)));
}

(see my D65515 for reference).

2. With that you do not need to call consumeError after reportWarning.

3. I think everywhere where you used consumeError you should probably report a warning.

Like in the code above:

if (NameOrErr)
  SymName = *NameOrErr;
else
  consumeError(NameOrErr.takeError());

i.e. call reportWarning from (1) instead.

What do you think?

[jhenderson]

I've only done a fairly brief review, so don't wait for me for an LGTM if anybody else gives it. I'm happy to defer to others judgment on the --all behaviour. My instinct there is that the --all behaviour change is a wider issue beyond --stack-sizes. For example, --addrsig, --hash-symbols etc are switches that don't exist in GNU readelf, but might be printed if they did.

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

194

"with a complete" sounds like there's a mistake here. Should it be "within"?

434

Let's tidy up the spacing in this block here so that it better matches what is printed (and is therefore more readable).

llvm/tools/llvm-readobj/ELFDumper.cpp

4317–4318

If I'm not mistaken, we tend to write comments in the third person i.e. "This function ignores..."

4380

See my comment above.

4405–4406

Perhaps rephrase this "correct section and report its stack size anyway."

llvm/tools/llvm-readobj/llvm-readobj.cpp

58

I'm in two minds about this. My hope is that we could ignore GNU compatibility on this, and indeed I'd expect people to not be parsing --all output in such a way as it can't work if more stuff was emitted, but I could be wrong. Absolutely it should be printed for LLVM output. I'm happy to defer to others on this one.

[wolfgangp]

Addressed review comments:

--all does not imply --stack-sizes any more

Changed some comments to use third person instead of first person plural.

Some formatting adjustments in the test.

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

194

I've been struggling with the phrasing of this from the beginning. I wanted to say "ends with an incomplete stack size entry".

llvm/tools/llvm-readobj/ELFDumper.cpp

4403

I like the idea of adapting the reporting of warnings to the one with errors.

However, I feel this should really be done in a different patch, and then we can refactor all uses of reportWarning in ELFDumper.cpp and ObjDumper.cpp. I'd be happy to do this afterwards, while it's still fresh in my mind.

The other caveat is that with reporting warnings on all malformed input we would now create messages on, for example, malformed symbols that have nothing to do with what we are reporting on (since we're scanning the symbol table). If you feel that's acceptable, I have no problem doing it, but I wanted to point it out.

[jhenderson]

I'm happy with the state of this, but I'd like @grimar/@rupprecht to approve too.

[grimar]

I am OK with this. I'd like to refactor how the warnings are reported. We can do it separatelly indeed.

[rupprecht]

Sorry, I had some draft comments yesterday but had to leave early, here are post-commit comments now:

llvm/tools/llvm-readobj/ELFDumper.cpp

4524

Is this iteration order well defined/stable? I tried going down the rabbit hole of making sure this isn't sorting based on arbitrary pointer values, but couldn't figure out what it's keyed off of. Is it sorting by section name/index?

(llvm::MapVector itself is deterministic/sorted on the key, but if the key is a pointer, it's effectively random)

llvm/tools/llvm-readobj/llvm-readobj.cpp

58

Hmm, good point; definitely there are countless users that invoke+parse the output of readelf -a (when probably they only care about a few things, but use -a as a lazy way to just get everything). But there's so much output it produces, any strict parser that would break if an additional block is produced is probably so fragile anyway.

Still, might be good to submit this without being included in --all (for readelf), and we can add it there that as a separate change after having this feature live in the wild for a bit/get some more opinions.

737–740

I think this block is obsolete now? The default for flags is false, so this just means that llvm-readobj --all --stack-sizes won't print stack sizes, but llvm-readobj --stack-sizes will (and will print the warning).

[rupprecht]

(Also just want to say the print*RelocatableStackSizes methods look much better now, thanks for cleaning that up!)

llvm/docs/CommandGuide/llvm-readelf.rst

 
  When used with :option:`--sections`, display symbols for each section shown.
  This option has no effect for GNU style output.
 
 .. option:: --stackmap
 
  Display contents of the stackmap section.
 
+.. option:: --stack-sizes
+
+ Display the contents of the stack sizes section(s), i.e. pairs of function
+ names and the size of their stack frames.
+
 .. option:: --string-dump=<section[,section,...]>, -p
 
  Display the specified section(s) as a list of strings. ``section`` may be a
  section index or section name.
 
 .. option:: --symbols, --syms, -s
 
  Display the symbol table.

llvm/test/tools/llvm-readobj/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 > %t01
+# RUN: llvm-readelf --stack-sizes %t01 \
+# RUN:   | FileCheck %s --check-prefix=RELOC --strict-whitespace --match-full-lines
+
+#      RELOC:         Size     Function
+# RELOC-NEXT:           16     referenced_by_symbol_foo
+# RELOC-NEXT:           32     referenced_via_section_bar
+# RELOC-NEXT:            8     separate_text_section_baz
+#  RELOC-NOT:{{.}}
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:    .text
+    Type:    SHT_PROGBITS
+    Flags:   [SHF_ALLOC]
+    Size:    16
+  - Name:    .text.baz
+    Type:    SHT_PROGBITS
+    Flags:   [SHF_ALLOC]
+    Size:    16
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+## 2 stack size entries. Each consists of an address (subject to relocation)
+## followed by a ULEB for the size.
+    Content: "000000000000000010000000000000000020"
+    Link:    .text
+  - Name:    .stack_sizes.baz
+    Type:    SHT_PROGBITS
+## One stack size entry.
+    Content: "200000000000000008"
+    Link:    .text.baz
+  - Name:    .rela.stack_sizes
+    Type:    SHT_RELA
+    Info:    .stack_sizes
+    Relocations:
+## A symbol relative reference. 
+      - Offset: 0
+        Symbol: referenced_by_symbol_foo 
+        Type:   R_X86_64_64
+## A section relative reference. 
+      - Offset: 9
+        Addend: 16
+        Symbol: .text
+        Type:   R_X86_64_64
+  - Name:   .rela.stack_sizes.baz
+    Type:   SHT_RELA
+    Info:   .stack_sizes.baz
+    Relocations:
+      - Offset: 0
+        Symbol: separate_text_section_baz
+        Type:   R_X86_64_64
+Symbols:
+  - Name:    separate_text_section_baz
+    Section: .text.baz
+    Type:    STT_FUNC
+  - Name:    .text
+    Section: .text
+    Type:    STT_SECTION
+  - Name:    referenced_by_symbol_foo
+    Section: .text
+    Type:    STT_FUNC
+    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.
+
+# RUN: yaml2obj --docnum=2 %s > %t02
+# RUN: llvm-readelf --stack-sizes %t02 \
+# RUN:   | FileCheck %s --check-prefix=EXEC --strict-whitespace --match-full-lines
+
+#      EXEC:         Size     Function
+# EXEC-NEXT:           16     foo
+# EXEC-NEXT:           32     bar
+#  EXEC-NOT:{{.}}
+
+--- !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
+    Content: "100000000000000010200000000000000020"
+    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
+
+## 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
+
+# SHORT: error: '[[FILE]]': found invalid relocation offset into section .stack_sizes while trying to extract a stack size entry
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:    .text
+    Type:    SHT_PROGBITS
+    Flags:   [SHF_ALLOC]
+    Size:    16
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Size:    1
+    Link:    .text
+  - Name:    .rela.stack_sizes
+    Type:    SHT_RELA
+    Info:    .stack_sizes
+    Relocations:
+      - Offset: 1
+        Symbol: foo 
+        Type:   R_X86_64_64
+Symbols:
+  - Name:    foo
+    Section: .text
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+
+## Check that we warn about a function symbol that is not in the section
+## that is referenced by the stack sizes section's sh_link.
+
+# RUN: yaml2obj --docnum=4 %s > %t04
+# RUN: llvm-readelf --stack-sizes %t04 2> %t04.err | FileCheck %s --check-prefix=WRONGSECTION
+# RUN: FileCheck %s < %t04.err --check-prefix=WRONGSECTION-ERR -DFILE=%t04
+
+# WRONGSECTION:      Size Function
+# WRONGSECTION-NEXT: 8 foo
+# WRONGSECTION-ERR:  warning: '[[FILE]]': relocation symbol foo is not in the expected section
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:    .text
+    Type:    SHT_PROGBITS
+    Size:    8
+  - Name:    .text2
+    Type:    SHT_PROGBITS
+    Size:    8
+    Flags:   [SHF_ALLOC]
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Content: "000000000000000008"
+    Link:    .text2
+  - Name:    .rela.stack_sizes
+    Type:    SHT_RELA
+    Info:    .stack_sizes
+    Relocations:
+      - Offset: 0
+        Symbol: foo 
+        Type:   R_X86_64_64
+Symbols:
+  - Name:    foo
+    Section: .text
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+
+## Check that we report an error when a stack sizes section ends with a complete stack size entry.
+
+# RUN: yaml2obj --docnum=5 %s > %t05
+# RUN: not llvm-readelf --stack-sizes %t05 2>&1 %t05.err | \
+# RUN:    FileCheck %s --check-prefix=SUDDENEND -DFILE=%t05
+
+# SUDDENEND: error: '[[FILE]]': section .stack_sizes ended while trying to extract a stack size entry
+
+--- !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
+    Content: "10000000"
+    Link:    .text
+Symbols:
+  - Name:    foo
+    Section: .text
+    Value:   0x10
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+
+## Check that we report an invalid stack size, which is represented by a ULEB that
+## ends in a byte with the high bit set.
+
+# RUN: yaml2obj --docnum=6 %s > %t06
+# RUN: not llvm-readelf --stack-sizes %t06 2>&1 | FileCheck %s --check-prefix=BADSIZE -DFILE=%t06
+
+# BADSIZE: error: '[[FILE]]': could not extract a valid stack size in section .stack_sizes
+
+--- !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
+    Content: "100000000000000080"
+    Link:    .text
+Symbols:
+  - Name:    foo
+    Section: .text
+    Value:   0x10
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+
+## Check that we report a warning when a relocation symbol does not belong to a
+## valid section. We expect a stack size entry with an unknown symbol in the 
+## output.
+
+# RUN: yaml2obj --docnum=7 %s > %t07
+# RUN: llvm-readelf --stack-sizes %t07 2> %t07.err | FileCheck %s --check-prefix=BADSECTION-OUT
+# RUN: FileCheck %s < %t07.err --check-prefix=BADSECTION-ERR -DFILE=%t07
+
+# BADSECTION-OUT: Size Function
+# BADSECTION-OUT:    8 ?
+# BADSECTION-ERR: warning: '[[FILE]]': cannot identify the section for relocation symbol foo
+
+--- !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
+    Link:    .text
+    Content: "000000000000000008"
+  - Name:    .rela.stack_sizes
+    Type:    SHT_RELA
+    Info:    .stack_sizes
+    Relocations:
+    - Offset: 0
+      Symbol: foo 
+      Type:   R_X86_64_64
+Symbols:
+  - Name:    foo
+## An invalid section index.
+    Index:   10
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+
+## Check that we report a warning when a stack sizes section does not come with
+## a corresponding relocation section.
+
+# RUN: yaml2obj --docnum=8 %s > %t08
+# RUN: llvm-readelf --stack-sizes %t08 2> %t08.err | FileCheck %s --check-prefix=NORELOCSECTION-OUT
+# RUN: FileCheck %s < %t08.err --check-prefix=NORELOCSECTION-ERR -DFILE=%t08
+
+# NORELOCSECTION-OUT:     Size Function
+# NORELOCSECTION-OUT-NOT: {{.}}
+# NORELOCSECTION-ERR:     warning: '[[FILE]]': section .stack_sizes does not have a corresponding relocation section
+
+--- !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
+    Link:    .text
+    Content: "000000000000000008"
+
+## Check that we handle multiple object files, separately and when they
+## are in an archive. This also checks whether we have blank lines between the
+## tables.
+
+# RUN: llvm-ar rc %t1.a %t01 %t02
+# RUN: llvm-readelf --stack-sizes %t01 %t02 | FileCheck %s --check-prefix=MULTIPLE
+# RUN: llvm-readelf --stack-sizes %t1.a \
+# RUN:   | FileCheck %s --check-prefix=MULTIPLE --check-prefix=ARCHIVE --strict-whitespace\
+# RUN:   --match-full-lines -DFILE=%t1.a
+
+#       ARCHIVE:File: [[FILE]]({{.*01}})
+#      MULTIPLE:Stack Sizes:
+# MULTIPLE-NEXT:         Size     Function
+# MULTIPLE-NEXT:           16     referenced_by_symbol_foo
+# MULTIPLE-NEXT:           32     referenced_via_section_bar
+# MULTIPLE-NEXT:            8     separate_text_section_baz
+# MULTIPLE-EMPTY:
+#       ARCHIVE:File: [[FILE]]({{.*02}})
+# MULTIPLE-EMPTY:
+# MULTIPLE-NEXT:Stack Sizes:
+# MULTIPLE-NEXT:         Size     Function
+# MULTIPLE-NEXT:           16     foo
+# MULTIPLE-NEXT:           32     bar
+
+## Check that stack sizes are dumped with the --all switch.
+
+# RUN: yaml2obj --docnum=1 %s > %t13
+# RUN: llvm-readelf --all %t13 | FileCheck %s --check-prefix=ALL
+
+# ALL: Stack Sizes:
+
+## 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 --all %t14 2> %t14.err | FileCheck %s --check-prefix=NONFUNCTIONSYM
+# RUN: FileCheck %s < %t14.err --check-prefix=NONFUNCTIONSYM-ERR -DFILE=%t14
+
+# NONFUNCTIONSYM:     Stack Sizes:
+# NONFUNCTIONSYM:     0 ?
+# NONFUNCTIONSYM-ERR: warning: '[[FILE]]': could not identify function symbol for stack size entry
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .text
+    Type: SHT_PROGBITS
+    Size: 16
+  - Name: .stack_sizes
+    Type: SHT_PROGBITS
+    Size: 9
+    Link: .text
+  - Name: .rela.stack_sizes
+    Type: SHT_RELA
+    Info: .stack_sizes
+    Relocations:
+      - Offset: 0
+        Symbol: foo 
+        Type:   R_X86_64_64
+Symbols:
+  - Name:    foo
+    Section: .text
+    Type:    STT_OBJECT
+    Binding: STB_GLOBAL
+
+## Check that we report an error when we find an unsupported relocation
+## in the section that contains the stack size entries' relocations.
+
+# RUN: yaml2obj --docnum=10 %s > %t15
+# RUN: not llvm-readelf --stack-sizes %t15 2>&1 | FileCheck %s --check-prefix=UNSUPPRELOC -DFILE=%t15
+
+# UNSUPPRELOC: error: '[[FILE]]': unsupported relocation type in section .rela.stack_sizes: R_X86_64_RELATIVE
+
+--- !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
+    Size: 16
+    Link: .text
+  - Name: .rela.stack_sizes
+    Type: SHT_RELA
+    Info: .stack_sizes
+    Relocations:
+      - Offset: 0
+        Symbol: foo 
+        Type:   R_X86_64_RELATIVE
+Symbols:
+  - Name:    foo
+    Section: .text
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+
+## Check that warning messages in archives do not impact other members. In the following
+## test, the first archive member generates a warning and we make sure all the information
+## is still dumped.
+
+# RUN: llvm-ar rc %t2.a %t04 %t01
+# RUN: llvm-readelf --stack-sizes %t2.a 2>&1 | FileCheck %s --check-prefix=ARCHIVEWARN \
+# RUN:   -DFILE=%t2.a
+
+# ARCHIVEWARN:      File: [[FILE]]({{.*04}})
+# ARCHIVEWARN:      Stack Sizes:
+# ARCHIVEWARN-NEXT: Size Function
+# ARCHIVEWARN:      8 foo
+# ARCHIVEWARN:      File: [[FILE]]({{.*01}})
+# ARCHIVEWARN:      Stack Sizes:
+# ARCHIVEWARN-NEXT: Size Function
+# ARCHIVEWARN-NEXT: 16 referenced_by_symbol_foo
+# ARCHIVEWARN-NEXT: 32 referenced_via_section_bar
+# ARCHIVEWARN-NEXT:  8 separate_text_section_baz
+# ARCHIVEWARN-NOT:  {{.}}
+# ARCHIVEWARN-ERR:  warning: '[[FILE]]': relocation symbol foo is not in the expected section
+
+## Check that we demangle function names when requested.
+
+# RUN: yaml2obj --docnum=11 %s > %t16
+# RUN: llvm-readelf --stack-sizes --demangle %t16 | FileCheck %s --check-prefix=DEMANGLE
+
+# DEMANGLE: 16 foo(float)
+
+--- !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
+    Content: "100000000000000010"
+    Link:    .text
+Symbols:
+  - Name:    _Z3foof
+    Section: .text
+    Value:   0x10
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+
+## Check that we emit a 'not implemented' message for an attempt to dump stack-sizes
+## sections LLVM-style, i.e. when invoking llvm-readobj. 
+## FIXME: Replace this test with something functional when the feature is implemented.
+
+# RUN: llvm-readobj --stack-sizes %t01 | FileCheck %s --check-prefix=NOTIMPLEMENTED 
+
+# NOTIMPLEMENTED: Dumping of stack sizes in LLVM style is not implemented yet

llvm/tools/llvm-readobj/ELFDumper.cpp

 #include "DwarfCFIEHPrinter.h"
 #include "Error.h"
 #include "ObjDumper.h"
 #include "StackMapPrinter.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/RelocationResolver.h"
 #include "llvm/Object/StackMapParser.h"
 #include "llvm/Support/AMDGPUMetadata.h"
 #include "llvm/Support/ARMAttributeParser.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
public:
   void printHashHistogram() override;
 
   void printCGProfile() override;
   void printAddrsig() override;
 
   void printNotes() override;
 
   void printELFLinkerOptions() override;
+  void printStackSizes() override;
 
   const object::ELFObjectFile<ELFT> *getElfObject() const { return ObjF; };
 
 private:
   std::unique_ptr<DumpStyle<ELFT>> ELFDumperStyle;
 
   TYPEDEF_ELF_TYPES(ELFT)
 

 }
 
 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;
 
   DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) {}
   virtual ~DumpStyle() = default;
 
   virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0;
   virtual void printRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSectionHeaders(const ELFFile<ELFT> *Obj) = 0;
virtual void printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
                                              const Elf_Shdr *Sec) = 0;
   virtual void printVersionDependencySection(const ELFFile<ELFT> *Obj,
                                              const Elf_Shdr *Sec) = 0;
   virtual void printHashHistogram(const ELFFile<ELFT> *Obj) = 0;
   virtual void printCGProfile(const ELFFile<ELFT> *Obj) = 0;
   virtual void printAddrsig(const ELFFile<ELFT> *Obj) = 0;
   virtual void printNotes(const ELFFile<ELFT> *Obj) = 0;
   virtual void printELFLinkerOptions(const ELFFile<ELFT> *Obj) = 0;
+  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,
+                              uint64_t *Offset);
+  void printStackSize(const ELFObjectFile<ELFT> *Obj, RelocationRef Rel,
+                      SectionRef FunctionSec,
+                      const StringRef &StackSizeSectionName,
+                      const RelocationResolver &Resolver, 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; }
 
 private:
   const ELFDumper<ELFT> *Dumper;
 };
 
void printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
                                      const Elf_Shdr *Sec) override;
   void printVersionDependencySection(const ELFFile<ELFT> *Obj,
                                      const Elf_Shdr *Sec) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printAddrsig(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
+  void printStackSizes(const ELFObjectFile<ELFT> *Obj) override;
+  void printStackSizeEntry(uint64_t Size, StringRef FuncName) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
 
 private:
   struct Field {
     std::string Str;
     unsigned Column;
 
void printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
                                      const Elf_Shdr *Sec) override;
   void printVersionDependencySection(const ELFFile<ELFT> *Obj,
                                      const Elf_Shdr *Sec) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printAddrsig(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
+  void printStackSizes(const ELFObjectFile<ELFT> *Obj) override;
+  void printStackSizeEntry(uint64_t Size, StringRef FuncName) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
 
 private:
   void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel);
   void printSymbols(const ELFO *Obj);
   void printDynamicSymbols(const ELFO *Obj);

 template <class ELFT> void ELFDumper<ELFT>::printNotes() {
   ELFDumperStyle->printNotes(ObjF->getELFFile());
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printELFLinkerOptions() {
   ELFDumperStyle->printELFLinkerOptions(ObjF->getELFFile());
 }
 
+template <class ELFT> void ELFDumper<ELFT>::printStackSizes() {
+  ELFDumperStyle->printStackSizes(ObjF);
+}
+
 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum)                                 \
   { #enum, prefix##_##enum }
 
 static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
   LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
   LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
   LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
   LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
   OS << "printELFLinkerOptions not implemented!\n";
 }
 
+// FIXME: As soon as the DataExtractor interface handles uint64_t *, this 
+// should be eliminated. See upstream review https://reviews.llvm.org/D64006.
+inline uint32_t *AdjustPtr(uint64_t *Offset) {
+  uint32_t *Ptr = reinterpret_cast<uint32_t *>(Offset);
+  if (sys::IsBigEndianHost)
+    Ptr++;
+  return Ptr;
+}
+
+template <class ELFT>
+void DumpStyle<ELFT>::printFunctionStackSize(
+    const ELFObjectFile<ELFT> *Obj, uint64_t SymValue, SectionRef FunctionSec,
+    const StringRef SectionName, DataExtractor Data, uint64_t *Offset) {
+  // We are ignoring potentially erroneous input, unless it is directly
+  // related to stack size reporting.
+  SymbolRef FuncSym;
+  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) {
+      // Check if the symbol is in the right section.
+      if (FunctionSec.containsSymbol(Symbol)) {
+        FuncSym = Symbol;
+        break;
+      }
+    }
+  }
+
+  StringRef FileStr = Obj->getFileName();
+  std::string FuncName = "?";
+  // 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)
+      FuncName = maybeDemangle(*FuncNameOrErr);
+    else
+      consumeError(FuncNameOrErr.takeError());
+  } else
+    reportWarning(" '" + FileStr +
+                  "': could not identify function symbol for stack size entry");
+
+  // Extract the size. We expect that Offset is pointing to the right place,
+  // i.e. past the function address.
+  uint64_t PrevOffset = *Offset;
+  uint64_t StackSize = Data.getULEB128(AdjustPtr(Offset));
+  // getULEB128() does not advance Offset if it is not able to extract a valid
+  // integer.
+  if (*Offset == PrevOffset)
+    reportError(
+        FileStr,
+        createStringError(object_error::parse_failed,
+                          "could not extract a valid stack size in section %s",
+                          SectionName.data()));
+
+  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) {
+  // We are ignoring 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
+    // located.
+    StringRef SymName = "?";
+    Expected<StringRef> NameOrErr = RelocSym->getName();
+    if (NameOrErr)
+      SymName = *NameOrErr;
+    else
+      consumeError(NameOrErr.takeError());
+
+    auto SectionOrErr = RelocSym->getSection();
+    if (!SectionOrErr) {
+      reportWarning(" '" + FileStr +
+                    "': cannot identify the section for relocation symbol " +
+                    SymName);
+      consumeError(SectionOrErr.takeError());
+    } else if (*SectionOrErr != FunctionSec) {
+      reportWarning(" '" + FileStr + "': relocation symbol " + SymName +
+                    " is not in the expected section");
+      // Pretend that the symbol is in the correct section. We will report
+      // its stack size anyway.
+      FunctionSec = **SectionOrErr;
+    }
+
+    Expected<uint64_t> RelocSymValueOrErr = RelocSym->getValue();
+    if (RelocSymValueOrErr)
+      RelocSymValue = *RelocSymValueOrErr;
+    else
+      consumeError(RelocSymValueOrErr.takeError());
+  }
+
+  uint64_t Offset = Reloc.getOffset();
+  if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1))
+    reportError(FileStr, createStringError(
+                             object_error::parse_failed,
+                             "found invalid relocation offset into section %s "
+                             "while trying to extract a stack size entry",
+                             StackSizeSectionName.data()));
+
+  uint64_t Addend = Data.getAddress(AdjustPtr(&Offset));
+  uint64_t SymValue = Resolver(Reloc, RelocSymValue, Addend);
+  this->printFunctionStackSize(Obj, SymValue, FunctionSec, StackSizeSectionName,
+                               Data, &Offset);
+}
+
+template <class ELFT>
+SectionRef toSectionRef(const ObjectFile *Obj, const typename ELFT::Shdr *Sec) {
+  DataRefImpl DRI;
+  DRI.p = reinterpret_cast<uintptr_t>(Sec);
+  return SectionRef(DRI, Obj);
+}
+
+template <class ELFT>
+void DumpStyle<ELFT>::printNonRelocatableStackSizes(
+    const ELFObjectFile<ELFT> *Obj, std::function<void()> PrintHeader) {
+  // We are ignoring 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;
+    Sec.getName(SectionName);
+    const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl());
+    if (!SectionName.startswith(".stack_sizes"))
+      continue;
+    PrintHeader();
+    ArrayRef<uint8_t> Contents = unwrapOrError(EF->getSectionContents(ElfSec));
+    DataExtractor Data(
+        StringRef(reinterpret_cast<const char *>(Contents.data()),
+                  Contents.size()),
+        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(EF->getSection(ElfSec->sh_link));
+    uint64_t Offset = 0;
+    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(
+            FileStr,
+            createStringError(
+                object_error::parse_failed,
+                "section %s ended while trying to extract a stack size entry",
+                SectionName.data()));
+      }
+      uint64_t SymValue = Data.getAddress(AdjustPtr(&Offset));
+      printFunctionStackSize(Obj, SymValue,
+                             toSectionRef<ELFT>(Obj, FunctionELFSec),
+                             SectionName, Data, &Offset);
+    }
+  }
+}
+
+template <class ELFT>
+void DumpStyle<ELFT>::printRelocatableStackSizes(
+    const ELFObjectFile<ELFT> *Obj, std::function<void()> PrintHeader) {
+  const ELFFile<ELFT> *EF = Obj->getELFFile();
+  StringRef FileStr = Obj->getFileName();
+  // For relocatable objects we build a map between stack size sections and
+  // their corresponding relocation sections.
+  llvm::MapVector<SectionRef, SectionRef> StackSizeRelocMap;
+  const SectionRef NullSection;
+
+  for (const SectionRef &Sec : Obj->sections()) {
+    StringRef SectionName;
+    Sec.getName(SectionName);
+    // 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.startswith(".stack_sizes"))
+      if (StackSizeRelocMap.count(Sec) == 0) {
+        StackSizeRelocMap[Sec] = NullSection;
+        continue;
+      }
+
+    // Check relocation sections if they are relocating contents of a
+    // stack sizes section.
+    const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl());
+    uint32_t SectionType = ElfSec->sh_type;
+    if (SectionType != ELF::SHT_RELA && SectionType != ELF::SHT_REL)
+      continue;
+
+    SectionRef Contents = *Sec.getRelocatedSection();
+    const Elf_Shdr *ContentsSec = Obj->getSection(Contents.getRawDataRefImpl());
+    Expected<StringRef> ContentsSectionNameOrErr =
+        EF->getSectionName(ContentsSec);
+    if (!ContentsSectionNameOrErr) {
+      consumeError(ContentsSectionNameOrErr.takeError());
+      continue;
+    }
+    if (!ContentsSectionNameOrErr->startswith(".stack_sizes"))
+      continue;
+    // Insert a mapping from the stack sizes section to its relocation section.
+    StackSizeRelocMap[toSectionRef<ELFT>(Obj, ContentsSec)] = Sec;
+  }
+
+  for (const auto &StackSizeMapEntry : StackSizeRelocMap) {
+    PrintHeader();
+    const SectionRef &StackSizesSec = StackSizeMapEntry.first;
+    const SectionRef &RelocSec = StackSizeMapEntry.second;
+
+    // Warn about stack size sections without a relocation section.
+    StringRef StackSizeSectionName;
+    StackSizesSec.getName(StackSizeSectionName);
+    if (RelocSec == NullSection) {
+      reportWarning(" '" + FileStr + "': section " + StackSizeSectionName +
+                    " does not have a corresponding "
+                    "relocation section");
+      continue;
+    }
+
+    // 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 *StackSizesELFSec =
+        Obj->getSection(StackSizesSec.getRawDataRefImpl());
+    const SectionRef FunctionSec = toSectionRef<ELFT>(
+        Obj, unwrapOrError(EF->getSection(StackSizesELFSec->sh_link)));
+
+    bool (*IsSupportedFn)(uint64_t);
+    RelocationResolver Resolver;
+    std::tie(IsSupportedFn, Resolver) = getRelocationResolver(*Obj);
+    auto Contents = unwrapOrError(StackSizesSec.getContents());
+    DataExtractor Data(
+        StringRef(reinterpret_cast<const char *>(Contents.data()),
+                  Contents.size()),
+        Obj->isLittleEndian(), sizeof(Elf_Addr));
+    for (const RelocationRef &Reloc : RelocSec.relocations()) {
+      if (!IsSupportedFn(Reloc.getType())) {
+        StringRef RelocSectionName;
+        RelocSec.getName(RelocSectionName);
+        StringRef RelocName = EF->getRelocationTypeName(Reloc.getType());
+        reportError(
+            FileStr,
+            createStringError(object_error::parse_failed,
+                              "unsupported relocation type in section %s: %s",
+                              RelocSectionName.data(), RelocName.data()));
+      }
+      this->printStackSize(Obj, Reloc, FunctionSec, StackSizeSectionName,
+                           Resolver, Data);
+    }
+  }
+}
+
+template <class ELFT>
+void GNUStyle<ELFT>::printStackSizes(const ELFObjectFile<ELFT> *Obj) {
+  bool HeaderHasBeenPrinted = false;
+  auto PrintHeader = [&]() {
+    if (HeaderHasBeenPrinted)
+      return;
+    OS << "\nStack Sizes:\n";
+    OS.PadToColumn(9);
+    OS << "Size";
+    OS.PadToColumn(18);
+    OS << "Function\n";
+    HeaderHasBeenPrinted = true;
+  };
+
+  // For non-relocatable objects, look directly for sections whose name starts
+  // with .stack_sizes and process the contents.
+  if (Obj->isRelocatableObject())
+    this->printRelocatableStackSizes(Obj, PrintHeader);
+  else
+    this->printNonRelocatableStackSizes(Obj, PrintHeader);
+}
+
 template <class ELFT>
 void GNUStyle<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) {
   size_t Bias = ELFT::Is64Bits ? 8 : 0;
   auto PrintEntry = [&](const Elf_Addr *E, StringRef Purpose) {
     OS.PadToColumn(2);
     OS << format_hex_no_prefix(Parser.getGotAddress(E), 8 + Bias);
     OS.PadToColumn(11 + Bias);
     OS << format_decimal(Parser.getGotOffset(E), 6) << "(gp)";
for (const uint8_t *P = Contents.begin(), *E = Contents.end(); P < E; ) {
       W.printString(Key, Value);
 
       P = P + Key.size() + Value.size() + 2;
     }
   }
 }
 
 template <class ELFT>
+void LLVMStyle<ELFT>::printStackSizes(const ELFObjectFile<ELFT> *Obj) {
+  W.printString(
+      "Dumping of stack sizes in LLVM style is not implemented yet\n");
+}
+
+template <class ELFT>
+void LLVMStyle<ELFT>::printStackSizeEntry(uint64_t Size, StringRef FuncName) {
+  // FIXME: Implement this function for LLVM-style dumping.
+}
+
+template <class ELFT>
 void LLVMStyle<ELFT>::printMipsGOT(const MipsGOTParser<ELFT> &Parser) {
   auto PrintEntry = [&](const Elf_Addr *E) {
     W.printHex("Address", Parser.getGotAddress(E));
     W.printNumber("Access", Parser.getGotOffset(E));
     W.printHex("Initial", *E);
   };
 
   DictScope GS(W, Parser.IsStatic ? "Static GOT" : "Primary GOT");

llvm/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printLoadName() {}
   virtual void printVersionInfo() {}
   virtual void printGroupSections() {}
   virtual void printHashHistogram() {}
   virtual void printCGProfile() {}
   virtual void printAddrsig() {}
   virtual void printNotes() {}
   virtual void printELFLinkerOptions() {}
+  virtual void printStackSizes() {}
 
   // Only implemented for ARM ELF at this time.
   virtual void printAttributes() { }
 
   // Only implemented for MIPS ELF at this time.
   virtual void printMipsPLTGOT() { }
   virtual void printMipsABIFlags() { }
   virtual void printMipsReginfo() { }

llvm/tools/llvm-readobj/llvm-readobj.cpp

cl::list<std::string> InputFilenames(cl::Positional,
     cl::ZeroOrMore);
 
   // --all, -a
   cl::opt<bool>
       All("all",
           cl::desc("Equivalent to setting: --file-headers, --program-headers, "
                    "--section-headers, --symbols, --relocations, "
                    "--dynamic-table, --notes, --version-info, --unwind, "
-                   "--section-groups and --elf-hash-histogram."));
+                   "--stack-sizes, --section-groups and --elf-hash-histogram."));
   cl::alias AllShort("a", cl::desc("Alias for --all"), cl::aliasopt(All));
 
   // --headers -e
   cl::opt<bool>
       Headers("headers",
           cl::desc("Equivalent to setting: --file-headers, --program-headers, "
                    "--section-headers"));
   cl::alias HeadersShort("e", cl::desc("Alias for --headers"),
namespace opts {
   MachODysymtab("macho-dysymtab",
                   cl::desc("Display MachO Dysymtab command"));
 
   // --stackmap
   cl::opt<bool>
   PrintStackMap("stackmap",
                 cl::desc("Display contents of stackmap section"));
 
+  // --stack-sizes
+  cl::opt<bool>
+      PrintStackSizes("stack-sizes",
+                      cl::desc("Display contents of all stack sizes sections"));
+
   // --version-info, -V
   cl::opt<bool>
       VersionInfo("version-info",
                   cl::desc("Display ELF version sections (if present)"));
   cl::alias VersionInfoShort("V", cl::desc("Alias for -version-info"),
                              cl::aliasopt(VersionInfo));
 
   // --elf-section-groups, --section-groups, -g
if (opts::MachOSegment)
       Dumper->printMachOSegment();
     if (opts::MachOVersionMin)
       Dumper->printMachOVersionMin();
     if (opts::MachODysymtab)
       Dumper->printMachODysymtab();
   }
   if (opts::PrintStackMap)
     Dumper->printStackMap();
+  if (opts::PrintStackSizes)
+    Dumper->printStackSizes();
 }
 
 /// Dumps each object file in \a Arc;
 static void dumpArchive(const Archive *Arc, ScopedPrinter &Writer) {
   Error Err = Error::success();
   for (auto &Child : Arc->children(Err)) {
     Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary();
     if (!ChildOrErr) {
if (opts::All) {
     opts::Symbols = true;
     opts::Relocations = true;
     opts::DynamicTable = true;
     opts::Notes = true;
     opts::VersionInfo = true;
     opts::UnwindInfo = true;
     opts::SectionGroups = true;
     opts::HashHistogram = true;
+    // FIXME: As soon as we implement LLVM-style printing of the .stack_size
+    // section, we will enable it unconditionally with --all.
+    if (opts::Output == opts::GNU)
+      opts::PrintStackSizes = true;
   }
 
   if (opts::Headers) {
     opts::FileHeaders = true;
     opts::ProgramHeaders = true;
     opts::SectionHeaders = true;
   }