[ObjectYAML][DWARF] Add DWARF entry in ELFYAML.

[Higuoxing]

Summary

This patch adds a new DWARF entry in ELF YAML file. Sections emitting will be added in next series of patches.

---

The basic idea is that we treat these debug sections as implicit sections like .strtab/.symtab. In future, reportError() will be replaced by initDWARFSectionHeader() for emitting the content.

[grimar]

I think I'd like to see at least one DWARF section implemented to demonstrate that the concept works.

llvm/lib/ObjectYAML/DWARFYAML.cpp

26

It can return the vector of StringRefs. Perhaps it can be called just "getSectionNames" for simplicity.

28

DebugStrings.size() != 0 -> !DebugStrings.empty() here and below.

36

Why this is !DWARF.PubNames.Entries and not !DWARF.PubNames?
(The same question for things around).

llvm/lib/ObjectYAML/ELFEmitter.cpp

270

Do not use auto when a type is not obvious.

271

Doesn't this create a temporary std::string that is destroyed after the push_back
(and so ImplicitSections holds the dead string as a result)?

407

Why do you need && !YAMLSec?

llvm/test/tools/yaml2obj/ELF/unimplemented-debug-sections.test

1 ↗

(On Diff #264853)

unimplemented-debug-sections.test is a name that assumes this file will be renamed/removed later.
I do not think it is common to do such things. It could be just "debug-sections.test".

Perhaps, we should create a "ELF/DWARF" subfolder and create a separate test for each section. I am not sure, lets hear from others.

[Higuoxing]

Addressed comments:

• Use std::vector<>::empty().
• Use StringRef.
• Support emitting .debug_str section.
• Add a new directory ELF/DWARF for test cases.

[Higuoxing]

llvm/lib/ObjectYAML/ELFEmitter.cpp

407

We have some DebugInfo test cases using yaml2obj to generate debug sections via raw content.

[Higuoxing]

.

[Higuoxing]

llvm/lib/ObjectYAML/DWARFYAML.cpp

36

Because Data possesses PubNames directly, rather than Optional<PubNames>.

struct PubNames {
  ...
  std::vector<PubEntry> Entries;
};

struct Data {
  PubSection PubNames;
};

Can I fix it in the next patch?

[Higuoxing]

Seems that this patch breaks test, I will look into it.

[jhenderson]

Thanks for the patch. In general, it looks like the right approach.

llvm/lib/ObjectYAML/DWARFYAML.cpp

26

DWARFYAML is already used in Mach-O, so we might need to be careful with code like this that is ELF-specific. If we can add a property to the class that says what file format it is, that'll allow us to change the function name to getSectionNames as suggested, and provide a way to make this sort of function generic in the future, should the need arise.

Actually, I might suggest getUsedSectionNames, since it doesn't return all section names all the time.

llvm/lib/ObjectYAML/ELFEmitter.cpp

764

I don't know if it's needed in this patch, but we might want an error if a user tries to specify both Content/Size and DWARF data for a DWARF section.

An alternative, but I don't think it is necessary without a use-case, would be to do something like append the two.

778

Maybe this can just result in an empty section rather than an error?

llvm/test/tools/yaml2obj/ELF/DWARF/debug-info.yaml

3 ↗

(On Diff #265128)

You can get rid of the "a) ". On its own, it doesn't really make sense.

16–21 ↗

(On Diff #265128)

Maybe worth just omitting the body here, since it isn't actually used, if I'm right.

22 ↗

(On Diff #265128)

Here and in all other cases, you don't need the ....

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

2

In addition to the test cases in this file already, you need the following, I think:

a) Size is explicitly specified.
b) Both Size and DWARF->debug_str are specified
c) Both Content and DWARF->debug_str are specified
d) All properties that can be overridden by the section header (e.g. EntSize, Flags etc) when DWARF->debug_str is used.
e) The default values of Flags, EntSize etc when DWARF->debug_str is not used.
f) All properties that can be overridden by the section header (e.g. EntSize, Flags etc) when DWARF->debug_str is not used.
g) Something show that assignSectionAddresses is called.

6

I'd like to hear other people's opinions on this:

Presumably one of the reasons we are adding this support is because in the future, we'd like to write llvm-dwarfdump tests by using yaml2obj, but if we do that, we end up in a bit of a circular dependency, as we are using llvm-dwarfdump to test yaml2obj. That could result in a bug in the common library that results in both appearing to produce the right data, but actually it not being correct.

For .debug_str, it would be trivial to use other options, like llvm-readobj's --section-data or --string-dump options. I don't think this would work as well for other sections though, so maybe the circular dependency is okay? Thoughts?

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

778

In fact, looking at the test cases that are still failing, I think that's exactly what we need to do. Since you zero the section header, you probably can just delete this else.

[grimar]

llvm/lib/ObjectYAML/DWARFYAML.cpp

36

OK. I wonder if we could start from having 2 just sections here for start: ".debug_str" and ".debug_info"
since seems other lines here arenot needed for this patch?

llvm/lib/ObjectYAML/ELFEmitter.cpp

758

I'd move it below, it is a bit too far from the place where RawSec is used first time.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

6

I don't think this would work as well for other sections though, so maybe the circular dependency is okay? Thoughts?

As far I understand, we have no much options. lib/DebugInfo is underlying layer used by llvm-dwarfdump, llvm-objdump to
dump the debug data (I believe). I'd try to use llvm-readobj's --section-data or other options where possible, like you suggest,
but it seems OK to use llvm-dwarfdump for other cases to me.

Partially I guess this problem will be solved by obj2yaml when it will be able to dump debug sections.
I.e. I expect that it might be able to catch some things after dumping objects produced by yaml2obj as probably will use some
independent code for dumping.

[grimar]

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

6

For .debug_str, it would be trivial to use other options, like llvm-readobj's --section-data or --string-dump options.

I think we should do it. And anyways llvm-readelf is already used below for --section-headers

[Higuoxing]

Thanks for reviewing and giving me useful suggestions.

---

Addressed comments.

• Get rid of unimplemented debug sections in getUsedSectionNames(), so that we don't need to process them in initImplicitSections().
• Use generateContentsFromDWARFEntry() to generate section contents from "DWARF" entry. If the contents are successfully generated for "DWARF" entry, it returns true, otherwise, it returns false.
• Use llvm-readelf in tests.
• Remove test for .debug_info section. ("debug_info" entry can be parsed, but will not be emitted.)
• Add tests
  • c) Generate the .debug_str section when the "Size" is specified.
  • d) Test that yaml2obj emits an error message when both the "Size" and the "debug_str" entry at the same time.
  • e) Test that yaml2obj emits an error message when both the "Content" and the "debug_str" entry at the same time.
  • f) Test that all the properties can be overriden by the section header when the "debug_str" entry is used.
  • g) Test that all the properties can be overriden by the section header when the "debug_str" entry doesn't exist.
  • h) Check the default values of sh_entsize, sh_flags, sh_info and sh_addralign when the "debug_str" entry doesn't exist.
  • i) Set the address for the .debug_str section when the "debug_str" entry exists.
  • j) Set the address for the .debug_str section when the "debug_str" doesn't exists.

[Higuoxing]

llvm/lib/ObjectYAML/ELFEmitter.cpp

228

This allocator is from D79984, I will rebase this patch after that.

[jhenderson]

Thanks. I've mostly got test comments for you.

llvm/lib/ObjectYAML/ELFEmitter.cpp

271

If I'm not mistaken, StringRef + const char * results in a Twine, so you probably can just do ("." + DebugSecName).str() without the explicit Twine.

789

Would this be better if it were more explicit? Something like: "initDWARFSectionHeader() should only be called if something describes the section".

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

17

Let's be more preceise with our prefix names, e.g. "SHDRS" here, "DWARF-DEFAULT" above.

37

I think you should get rid of the Flags property below and show the section header details here. That way, you'll show what the default flag properties are if the DWARF tag is not specified.

54

You probably want to show that the content of the section is all zero too. You can use the --hex-dump switch if needed for that, or the od tool.

110

overriden -> overridden

Same elsewhere.

133–134

I think another set of interesting tests would be when the DWARF tag exists, but no debug_str entry is specified. I also think it would be interesting to show that no .debug_str section is generated if the DWARF tag is used, but no debug_str entry is specified within it or the Sections tag.

160–161

I think you can merge this test case with case b) above (if you drop the flags bit).

179

Fold this in with the similar test cases for sh_entsize etc.

201

Ditto.

[grimar]

I am looking. Going to suggest a few little changes in the code a bit later today.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

775

FTR: You should probably use YAMLSec->Offset here instad of "None" to allow setting any offset using the "Offset" section key. (And this needs a test case). I think for this patch you can leave it as is though.

789

It should not be llvm_unreachable, because it is possible to reach it using the following input:

--- !ELF
FileHeader:
  Class:   ELFCLASS64
  Data:    ELFDATA2LSB
  Type:    ET_EXEC
  Machine: EM_X86_64
Sections:
  - Name:    .debug_str
    Type:    SHT_DYNAMIC
    Flags:   [SHF_MERGE, SHF_STRINGS]
    Content: "610062006300"
DWARF:

(I guess it could be a error instead for start).

805

I'd suggest the following code change:

static bool shouldEmitDWARF(Optional<DWARFYAML::Data> DWARF,
                            StringRef SecName) {
  return StringSwitch<bool>(SecName)
      .Case(".debug_str", !DWARF->DebugStrings.empty())
      .Default(false);
}

template <class ELFT>
static uint64_t emitDWARF(typename ELFT::Shdr &SHeader, StringRef Name,
                          const DWARFYAML::Data &DWARF, raw_ostream &OS) {
  uint64_t BeginOffset = OS.tell();
  if (Name == ".debug_str")
    DWARFYAML::EmitDebugStr(OS, DWARF);
  else
    llvm_unreachable("unexpected emitDWARF() call");
  return OS.tell() - BeginOffset;
}

template <class ELFT>
void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                            ContiguousBlobAccumulator &CBA,
                                            ELFYAML::Section *YAMLSec) {
  zero(SHeader);
  SHeader.sh_name = DotShStrtab.getOffset(ELFYAML::dropUniqueSuffix(Name));
  SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_PROGBITS;
  SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
  SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, /*Offset=*/None);

  ELFYAML::RawContentSection *RawSec =
      dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
  if (Doc.DWARF && shouldEmitDWARF(*Doc.DWARF, Name)) {
    if (RawSec && (RawSec->Content || RawSec->Size))
      reportError("cannot specify the '" + Name +
                  "' section contents in the 'DWARF' entry and the 'Content' "
                  "or 'Size' in the 'Sections' entry at the same time");
    else
      SHeader.sh_size = emitDWARF<ELFT>(SHeader, Name, *Doc.DWARF, CBA.getOS());
  } else if (RawSec) {
    SHeader.sh_size = writeContent(CBA.getOS(), RawSec->Content, RawSec->Size);
  } else {
    reportError("not supported"); // ??
  }

....

Benefits are:

1. sh_size is set in a single place.
2. "cannot specify the ...Content/SIze ..." error is reported before emitting the DWARF data and not after.
3. no need to have generateContentsFromDWARFEntry member.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

805

BTW, you even can avoid having the

static bool shouldEmitDWARF(Optional<DWARFYAML::Data> DWARF,
                            StringRef SecName) {
  return StringSwitch<bool>(SecName)
      .Case(".debug_str", !DWARF->DebugStrings.empty())
      .Default(false);
}

Because getUsedSectionNames() provides you all information needed
to avoid checking !DWARF->DebugStrings.empty() here again (it seems).
Perhaps `getUsedSectionNames() could return MapVector<StringRef> and you could
do something like:

static bool shouldEmitDWARF(Optional<DWARFYAML::Data> DWARF,
                            StringRef SecName) {
  MapVector<StringRef> M = DWARF.getUsedSectionNames();
  if (!SecName.empty() && SecName[0] == '.' && M.count(SecName.drop_front())
    return true;
  return false;
}

[Higuoxing]

Addressed comments:

[ObjectYAML]

• Support adjusting section offset via YAMLSec->Offset
• Replace llvm_unreachable by reportError() and add one testcase (i) for it.
• Thanks for @grimar 's suggestion
  • Add two helper functions: shouldEmitDWARF(), emitDWARF().
  • Change the return type of getUsedSectionNames() to SetVector<>

[Test]

• Use precise check tags.
• Merge some testcases
• Add test for 'offset' property in (g) and (f).
• Add one test (h).
  • .debug_str is defined in the "Sections" entry, but with SHT_DYNAMIC tag.
• Add one test (i).
  • Only the "DWARF" entry exists. yaml2obj will not emit the .debug_str section.
• Use llvm-readelf --hex-dump to check the content of zeros.

[grimar]

LGTM with 2 last comments addressed.

Please wait for @jhenderson approvement too.

llvm/lib/ObjectYAML/ELFEmitter.cpp

158

You do not need to make emitDWARF to be a member. It can be just a static helper function.

753

Just

return (!Name.empty() && Name[0] == '.' && DebugSecNames.count(Name.drop_front()));

Perhaps also worth adding a comment. I guess for people who are unfamilar with what is going on here
it might be not that easy to understand the logic.

[MaskRay]

llvm/lib/ObjectYAML/ELFEmitter.cpp

751

return Name.consume_front(".") && DebugSecnames.count(Name);

784

Use "section '" + Name + "' " and omit the

ditto below

792

We usually use ("section '" + Name + "' " + ...

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

16

--section-headers is very common and people tend to recognize -S

192

FileCheck /dev/null --implicit-check-not=.debug_str

[Higuoxing]

Address comments.

• Make emitDWARF() be a static helper function.
• Simplify the logic inside shouldEmitDWARF()
• Use llvm-readelf -S rather than llvm-readelf --section-headers
• Make error messages be consistent with others.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

790–791

Probably I'd say "can only be initialized via the 'DWARF' entry or a section's 'Content' or 'Size' fields"

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

2

g) Something show that assignSectionAddresses is called.

I'm not sure I see which test case demonstrates this?

139

We probably want a "Link:" reference too (e.g. "Link: .symtab").

149

It might make slightly more sense for f) and g) to be switched around (have the "base" case before the ones which include more data).

186–187

My instinct says that this should only be an error if we start using something like "Entries:" (for dynamic sections) etc. Otherwise, we cannot test the case where the type of a debug section is one of those kinds of sections (dynamic, relocation etc). Thus the cases below should not be errors:

- Name: .debug_str
  Type: SHT_DYNAMIC
- Name: .debug_str
  Type: SHT_DYNAMIC
  Size: 42
- Name: .debug_str
  Type: SHT_DYNAMIC
  Content: '006f00'

whereas the following would be:

- Name: .debug_str
  Type: SHT_DYNAMIC
  Entries:
   - Tag: DT_NULL
     Value: 0

[Higuoxing]

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

2

The default sh_addr is 0x0000 for .debug_str. Test (f) shows that it's overridden to be 0x2020.

[Higuoxing]

Thanks for reviewing!

---

Addressed comments:

• sh_link can be overridden as well.
• Support generating debug sections from RawContentSection if their sh_type are the preserved one, e.g., SHT_DYNAMIC.
• Reject the input at the lexical level, if the debug section is initialized from non-RawContentSection.

[Higuoxing]

I think this revision needs another round of reviewing, since I change the logic in DWARFYAML.cpp

[jhenderson]

FYI, I'm not working tomorrow, so it'll be Friday before I am able to give further comments. If @grimar approves this before Friday, I'm happy for you to commit and I'll review it post-commit after I'm back.

llvm/lib/ObjectYAML/ELFYAML.cpp

1254

I'd add the following sentence to this comment: "This means they can have other SHT_* type values, but that the special parsing of those types is not supported."

This seems like a reasonable solution to me, but I'm interested to here @grimar's thoughts.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

146

There's a typo: OVERRIEDDEN -> OVERRIDDEN

193

I'm not sure "preserved" makes sense here. Probably you mean "is a type which usually uses a different syntax".

197

I'd avoid using -EMPTY in your suffix name, since -EMPTY is a valid FileCheck suffix. Probably it's okay just to call these cases DYNAMIC1, DYNAMIC2 etc.

199

Did you deliberately not include the DYNAMIC-EMPTY tag here? If so, you need '##'. Same applies in all the other test cases too.

[grimar]

llvm/lib/ObjectYAML/ELFYAML.cpp

1254

If I understand it right, that change means:

1. We are unable to create, for example, SHT_DYNAMIC section named .debug_ anymore.
2. It was done to allow creating .debug_ sections that has sh_type overriden to something, like to SHT_DYNAMIC.

Currently, yaml2obj uses section type to make a specific section mapping. It looks generally more right than checking sections by name (in the ideal world). Unfortunately we have to check section names still. But it is just because they have no dedicated SHT_* types first of all I believe.

And my concern that (2) might be confusing, because the current way we have to override things is to use Sh* fields. E.g:

// This can be used to override the offset stored in the sh_name field.
// It does not affect the name stored in the string table.
Optional<llvm::yaml::Hex64> ShName;

// This can be used to override the sh_offset field. It does not place the
// 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;

// This can be used to override the sh_flags field.
Optional<llvm::yaml::Hex64> ShFlags;

Also, what if we want to create a SHT_RELR section with the type SHT_DYNAMIC?

I think the better way would be to introduce ShType field that would allow to override the sh_type to anything.
(And I believe it can be done in a follow-up patch, no need to support such specific things from the begining).

How does it sound?

[grimar]

llvm/lib/ObjectYAML/ELFYAML.cpp

1254

To clarify.

This will create a dynamic section with the name .debug_str.

- Name: .debug_str
  Type: SHT_DYNAMIC

And this then can be used to create a debug section with the type SHT_DYNAMIC:

- Name: .debug_str
  Type: SHT_PROGBITS
  ShType: SHT_DYNAMIC

[Higuoxing]

llvm/lib/ObjectYAML/ELFYAML.cpp

1254

Thank you @grimar, It sounds reasonable to me since we've already had shName/shSize... fields to override section header. Besides, it's more flexaible to create sections with uncommon properties.

[Higuoxing]

Thanks for @grimar 's suggestion, I revert this revision to the previous one with some small changes.

Changes are listed below.

• The error message is changed to "can only be initialized via the 'DWARF' entry or a section's 'Content' or 'Size' fields"
• Support the modification of the sh_link value.

[grimar]

It looks good, have a last suggestion.
I've tested that all tests in debug-str.yaml pass with it, except --docnum=9, which is fixed to produce the desired (I believe) output.

llvm/lib/ObjectYAML/ELFEmitter.cpp

789

I think you can change this to be unreachable.

If you do the following:

template <class ELFT>
bool ELFState<ELFT>::initImplicitHeader(ContiguousBlobAccumulator &CBA,
                                        Elf_Shdr &Header, StringRef SecName,
                                        ELFYAML::Section *YAMLSec) {
  // Check if the header was already initialized.
  if (Header.sh_offset)
    return false;

  if (SecName.startswith(".debug_")) {
    // If we have, for example, a SHT_DYNAMIC section with the name ".debug_*",
    // we treat it as dynamic section.
    if (YAMLSec && !isa<ELFYAML::RawContentSection>(YAMLSec))
      return false;
    initDWARFSectionHeader(Header, SecName, CBA, YAMLSec);
    return true;
  }
...

(the comment could be better, I think, but shows the idea).

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

198

This should produce the SHT_DYNAMIC section with the name .debug_str, I think. See my suggestion above.

[Higuoxing]

Thanks for reviewing!

Addressed comments

• If we have a ".debug_*" section whose "Type" is a preserved one, e.g. SHT_DYNAMIC, we will treat it as a dynamic section.
• Update test (i).

[grimar]

LGTM with a nit. Thanks!

llvm/lib/ObjectYAML/ELFEmitter.cpp

411

I think instead of "will treat it as a dynamic section" it should say "will not treat it as a debug section",
otherwise it probably sounds like we treat all preserved sections as dynamic.

[jhenderson]

It looks like my last batch of test comments weren't addressed. Please could you post a new patch to fix them all.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

146

It looks like this comment wasn't addressed?

193

This comment wasn't addressed either. "preserved" is not the right word for this sentence ("preserve" means "to keep something from going bad" or "to protect" and similar meanings).

"with a preserved "Type"" -> "with a "Type" with non-standard syntax"

199

This comment wasn't addressed either.

[Higuoxing]

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

146

Should be fixed in D80802. Sorry I didn't notice it here.

197

The check-prefix is changed to DYN-SHDR in my commit. Sorry, I didn't submit a updated-diff before my commit.

[jhenderson]

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

146

For posterity:
D80802 -> D80862

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 /// This file declares classes for handling the YAML representation
 /// of DWARF Debug Info.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECTYAML_DWARFYAML_H
 #define LLVM_OBJECTYAML_DWARFYAML_H
 
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 namespace DWARFYAML {
struct Data {
   PubSection GNUPubNames;
   PubSection GNUPubTypes;
 
   std::vector<Unit> CompileUnits;
 
   std::vector<LineTable> DebugLines;
 
   bool isEmpty() const;
+
+  SetVector<StringRef> getUsedSectionNames() const;
 };
 
 } // end namespace DWARFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor)

llvm/include/llvm/ObjectYAML/ELFYAML.h

 /// of ELF.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECTYAML_ELFYAML_H
 #define LLVM_OBJECTYAML_ELFYAML_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <cstdint>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace ELFYAML {
struct Object {
   std::vector<std::unique_ptr<Chunk>> Chunks;
 
   // Although in reality the symbols reside in a section, it is a lot
   // cleaner and nicer if we read them from the YAML as a separate
   // top-level key, which automatically ensures that invariants like there
   // being a single SHT_SYMTAB section are upheld.
   Optional<std::vector<Symbol>> Symbols;
   Optional<std::vector<Symbol>> DynamicSymbols;
+  Optional<DWARFYAML::Data> DWARF;
 
   std::vector<Section *> getSections() {
     std::vector<Section *> Ret;
     for (const std::unique_ptr<Chunk> &Sec : Chunks)
       if (auto S = dyn_cast<ELFYAML::Section>(Sec.get()))
         Ret.push_back(S);
     return Ret;
   }

llvm/lib/ObjectYAML/DWARFYAML.cpp

 bool DWARFYAML::Data::isEmpty() const {
   return 0 == DebugStrings.size() + AbbrevDecls.size() + ARanges.size() +
                   DebugRanges.size() + PubNames.Entries.size() +
                   PubTypes.Entries.size() + GNUPubNames.Entries.size() +
                   GNUPubTypes.Entries.size() + CompileUnits.size() +
                   DebugLines.size();
 }
 
+SetVector<StringRef> DWARFYAML::Data::getUsedSectionNames() const {
+  SetVector<StringRef> SecNames;
+  if (!DebugStrings.empty())
+    SecNames.insert("debug_str");
+  return SecNames;
+}
+
 namespace yaml {
 
 void MappingTraits<DWARFYAML::Data>::mapping(IO &IO, DWARFYAML::Data &DWARF) {
   auto oldContext = IO.getContext();
   IO.setContext(&DWARF);
   IO.mapOptional("debug_str", DWARF.DebugStrings);
   IO.mapOptional("debug_abbrev", DWARF.AbbrevDecls);
   if (!DWARF.ARanges.empty() || !IO.outputting())
     IO.mapOptional("debug_aranges", DWARF.ARanges);
   if (!DWARF.DebugRanges.empty() || !IO.outputting())
     IO.mapOptional("debug_ranges", DWARF.DebugRanges);
   if (!DWARF.PubNames.Entries.empty() || !IO.outputting())

llvm/lib/ObjectYAML/ELFEmitter.cpp

 //===- yaml2elf - Convert YAML to a ELF object file -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// The ELF component of yaml2obj.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/ObjectYAML/DWARFEmitter.h"
+#include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
void initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                           ContiguousBlobAccumulator &CBA);
   void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
+  void initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
+                              ContiguousBlobAccumulator &CBA,
+                              ELFYAML::Section *YAMLSec);
+  static uint64_t emitDWARF(Elf_Shdr &SHeader, StringRef Name,
+                            const DWARFYAML::Data &DWARF, raw_ostream &OS);
   void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                               std::vector<Elf_Shdr> &SHeaders);
 
   std::vector<Fragment>
   getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,
                    ArrayRef<typename ELFT::Shdr> SHeaders);
 
   void finalizeStrings();
void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::CallGraphProfileSection &Section,
                            ContiguousBlobAccumulator &CBA);
 
   void writeFill(ELFYAML::Fill &Fill, ContiguousBlobAccumulator &CBA);
 
   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 
   void assignSectionAddress(Elf_Shdr &SHeader, ELFYAML::Section *YAMLSec);
-
+  BumpPtrAllocator StringAlloc;
   uint64_t alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
                          llvm::Optional<llvm::yaml::Hex64> Offset);
 
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
 };
 } // end anonymous namespace
Doc.Chunks.insert(
         std::make_unique<ELFYAML::Section>(
             ELFYAML::Chunk::ChunkKind::RawContent, /*IsImplicit=*/true));
 
   std::vector<StringRef> ImplicitSections;
   if (Doc.DynamicSymbols)
     ImplicitSections.insert(ImplicitSections.end(), {".dynsym", ".dynstr"});
   if (Doc.Symbols)
     ImplicitSections.push_back(".symtab");
+  if (Doc.DWARF)
+    for (StringRef DebugSecName : Doc.DWARF->getUsedSectionNames()) {
+      std::string SecName = ("." + DebugSecName).str();
+      ImplicitSections.push_back(StringRef(SecName).copy(StringAlloc));
+    }
   ImplicitSections.insert(ImplicitSections.end(), {".strtab", ".shstrtab"});
 
   // Insert placeholders for implicit sections that are not
   // defined explicitly in YAML.
   for (StringRef SecName : ImplicitSections) {
     if (DocSections.count(SecName))
       continue;
 
bool ELFState<ELFT>::initImplicitHeader(ContiguousBlobAccumulator &CBA,
   else if (SecName == ".strtab")
     initStrtabSectionHeader(Header, SecName, DotStrtab, CBA, YAMLSec);
   else if (SecName == ".shstrtab")
     initStrtabSectionHeader(Header, SecName, DotShStrtab, CBA, YAMLSec);
   else if (SecName == ".dynsym")
     initSymtabSectionHeader(Header, SymtabType::Dynamic, CBA, YAMLSec);
   else if (SecName == ".dynstr")
     initStrtabSectionHeader(Header, SecName, DotDynstr, CBA, YAMLSec);
+  else if (SecName.startswith(".debug_"))
+    initDWARFSectionHeader(Header, SecName, CBA, YAMLSec);
   else
     return false;
 
   LocationCounter += Header.sh_size;
 
   // Override section fields if requested.
   overrideFields<ELFT>(YAMLSec, Header);
   return true;
 }
 
 constexpr StringRef SuffixStart = " (";
void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
   if (YAMLSec && YAMLSec->Flags)
     SHeader.sh_flags = *YAMLSec->Flags;
   else if (Name == ".dynstr")
     SHeader.sh_flags = ELF::SHF_ALLOC;
 
   assignSectionAddress(SHeader, YAMLSec);
 }
 
+static bool shouldEmitDWARF(DWARFYAML::Data &DWARF, StringRef Name) {
+  SetVector<StringRef> DebugSecNames = DWARF.getUsedSectionNames();
+  if (!Name.empty() && Name[0] == '.' && DebugSecNames.count(Name.drop_front()))
+    return true;
+  return false;
+}
+
+template <class ELFT>
+uint64_t ELFState<ELFT>::emitDWARF(Elf_Shdr &SHeader, StringRef Name,
+                                   const DWARFYAML::Data &DWARF,
+                                   raw_ostream &OS) {
+  uint64_t BeginOffset = OS.tell();
+  if (Name == ".debug_str")
+    DWARFYAML::EmitDebugStr(OS, DWARF);
+  else
+    llvm_unreachable("unexpected emitDWARF() call");
+
+  return OS.tell() - BeginOffset;
+}
+
+template <class ELFT>
+void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
+                                            ContiguousBlobAccumulator &CBA,
+                                            ELFYAML::Section *YAMLSec) {
+  zero(SHeader);
+  SHeader.sh_name = DotShStrtab.getOffset(ELFYAML::dropUniqueSuffix(Name));
+  SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_PROGBITS;
+  SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
+  SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign,
+                                    YAMLSec ? YAMLSec->Offset : None);
+
+  ELFYAML::RawContentSection *RawSec =
+      dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
+  if (Doc.DWARF && shouldEmitDWARF(*Doc.DWARF, Name)) {
+    if (RawSec && (RawSec->Content || RawSec->Size))
+      reportError("cannot specify the '" + Name +
+                  "' section contents in the 'DWARF' entry and the 'Content' "
+                  "or 'Size' in the 'Sections' entry at the same time");
+    else
+      SHeader.sh_size = emitDWARF(SHeader, Name, *Doc.DWARF, CBA.getOS());
+  } else if (RawSec)
+    SHeader.sh_size = writeContent(CBA.getOS(), RawSec->Content, RawSec->Size);
+  else
+    reportError("the '" + Name +
+                "' section can only be initialized from the 'DWARF' entry or "
+                "the raw content section");
+
+  if (YAMLSec && YAMLSec->EntSize)
+    SHeader.sh_entsize = *YAMLSec->EntSize;
+  else if (Name == ".debug_str")
+    SHeader.sh_entsize = 1;
+
+  if (RawSec && RawSec->Info)
+    SHeader.sh_info = *RawSec->Info;
+
+  if (YAMLSec && YAMLSec->Flags)
+    SHeader.sh_flags = *YAMLSec->Flags;
+  else if (Name == ".debug_str")
+    SHeader.sh_flags = ELF::SHF_MERGE | ELF::SHF_STRINGS;
+
+  assignSectionAddress(SHeader, YAMLSec);
+}
+
 template <class ELFT> void ELFState<ELFT>::reportError(const Twine &Msg) {
   ErrHandler(Msg);
   HasError = true;
 }
 
 template <class ELFT>
 std::vector<Fragment>
 ELFState<ELFT>::getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,

llvm/lib/ObjectYAML/ELFYAML.cpp

if (IO.outputting()) {
 
     IO.mapRequired("Type", Type);
   }
 
   switch (Type) {
   case ELF::SHT_DYNAMIC:
     if (!IO.outputting())
       Section.reset(new ELFYAML::DynamicSection());
     sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
     break;
   case ELF::SHT_REL:
   case ELF::SHT_RELA:
     if (!IO.outputting())
       Section.reset(new ELFYAML::RelocationSection());
     sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
     break;
   case ELF::SHT_RELR:
void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   assert(!IO.getContext() && "The IO context is initialized already");
   IO.setContext(&Object);
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Chunks);
   IO.mapOptional("Symbols", Object.Symbols);
   IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
+  IO.mapOptional("DWARF", Object.DWARF);
   IO.setContext(nullptr);
 }
 
 void MappingTraits<ELFYAML::LinkerOption>::mapping(IO &IO,
                                                    ELFYAML::LinkerOption &Opt) {
   assert(IO.getContext() && "The IO context is not initialized");
   IO.mapRequired("Name", Opt.Key);
   IO.mapRequired("Value", Opt.Value);

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str.yaml

+## Test that yaml2obj emits .debug_str section.
+
+## a) Generate the .debug_str section from the "DWARF" entry.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1.o
+# RUN: llvm-readelf --string-dump=.debug_str %t1.o | FileCheck %s --check-prefix=DWARF-DEFAULT
+
+#      DWARF-DEFAULT: String dump of section '.debug_str':
+# DWARF-DEFAULT-NEXT: [     0] a
+# DWARF-DEFAULT-NEXT: [     2] b
+# DWARF-DEFAULT-NEXT: [     4] c
+
+## Check the default sh_type, sh_entsize, sh_info, sh_flags and sh_addralign of the
+## .debug_str section header.
+
+# RUN: llvm-readelf --section-headers %t1.o | FileCheck %s --check-prefix=SHDRS-DEFAULT
+
+#                Name       Type     Address          Offset Size   ES Flg Lk Inf Al
+# SHDRS-DEFAULT: .debug_str PROGBITS 0000000000000000 000040 000006 01 MS  0  0   1
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_str:
+    - a
+    - b
+    - c
+
+## b) Generate the .debug_str section from the raw section content.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2.o
+# RUN: llvm-readelf --string-dump=.debug_str %t2.o | FileCheck %s --check-prefix=DWARF-DEFAULT
+# RUN: llvm-readelf --section-headers %t2.o | FileCheck %s --check-prefix=SHDRS
+
+#        Name       Type     Address          Offset Size   ES Flg Lk Inf Al
+# SHDRS: .debug_str PROGBITS 0000000000000000 000040 000006 01 MS  0  0   0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .debug_str
+    Type:    SHT_PROGBITS
+    Content: "610062006300"
+
+## c) Generate the .debug_str section when the "Size" is specified.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3.o
+# RUN: llvm-readelf --section-headers %t3.o | FileCheck %s --check-prefix=SIZE
+# RUN: llvm-readelf --hex-dump=.debug_str %t3.o | FileCheck %s --check-prefix=SIZE-CONTENT
+
+#       Name       Type     Address          Offset Size   ES Flg Lk Inf Al
+# SIZE: .debug_str PROGBITS 0000000000000000 000040 000010 01 MS  0  0   0
+
+#       SIZE-CONTENT: Hex dump of section '.debug_str':
+#  SIZE-CONTENT-NEXT: 0x00000000 00000000 00000000 00000000 00000000 ................
+# SIZE-CONTENT-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:  .debug_str
+    Type:  SHT_PROGBITS
+    Size:  0x10
+
+## d) Test that yaml2obj emits an error message when both the "Size" and the
+## "debug_str" entry are specified at the same time.
+
+# RUN: not yaml2obj --docnum=4 %s -o %t4.o 2>&1 | FileCheck %s --check-prefix=ERROR
+
+# ERROR: yaml2obj: error: cannot specify the '.debug_str' section contents in the 'DWARF' entry and the 'Content' or 'Size' in the 'Sections' entry at the same time
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:  .debug_str
+    Type:  SHT_PROGBITS
+    Size:  0x10
+DWARF:
+  debug_str:
+    - a
+
+## e) Test that yaml2obj emits an error message when both the "Content" and the
+## "debug_str" entry are specified at the same time.
+
+# RUN: not yaml2obj --docnum=5 %s -o %t5.o 2>&1 | FileCheck %s --check-prefix=ERROR
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .debug_str
+    Type:    SHT_PROGBITS
+    Content: "6100"
+DWARF:
+  debug_str:
+    - a
+
+## f) Test that all the properties can be overridden by the section header when
+## the "debug_str" entry is used.
+
+# RUN: yaml2obj --docnum=6 %s -o %t6.o
+# RUN: llvm-readelf --string-dump=.debug_str %t6.o | FileCheck %s --check-prefix=DWARF-DEFAULT
+# RUN: llvm-readelf --section-headers %t6.o | FileCheck %s --check-prefix=OVERRIDDEN
+
+#             Name       Type   Address          Offset Size   ES Flg Lk Inf Al
+# OVERRIDDEN: .debug_str STRTAB 0000000000002020 000050 000006 02 A   0  1   2
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_str
+    Type:         SHT_STRTAB         # SHT_PROGBITS by default.
+    Flags:        [SHF_ALLOC]        # [SHF_STRINGS, SHF_MERGE] by default.
+    EntSize:      2                  # 1 by default.
+    Info:         1                  # 0 by default.
+    AddressAlign: 2                  # 1 by default.
+    Address:      0x0000000000002020 # 0x00 by default.
+    Offset:       0x00000050         # 0x40 for the first section.
+DWARF:
+  debug_str:
+    - a
+    - b
+    - c
+
+## g) Test that all the properties can be overridden by the section header when
+## the "debug_str" entry doesn't exist.
+
+# RUN: yaml2obj --docnum=7 %s -o %t7.o
+# RUN: llvm-readelf --section-headers %t7.o | FileCheck %s --check-prefix=OVERRIDDEN
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_str
+    Type:         SHT_STRTAB
+    Flags:        [SHF_ALLOC]        # [SHF_STRINGS, SHF_MERGE] by default.
+    EntSize:      2                  # 1 by default.
+    Info:         1                  # 0 by default.
+    AddressAlign: 2                  # 0 by default.
+    Address:      0x0000000000002020 # 0x00 by default.
+    Offset:       0x00000050         # 0x40 for the first section.
+    Size:         6                  # Set the "Size" so that we can reuse the check tag "OVERRIEDDEN"
+
+## h) Test that yaml2obj emits an error message if we initialize the .debug_str section with
+## a preserved type, e.g., SHT_DYNAMIC.
+
+# RUN: not yaml2obj --docnum=8 %s -o %t8.o 2>&1 | FileCheck %s --check-prefix=TYPE-ERROR
+
+# TYPE-ERROR: yaml2obj: error: the '.debug_str' section can only be initialized from the 'DWARF' entry or the raw content section
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name: .debug_str
+    Type: SHT_DYNAMIC
+
+## i) Test that yaml2obj will not generate the .debug_str section when the "DWARF" entry exists
+## but the "debug_str" entry doesn't exist in the "DWARF" entry or the "Sections" entry.
+
+# RUN: yaml2obj --docnum=9 %s -o %t9.o
+# RUN: llvm-readelf --section-headers %t9.o | FileCheck %s --check-prefix=NO-DEBUGSTR --implicit-check-not=.debug_str
+
+# NO-DEBUGSTR: Section Headers:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF: