[yaml2obj/obj2yaml] - Add support for .stack_sizes sections.

[grimar]

Summary

.stack_sizes is a SHT_PROGBITS section that contains pairs of
<address (4/8 bytes), stack size (uleb128)>.

This patch teach tools to parse and dump it.

[MaskRay]

include/llvm/ObjectYAML/ELFYAML.h

183

I think we can just use Name == ".stack_sizes" for now. MC doesn't create .stack_sizes.*

Moreover, the error messages below just use plain .stack_sizes.

lib/ObjectYAML/ELFEmitter.cpp

794

using

lib/ObjectYAML/ELFYAML.cpp

1156

Section = std::make_unique<ELFYAML::StackSizesSection>();

test/tools/yaml2obj/elf-stack-sizes.yaml

2

produces

from YAML descriptions.

Seems redundant. This directory contains all such YAML files but none mentions "YAML descriptions".

8

Is it tighter to put CONTENT-VALID, CONTENT_INVALID and CONTENT-TRUNCATED tests together?

# Valid
- Name: .stack_sizes [1]
  Type:    SHT_PROGBITS
  Content: ...
# Truncated
- Name: .stack_sizes [2]
  Type:    SHT_PROGBITS
  Content: ...
# ...

tools/obj2yaml/elf2yaml.cpp

293

Move the if (Shdr->sh_type == ELF::SHT_PROGBITS) check here. It responds to the claim "which has a regular type."

Then, we probably should reword the comment. One suggestion I get is "recognize some special SHT_PROGBITS sections by name."

492

I guess the if can be deleted. An empty .stack_sizes can be processed with the same code.

493

If D67797 is accepted, this code can switch to the new ctor.

507

as an array of bytes.

If the data of .stack_sizes section is broken in any way,

How about "if .stack_sizes cannot be decoded"?

[grimar]

include/llvm/ObjectYAML/ELFYAML.h

183

I am not sure here. I did it because llvm-readobj test case uses YAML with .stack_sizes.*:
https://github.com/llvm-mirror/llvm/blob/master/test/tools/llvm-readobj/stack-sizes.test#L35

I do not know was it intention or the person who wrote the test just did not know how to desribe sections with the same name in YAML.
It probably might be not that bad to support .stack_sizes.* too (and may be teach MC to produve them)?
Or we can fix llvm-readobj test first. Or go with .stack_sizes.* here and deside what to do in a follow-up patch for YAML+readobj.
What would you prefer?

[MaskRay]

include/llvm/ObjectYAML/ELFYAML.h

183

Name.startswith(".stack_sizes"); is fine if we eventually emit .stack_sizes.* for clang -ffunction-sections -fstack-size-section. However, there are two problems:

• Larger code size. .stack_sizes.foo, .text.foo and .rodata.foo can take large amount of space in .strtab. This is why -fno-unique-section-names is sometimes useful.
• Linkers don't combine .stack_sizes.* into .stack_sizes. ld.bfd and lld will have to be taught the special rule. In lld, it is in getOutputSectionName.

[grimar]

include/llvm/ObjectYAML/ELFYAML.h

183

Seems the right way for now is to fix llvm-readobj then. I'll do a patch.

[grimar]

• Addressed review comments.

include/llvm/ObjectYAML/ELFYAML.h

183

Patch for llvm-readobj: D67824

test/tools/yaml2obj/elf-stack-sizes.yaml

8

Ok. But I left all fields for the first case, because we probably need to test them all at least once:
since the section has a special handling, we need to verify which values we set by default.

tools/obj2yaml/elf2yaml.cpp

492

Almost "yes" :) I had to modify the code slightly and added a test case for testing this case, which asserted before, but now works fine.
(Issue was that either 'Entries' or 'Content' must present to pass section validation, but in the previous version I did not set any of them when the section data was empty).

After removing 'if', without the code modificatiuon, yaml2obj for an empty section would produce Entries: [] instead of Content: '',
what perhaps is not critical, but seems do not match the comment saying that "If .stack_sizes cannot be decoded, we dump it as an array of bytes." (assuming that empty section == broken section == can not be decoded).

493

Nice! I'll switch once it happens.

507

How about "if .stack_sizes cannot be decoded"?

LG.

[MaskRay]

lib/ObjectYAML/ELFYAML.cpp

1182

Alternatives:

.stack_sizes: either Content or Entries tag must be specified

.stack_sizes: Content and Entries cannot be used together

[grimar]

• Addressed comments.
• Rebased.

[jhenderson]

include/llvm/ObjectYAML/ELFYAML.h

183

I know this is due to how LLD and other linkers behave, but I still find it less than helpful that you can't have sections with different suffixes for many section types. Why allow .text.foo, but not .stack_sizes.foo for example? I'd personally prefer to change LLD and MC (but that's another change) than change llvm-readelf. That way, it's immediately recognisable which section a .stack_sizes section is associated with when looking at the output, without needing to decipher the Link field.

lib/ObjectYAML/ELFYAML.cpp

1179

If we're allowing people to specify a Content field, it seems reasonable to also allow specification of a Size field, with the content set to zeroes, if not otherwise filled in by Content.

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

508

I'd either put this at the bottom of the tag and not change the indentation of the other fields, or indent the fields in the other sections to match. That being said, it seems a bit weird to do it this way. I'd think adding one or more explicit entries would be a more natural choice (or at least an empty Entries array).

test/tools/obj2yaml/elf-stack-sizes.yaml

1

produce -> produces

3

uses the "Entries" tag to describe a .stack_sizes section

35

uses the "Content" tag to describe a .stack_sizes section when it can't extract the entries, for example, when ...

63

Delete "the"

test/tools/yaml2obj/elf-stack-sizes.yaml

1

I think you need Big Endian and 32-bit test cases here, since those affect how the section is written.

3

Maybe change this to "Test the following cases when the .stack_sizes Content field is specified:"

"The first test:" doesn't seem useful to me.

4

from the -> from a

6

a incorrect -> an incorrect
from the -> from a

8

from the -> from a
with an empty -> with empty

14

I'd simplify these to "Case 1: valid content." "Case 2: truncated content." and "Case 3: empty content."

90

omit the "Address" tag.
case the address will be zero.

151

describe -> describing

[MaskRay]

include/llvm/ObjectYAML/ELFYAML.h

183

The main concern is that .stack_sizes.foo can increase the object file size considerably. I agree that .stack_sizes.foo is immediately recognisable but I am not sure such trade-off is worthwhile. .stack_sizes is not alone - some sanitizers synthesized sections (e.g. .sancov_cntrs) are not suffixed, either. Lots of .group are not suffixed, etc.

[grimar]

include/llvm/ObjectYAML/ELFYAML.h

183

Why allow .text.foo, but not .stack_sizes.foo for example?

I had a time to think about this a bit. text.foo does not have a Link or Info fields set. It has to have a
function name encoded in the section name. On the other side .stack_sizes have Link.
My vision is that руку it is a dumping tools problem probably: readelf has a format that makes hard to show a useful output here,
though it has full information. I.e. it shows Link as a numeric value what makes matching task for a human harder.
We can change/improve it in llvm-readobj. I am not sure it worth to add section suffixes to a binary produced because of that.
Our aim is not to make human readable objects, we have set of tools for dumping them. We might want to improve them.

[grimar]

include/llvm/ObjectYAML/ELFYAML.h

183

"is that руку it is a ..." -> "is that here it is a ..."

[grimar]

• Addressed review comments.

lib/ObjectYAML/ELFYAML.cpp

1179

I posted a follow-up: D67958

[jhenderson]

LGTM, with one minor comment.

test/tools/yaml2obj/elf-stack-sizes.yaml

5

I think you can delete "Shows" from each of these statements now.

include/llvm/Object/ELF.h

public:
   std::string getDynamicTagAsString(uint64_t Type) const;
 
   /// Get the symbol for a given relocation.
   Expected<const Elf_Sym *> getRelocationSymbol(const Elf_Rel *Rel,
                                                 const Elf_Shdr *SymTab) const;
 
   static Expected<ELFFile> create(StringRef Object);
 
+  bool isLE() const {
+    return getHeader()->getDataEncoding() == ELF::ELFDATA2LSB;
+  }
+
   bool isMipsELF64() const {
     return getHeader()->e_machine == ELF::EM_MIPS &&
            getHeader()->getFileClass() == ELF::ELFCLASS64;
   }
 
-  bool isMips64EL() const {
-    return isMipsELF64() &&
-           getHeader()->getDataEncoding() == ELF::ELFDATA2LSB;
-  }
+  bool isMips64EL() const { return isMipsELF64() && isLE(); }
 
   Expected<Elf_Shdr_Range> sections() const;
 
   Expected<Elf_Dyn_Range> dynamicEntries() const;
 
   Expected<const uint8_t *> toMappedAddr(uint64_t VAddr) const;
 
   Expected<Elf_Sym_Range> symbols(const Elf_Shdr *Sec) const {

include/llvm/ObjectYAML/ELFYAML.h

struct SectionOrType {
   StringRef sectionNameOrType;
 };
 
 struct DynamicEntry {
   ELF_DYNTAG Tag;
   llvm::yaml::Hex64 Val;
 };
 
+struct StackSizeEntry {
+  llvm::yaml::Hex64 Address;
+  llvm::yaml::Hex64 Size;
+};
+
 struct Section {
   enum class SectionKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
     NoBits,
     Verdef,
     Verneed,
+    StackSizes,
     SymtabShndxSection,
     Symver,
     MipsABIFlags
   };
   SectionKind Kind;
   StringRef Name;
   ELF_SHT Type;
   Optional<ELF_SHF> Flags;
struct Section {
   // section data at the offset specified.
   Optional<llvm::yaml::Hex64> ShOffset;
 
   // This can be used to override the sh_size field. It does not affect the
   // content written.
   Optional<llvm::yaml::Hex64> ShSize;
 };
 
+struct StackSizesSection : Section {
+  Optional<yaml::BinaryRef> Content;
+  Optional<std::vector<StackSizeEntry>> Entries;
+
+  StackSizesSection() : Section(SectionKind::StackSizes) {}
+
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::StackSizes;
+  }
+
+  static bool nameMatches(StringRef Name) {
+    return Name == ".stack_sizes";
+  }
+};
+
 struct DynamicSection : Section {
   std::vector<DynamicEntry> Entries;
   Optional<yaml::BinaryRef> Content;
 
   DynamicSection() : Section(SectionKind::Dynamic) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::Dynamic;
struct Object {
   // being a single SHT_SYMTAB section are upheld.
   std::vector<Symbol> Symbols;
   std::vector<Symbol> DynamicSymbols;
 };
 
 } // end namespace ELFYAML
 } // end namespace llvm
 
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)

 };
 
 template <>
 struct MappingTraits<ELFYAML::Symbol> {
   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
   static StringRef validate(IO &IO, ELFYAML::Symbol &Symbol);
 };
 
+template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
+  static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
+};
+
 template <> struct MappingTraits<ELFYAML::DynamicEntry> {
   static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
 };
 
 template <> struct MappingTraits<ELFYAML::VerdefEntry> {
   static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
 };
 

lib/ObjectYAML/ELFEmitter.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/EndianStream.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 // This class is used to build up a contiguous binary blob while keeping
void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::VerdefSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::MipsABIFlags &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::DynamicSection &Section,
                            ContiguousBlobAccumulator &CBA);
+  void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::StackSizesSection &Section,
+                           ContiguousBlobAccumulator &CBA);
   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
 };
 } // end anonymous namespace
 
for (size_t I = 0; I < Doc.Sections.size(); ++I) {
     } else if (auto S = dyn_cast<ELFYAML::DynamicSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::SymverSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::VerneedSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::VerdefSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
+    } else if (auto S = dyn_cast<ELFYAML::StackSizesSection>(Sec)) {
+      writeSectionContent(SHeader, *S, CBA);  
     } else {
       llvm_unreachable("Unknown section type");
     }
 
     // Override the fields if requested.
     if (Sec) {
       if (Sec->ShName)
         SHeader.sh_name = *Sec->ShName;
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   for (uint16_t Version : Section.Entries)
     support::endian::write<uint16_t>(OS, Version, ELFT::TargetEndianness);
 
   SHeader.sh_entsize = Section.EntSize ? (uint64_t)*Section.EntSize : 2;
   SHeader.sh_size = Section.Entries.size() * SHeader.sh_entsize;
 }
 
 template <class ELFT>
+void ELFState<ELFT>::writeSectionContent(
+    Elf_Shdr &SHeader, const ELFYAML::StackSizesSection &Section,
+    ContiguousBlobAccumulator &CBA) {
+  using uintX_t = typename ELFT::uint;
+  raw_ostream &OS =
+      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+
+  if (Section.Content) {
+    Section.Content->writeAsBinary(OS);
+    SHeader.sh_size = Section.Content->binary_size();
+    return;
+  }
+
+  for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
+    support::endian::write<uintX_t>(OS, E.Address, ELFT::TargetEndianness);
+    SHeader.sh_size += sizeof(uintX_t) + encodeULEB128(E.Size, OS);
+  }
+}
+
+template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerdefSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Verdaux Elf_Verdaux;
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
 

lib/ObjectYAML/ELFYAML.cpp

 
 static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Info", Section.Info);
 }
 
+static void sectionMapping(IO &IO, ELFYAML::StackSizesSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Content", Section.Content);
+  IO.mapOptional("Entries", Section.Entries);
+}
+
 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Size", Section.Size, Hex64(0));
 }
 
 static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Info", Section.Info);
case ELF::SHT_GNU_verneed:
     sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
     break;
   case ELF::SHT_SYMTAB_SHNDX:
     if (!IO.outputting())
       Section.reset(new ELFYAML::SymtabShndxSection());
     sectionMapping(IO, *cast<ELFYAML::SymtabShndxSection>(Section.get()));
     break;
   default:
-    if (!IO.outputting())
-      Section.reset(new ELFYAML::RawContentSection());
-    sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
+    if (!IO.outputting()) {
+      StringRef Name;
+      IO.mapOptional("Name", Name, StringRef());
+
+      if (ELFYAML::StackSizesSection::nameMatches(Name))
+        Section = std::make_unique<ELFYAML::StackSizesSection>();
+      else
+        Section = std::make_unique<ELFYAML::RawContentSection>();
+    }
+
+    if (auto S = dyn_cast<ELFYAML::RawContentSection>(Section.get()))
+      sectionMapping(IO, *S);
+    else
+      sectionMapping(IO, *cast<ELFYAML::StackSizesSection>(Section.get()));
   }
 }
 
 StringRef MappingTraits<std::unique_ptr<ELFYAML::Section>>::validate(
     IO &io, std::unique_ptr<ELFYAML::Section> &Section) {
-  const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(Section.get());
-  if (!RawSection)
-    return {};
+  if (const auto *RawSection =
+          dyn_cast<ELFYAML::RawContentSection>(Section.get())) {
     if (RawSection->Size && RawSection->Content &&
         (uint64_t)(*RawSection->Size) < RawSection->Content->binary_size())
       return "Section size must be greater than or equal to the content size";
     return {};
   }
 
+  if (const auto *SS = dyn_cast<ELFYAML::StackSizesSection>(Section.get())) {
+    if (SS->Content && SS->Entries)
+      return ".stack_sizes can't have both Content and Entries tags";
+    if (!SS->Content && !SS->Entries)
+      return ".stack_sizes: Content and Entries cannot be used together";
+    return {};
+  }
+  return {};
+}
+
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
         Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
         Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
         SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF)) {}
struct NormalizedMips64RelType {
   ELFYAML::ELF_REL Type;
   ELFYAML::ELF_REL Type2;
   ELFYAML::ELF_REL Type3;
   ELFYAML::ELF_RSS SpecSym;
 };
 
 } // end anonymous namespace
 
+void MappingTraits<ELFYAML::StackSizeEntry>::mapping(
+    IO &IO, ELFYAML::StackSizeEntry &E) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapOptional("Address", E.Address, Hex64(0));
+  IO.mapRequired("Size", E.Size);
+}
+
 void MappingTraits<ELFYAML::DynamicEntry>::mapping(IO &IO,
                                                    ELFYAML::DynamicEntry &Rel) {
   assert(IO.getContext() && "The IO context is not initialized");
 
   IO.mapRequired("Tag", Rel.Tag);
   IO.mapRequired("Value", Rel.Val);
 }
 

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

FileHeader:
   Machine: EM_X86_64
 Sections:
   - Name:    .text
     Type:    SHT_PROGBITS
     Flags:   [SHF_ALLOC]
     Size:    16
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
-    Size:    1
+    Content: "00"
     Link:    .text
   - Name:    .rela.stack_sizes
     Type:    SHT_RELA
     Info:    .stack_sizes
     Relocations:
       - Offset: 1
         Symbol: foo 
         Type:   R_X86_64_64
FileHeader:
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .text
     Type: SHT_PROGBITS
     Size: 16
   - Name: .stack_sizes
     Type: SHT_PROGBITS
-    Size: 9
+    Entries:
+      - Size: 0
     Link: .text
   - Name: .rela.stack_sizes
     Type: SHT_RELA
     Info: .stack_sizes
     Relocations:
       - Offset: 0
         Symbol: foo 
         Type:   R_X86_64_64
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:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Content: ""
+    Link:    .text
   - Name: .rela.stack_sizes
     Type: SHT_RELA
     Info: .stack_sizes
     Relocations:
       - Offset: 0
         Symbol: foo 
         Type:   R_X86_64_RELATIVE
 Symbols:

test/tools/obj2yaml/elf-stack-sizes.yaml

+## Check how obj2yaml produce YAML .stack_sizes descriptions.
+
+## Check that obj2yaml uses `Entries` tag to describe .stack_sizes section
+## when it can extract <address, size> pairs.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: obj2yaml %t1 | FileCheck %s --check-prefix=VALID
+
+# VALID:      --- !ELF
+# VALID-NEXT: FileHeader:
+# VALID-NEXT:   Class:   ELFCLASS64
+# VALID-NEXT:   Data:    ELFDATA2LSB
+# VALID-NEXT:   Type:    ET_EXEC
+# VALID-NEXT:   Machine: EM_X86_64
+# VALID-NEXT: Sections:
+# VALID-NEXT:   - Name: .stack_sizes
+# VALID-NEXT:     Type: SHT_PROGBITS
+# VALID-NEXT:     Entries:
+# VALID-NEXT:       - Address: 0x0000000000000010
+# VALID-NEXT:         Size:    0x0000000000000020
+# VALID-NEXT:       - Address: 0x0000000000000030
+# VALID-NEXT:         Size:    0x0000000000000040
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Content: "100000000000000020300000000000000040"
+
+## Check that obj2yaml uses `Content` tag to describe .stack_sizes section
+## when can't extract the entries. For example, when section data is truncated.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=INVALID
+
+# INVALID:      --- !ELF
+# INVALID-NEXT: FileHeader:
+# INVALID-NEXT:   Class:   ELFCLASS64
+# INVALID-NEXT:   Data:    ELFDATA2LSB
+# INVALID-NEXT:   Type:    ET_EXEC
+# INVALID-NEXT:   Machine: EM_X86_64
+# INVALID-NEXT: Sections:
+# INVALID-NEXT:   - Name:    .stack_sizes
+# INVALID-NEXT:     Type:    SHT_PROGBITS
+# INVALID-NEXT:     Content: '1000000000000000203000000000000000'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Content: "1000000000000000203000000000000000"
+
+## Check obj2yaml can dump the empty .stack_sizes.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: obj2yaml %t3 | FileCheck %s --check-prefix=EMPTY
+
+# EMPTY:      --- !ELF
+# EMPTY-NEXT: FileHeader:
+# EMPTY-NEXT:   Class:   ELFCLASS64
+# EMPTY-NEXT:   Data:    ELFDATA2LSB
+# EMPTY-NEXT:   Type:    ET_EXEC
+# EMPTY-NEXT:   Machine: EM_X86_64
+# EMPTY-NEXT: Sections:
+# EMPTY-NEXT:   - Name:    .stack_sizes
+# EMPTY-NEXT:     Type:    SHT_PROGBITS
+# EMPTY-NEXT:     Content: ''
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Content: ""

test/tools/yaml2obj/elf-stack-sizes.yaml

+## Check how yaml2obj produces .stack_sizes sections.
+
+## The first test:
+## 1) Shows we can produce a .stack_sizes section from the description with
+##    a valid section content.
+## 2) Shows we can produce a incorrect .stack_sizes section from the description with
+##    a broken (truncated) section content.
+## 3) Shows we can produce an empty .stack_sizes section from the description with
+##    an empty section content.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s
+
+## Case 1: a valid content is used.
+# CHECK:      Section {
+# CHECK:        Index: 1
+# CHECK-NEXT:   Name: .stack_sizes (1)
+# CHECK-NEXT:   Type: SHT_PROGBITS (0x1)
+# CHECK-NEXT:   Flags [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Address: 0x0
+# CHECK-NEXT:   Offset: 0x40
+# CHECK-NEXT:   Size: 9
+# CHECK-NEXT:   Link: 0
+# CHECK-NEXT:   Info: 0
+# CHECK-NEXT:   AddressAlignment: 0
+# CHECK-NEXT:   EntrySize: 0
+# CHECK-NEXT:   SectionData (
+# CHECK-NEXT:     0000: 10000000 00000000 20
+# CHECK-NEXT:   )
+# CHECK-NEXT: }
+
+## Case 2: a truncated content is used.
+# CHECK:      Name: .stack_sizes
+# CHECK:      Size:
+# CHECK-SAME: 8
+# CHECK:      SectionData (
+# CHECK-NEXT:  0000: 10000000 00000000
+
+## Case 3: an empty content is used.
+# CHECK:      Name: .stack_sizes
+# CHECK:      Size:
+# CHECK-SAME: 0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+## Valid.
+  - Name:    '.stack_sizes [1]'
+    Type:    SHT_PROGBITS
+    Content: "100000000000000020"
+## Truncated.
+  - Name:    '.stack_sizes [2]'
+    Type:    SHT_PROGBITS
+    Content: "1000000000000000"
+## Empty.
+  - Name:    '.stack_sizes [3]'
+    Type:    SHT_PROGBITS
+    Content: ""
+
+## Check we can describe .stack_sizes section using <address, size> pairs.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-readobj --sections --section-data %t2 | FileCheck %s --check-prefix=ENTRIES-BOTH
+
+# ENTRIES-BOTH:      Name: .stack_sizes
+# ENTRIES-BOTH:      SectionData (
+# ENTRIES-BOTH-NEXT:  0000: 10000000 00000000 20300000 00000000 |
+# ENTRIES-BOTH-NEXT:  0010: 0040                                |
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Entries:
+      - Address: 0x10
+        Size:    0x20
+      - Address: 0x30
+        Size:    0x40
+
+## Check we can omit `Address` tag. In this case address part will be zeroed.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-readobj --sections --section-data %t3 | FileCheck %s --check-prefix=ENTRIES-NOADDR
+
+# ENTRIES-NOADDR:      Name: .stack_sizes
+# ENTRIES-NOADDR:      SectionData (
+# ENTRIES-NOADDR-NEXT:  0000: 00000000 00000000 10000000 00000000 |
+# ENTRIES-NOADDR-NEXT:  0010: 0020                                |
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Entries:
+       - Size: 0x10
+       - Size: 0x20
+
+## Check that `Size` tag is mandatory when we describe .stack_sizes using Entries.
+
+# RUN: not yaml2obj --docnum=4 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-NOSIZE
+
+# ENTRIES-NOSIZE: error: missing required key 'Size'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Entries:
+       - Address: 0x10
+
+## Check we can't use both `Content` and `Entries` tags at the same time.
+
+# RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-AND-CONTENT
+
+# ENTRIES-AND-CONTENT: error: .stack_sizes can't have both Content and Entries tags
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .stack_sizes
+    Type:    SHT_PROGBITS
+    Content: "00"
+    Entries:
+      - Address: 0x10
+        Size:    0x20
+
+## Check we must specify either `Content` or `Entries` tag when describe .stack_sizes.
+
+# RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=NO-TAGS
+
+# NO-TAGS: error: .stack_sizes: Content and Entries cannot be used together
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name: .stack_sizes
+    Type: SHT_PROGBITS

tools/obj2yaml/elf2yaml.cpp

 //===------ utils/elf2yaml.cpp - obj2yaml conversion tool -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
+#include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/YAMLTraits.h"
 
 using namespace llvm;
 
 namespace {
 
 template <class ELFT>
class ELFDumper {
   Expected<ELFYAML::SymtabShndxSection *>
   dumpSymtabShndxSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerdefSection *> dumpVerdefSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
   Expected<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
+  Expected<ELFYAML::StackSizesSection *>
+  dumpStackSizesSection(const Elf_Shdr *Shdr);
+
+  Expected<ELFYAML::Section *> dumpSpecialSection(const Elf_Shdr *Shdr);
 
 public:
   ELFDumper(const object::ELFFile<ELFT> &O);
   Expected<ELFYAML::Object *> dump();
 };
 
 }
 
case ELF::SHT_NULL: {
         const uint8_t *Begin = reinterpret_cast<const uint8_t *>(&Sec);
         const uint8_t *End = Begin + sizeof(Elf_Shdr);
         if (std::find_if(Begin, End, [](uint8_t V) { return V != 0; }) == End)
           break;
       }
       LLVM_FALLTHROUGH;
     }
     default: {
+      // Recognize some special SHT_PROGBITS sections by name.
+      if (Sec.sh_type == ELF::SHT_PROGBITS) {
+        Expected<ELFYAML::Section *> SpecialSecOrErr = dumpSpecialSection(&Sec);
+        if (!SpecialSecOrErr)
+          return SpecialSecOrErr.takeError();
+        if (*SpecialSecOrErr) {
+          Y->Sections.emplace_back(*SpecialSecOrErr);
+          break;
+        }
+      }
+
       Expected<ELFYAML::RawContentSection *> SecOrErr =
           dumpContentSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Sections.emplace_back(*SecOrErr);
     }
     }
   }
if (!NameOrErr)
       return NameOrErr.takeError();
     S.Link = NameOrErr.get();
   }
 
   return Error::success();
 }
 
 template <class ELFT>
+Expected<ELFYAML::Section *>
+ELFDumper<ELFT>::dumpSpecialSection(const Elf_Shdr *Shdr) {
+  auto NameOrErr = getUniquedSectionName(Shdr);
+  if (!NameOrErr)
+    return NameOrErr.takeError();
+
+  if (ELFYAML::StackSizesSection::nameMatches(*NameOrErr))
+    return dumpStackSizesSection(Shdr);
+  return nullptr;
+}
+
+template <class ELFT>
 Error ELFDumper<ELFT>::dumpCommonRelocationSection(
     const Elf_Shdr *Shdr, ELFYAML::RelocationSection &S) {
   if (Error E = dumpCommonSection(Shdr, S))
     return E;
 
   auto InfoSection = Obj.getSection(Shdr->sh_info);
   if (!InfoSection)
     return InfoSection.takeError();
 
   auto NameOrErr = getUniquedSectionName(*InfoSection);
   if (!NameOrErr)
     return NameOrErr.takeError();
   S.RelocatableSec = NameOrErr.get();
 
   return Error::success();
 }
 
 template <class ELFT>
+Expected<ELFYAML::StackSizesSection *>
+ELFDumper<ELFT>::dumpStackSizesSection(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::StackSizesSection>();
+  if (Error E = dumpCommonSection(Shdr, *S))
+    return std::move(E);
+
+  auto ContentOrErr = Obj.getSectionContents(Shdr);
+  if (!ContentOrErr)
+    return ContentOrErr.takeError();
+
+  ArrayRef<uint8_t> Content = *ContentOrErr;
+  DataExtractor Data(Content, Obj.isLE(), ELFT::Is64Bits ? 8 : 4);
+
+  std::vector<ELFYAML::StackSizeEntry> Entries;
+  DataExtractor::Cursor Cur(0);
+  while (Cur && Cur.tell() < Content.size()) {
+    uint64_t Address = Data.getAddress(Cur);
+    uint64_t Size = Data.getULEB128(Cur);
+    Entries.push_back({Address, Size});
+  }
+
+  if (Content.empty() || !Cur) {
+    // If .stack_sizes cannot be decoded, we dump it as an array of bytes.
+    consumeError(Cur.takeError());
+    S->Content = yaml::BinaryRef(Content);
+  } else {
+    S->Entries = std::move(Entries);
+  }
+
+  return S.release();
+}
+
+template <class ELFT>
 Expected<ELFYAML::DynamicSection *>
 ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::DynamicSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(Shdr);
   if (!DynTagsOrErr)