[DWARFYAML] Implement the .debug_loclists section.

[Higuoxing]

Summary

This patch implements the .debug_loclists section. There are only two
DWARF expressions are implemented in this patch (DW_OP_consts,
DW_OP_stack_value). We will implement more in the future.

The YAML description of the .debug_loclists section is:

debug_loclists:
  - Format:              DWARF32 ## Optional
    Length:              0x1234  ## Optional
    Version:             5       ## Optional (5 by default)
    AddressSize:         8       ## Optional
    SegmentSelectorSize: 0       ## Optional (0 by default)
    OffsetEntryCount:    1       ## Optional
    Offsets:             [ 1 ]   ## Optional
    Lists:
      - Entries:
          - Operator:          DW_LLE_startx_endx
            Values:            [ 0x1234, 0x4321 ]
            DescriptorsLength: 0x1234             ## Optional
            Descriptors:
              - Operator: DW_OP_consts
                Values:   [ 0x1234 ]

[Higuoxing]

llvm/include/llvm/ObjectYAML/DWARFYAML.h

190

There are some operators that take a size and a block of that size. I'm not sure if it's ok to use a std::vector<> here.

[Higuoxing]

I am going to pull out the refactor work to a separate patch.

[Higuoxing]

Pull out refactor works.

[Higuoxing]

Update.

[Higuoxing]

llvm/include/llvm/ObjectYAML/DWARFYAML.h

190

I think we can add a new field called BlockSize which is used to overwrite the size of blocks.

struct DWARFOperation {
  dwarf::LocationAtom Operator;
  Optional<yaml::Hex64> BlockSize;
  std::vector<yaml::Hex64> Values;
};

e.g., DW_OP_implicit_value takes two operands, the first operand is an ULEB128 size, the second operand is a block of that size. We can use std::vector<yaml::Hex64> to hold a series of bytes, and the size of this block can be overwritten by BlockSize.

[labath]

I don't see anything out of the ordinary here, but I'll leave it others to have the final say.

llvm/include/llvm/ObjectYAML/DWARFYAML.h

190

Supporting DW_OP_entry_value is going to be amusing, as that takes an entire nested dwarf expression as an operand. But I think it would be fine even if the nested expression is simply printed in hex (in fact, I would be fine if initially _all_ dwarf expressions are simply printed in hex).

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

23–93

Would it be better to verify this structurally by checking llvm-dwarfdump output ?

[Higuoxing]

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

23–93

Hi @labath, I've tested the generated sections using llvm-dwarfdump on my local machine. We usually check the hex dump of sections to "bootstrap" yaml2obj. You can take a look at this thread :-) https://reviews.llvm.org/D82367#2134629

[labath]

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

23–93

I see. That makes sense. Thanks for the pointer.

[Higuoxing]

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

23–93

I'm wondering if it's helpful to put the output of llvm-dwarfdump in comments. e.g.,

## $ llvm-dwarfdump --debug-loclists -v %t.o
## .debug_loclists contents:
## 0x00000000: locations list header: length = 0x00000023, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000002
## offsets: [
## 0x00000010 => 0x00000024
## 0x0000001a => 0x0000002e
## ]
## 0x00000024: 
##             DW_LLE_startx_endx     (0x0000000000001234, 0x0000000000004321): DW_OP_consts +4660
##             DW_LLE_end_of_list     ()

[jhenderson]

llvm/include/llvm/ObjectYAML/DWARFYAML.h

190

I guess longer-term, we could add another field to a DWARFOperation, that is itself an Optional<DWARFOperation>, to allow for a kind of linked-list approach to the expression. In the YAML, it might look like:

- Entries:
    - Operator:          DW_LLE_startx_endx
      Values:            [ 0x1234, 0x4321 ]
      DescriptorsLength: 0x4321
      Descriptors:
        - Operator: DW_OP_entry_value
          Expression:
            - Operator: DW_OP_entry_value
              Expression:
                - Operator: DW_OP_entry_value
                ...

An operation would only be allowed to have one of Values or Expression in that case. But I think you're right, there's no need to do that now. The behaviour in this patch would be enough for simple cases.

@Higuoxing, I think your idea with an optional BlockSize makes sense to me.

201–202

I think "Descriptions" is the canonical term in the spec, so we should probably stick with that, i.e. use DescriptionsLength and Descriptions.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

445–447

One of the things yaml2obj is useful for is for creating broken ELFs. I see you're adding further checks here to make sure the Values array is the right size for the type. But what if you want to have an incorrect number of values for a given operation?

There are similar issues elsewhere, I'm sure, so I'm not saying this specific patch needs changing at this point, but I do think you need to consider how to solve this case. For example, it might mean being more specific with the type of value by using distinct fields for different types. For example, instead of Values: [0x1234, 0x4321] you might want something like:

Values:
  - Type: SLEB128
    Value: 0x1234
  - Type: Address
    Value: 0x4321

or even:

Values:
  - SLEB128: 0x1234
  - Address: 0x4321

What do you think?

566

These lambdas are very similar to those elsewhere. Maybe you should pull them out into a function.

620

Similar comments apply here to my earlier thoughts regarding checking operands.

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

2

I'll look at the testing more tomorrow.

23–93

I don't have a strong opinion on this either way. One of the problems is that this will rot easily if you make changes/expand the test, or if llvm-dwarfdump changes output slightly. I don't know if it gives any additional benefit beyond the comments.

One possible thought I had is that you could, in addition to the hex testing, add llvm-dwarfdump checks too. The hex check ensures the content is correct, whilst the llvm-dwarfdump check shows a) llvm-dwarfdump is correct, and b) provides a more readable way of showing yaml2obj is correct. If there's a failure in the llvm-dwarfdump check, you'd need to carefully inspect the hex to see if the hex check was wrong (i.e. yaml2obj has a bug) or there's a bug in llvm-dwarfdump. This would probably need some sort of commenting to explain the process. Maybe a readme.txt in the test directory would be enough, I don't know.

[labath]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

445–447

I've been wondering about that too. I personally don't find the ability to add more/less "values" than the appropriate DW_LLE kind expects useful, because the yaml structure will have no relation to how the result ends up being parsed. And the extra info needed to make this operation well-defined makes the yaml more verbose for the normal cases.

What I would find useful is if, at certain strategic levels, it would be possible to insert an arbitrary hex blob instead of fully formed yaml. One such place could be the dwarf expression -- instead of all the DW_OP thingies we could just add a hex blob. That would also give an escape hatch for the obj2yaml path so that it can serialize any DWARF expression with unknown/unsupported opcodes as hex.

Another such level could be the level of an individual location list -- if there's anything funny about the location list, one could put the entire list as hex, even though some parts of it could be valid and representable normally. I think that's fine because this is not likely to be needed often. Or maybe this could apply to an entire debug_loclists contribution. Or both...

At the last level, one could specify the entire section contents as hex, which is sort of what we have now.

[jhenderson]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

445–447

That makes sense to me. There are some cases in the ELF code, where we fall back to using hex section contents for known section types, when the content is unparseable for whatever reason.

[Higuoxing]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

445–447

One of the things yaml2obj is useful for is for creating broken ELFs. I see you're adding further checks here to make sure the Values array is the right size for the type. But what if you want to have an incorrect number of values for a given operation?

Sounds good! What about having an additional field called Types. If the Types field is specified, yaml2obj emits values according to the Types array. If it doesn't exist, yaml2obj emits values according to the spec.

- Operator: DW_LLE_startx_endx
  Types:    [ ULEB128, Hex64 ]
  Values:   [ 0x1234, 0x4321 ]

The benefit is that we don't have to specify the Value field every time. The number of operands can also be adjusted via the Types array.

- Operator: DW_LLE_startx_endx
  Types:    [ ULEB128, Hex64, Hex16 ]
  Values:   [ 0x1234, 0x4321, 0x12 ]

[labath]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

445–447

I sort of like that because it leaves the common case succinct, but it still seems like more flexibility than needed. I am not really opposed to that -- I'm sure it can be useful at times -- but I'm not sure the use will be frequent enough to justify the added complexity (you'd still need to handle all the situations when the types array is not specified _and_ also the case where the type array is there). Since yaml tests are typically done by taking obj2yaml output and modifying/reducing it, and obj2yaml will never produce output like that, I'm not sure how many people will even discover it.

Nit: I don't think HexNN is a good name because it bears no relation to how the input is written (one can just as easily write the value array in decimal), and the fact that the output is going to be hex (binary) is kinda obvious. Maybe just IntNN, or SignedNN/UnsignedNN is singedness matters (I don't think it does).

[Higuoxing]

Address comments.

[Higuoxing]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

445–447

Nit: I don't think HexNN is a good name because it bears no relation to how the input is written (one can just as easily write the value array in decimal), and the fact that the output is going to be hex (binary) is kinda obvious. Maybe just IntNN, or SignedNN/UnsignedNN is singedness matters (I don't think it does).

Oh, thanks a lot! I've upload a diff revision D84386 that illustrates my idea. Any thoughts?

[jhenderson]

The DWARF v5 standard explicitly allows for a value of 0 for the offset_entry_count, meaning there are no offset entries. My reading is that this is allowed even if there are location lists, but I don't see any testing for that situation, I think? I believe the same applies for .debug_rnglists, but I haven't looked to see if you implemented that there.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

445–447

I like the approach personally. I've commented more on D84386.

448

It looks like this lambda could be using checkListEntryOperands with a bit of a tweak to that function's name.

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

352

omitted in -> omitted from

427

Missing a comment for the end of list markers in both sequences?

501

I think this case is tested by case e)?

526–527

Looking at this, I think it might be best to test the majority of this in a gtest unit test. It seems like there's a lot of detail that would better fit there. I might be wrong though. What do you think?

[Higuoxing]

Address comments.

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

427

It's not the end_of_list marker, it's a counted location description, whose length is 0.

501

Removed.

526–527

I'm not sure. The number of operands is checked in the section emitting period. The gtest unit testing currently only supports testing the YAML parser.

[Higuoxing]

Remove unrelated changes.

[Higuoxing]

checkOperandsNumber -> checkOperandNumber

[jhenderson]

In D84234#2168873, @jhenderson wrote:

The DWARF v5 standard explicitly allows for a value of 0 for the offset_entry_count, meaning there are no offset entries. My reading is that this is allowed even if there are location lists, but I don't see any testing for that situation, I think? I believe the same applies for .debug_rnglists, but I haven't looked to see if you implemented that there.

I might be missing this, but was this point addressed yet?

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

758–759

Rather than a known value that we one day will likely support, causing this test to be updated, perhaps we should pick a value that isn't supported by the DWARF spec?

[Higuoxing]

• Add test cases u, v, w.

[Higuoxing]

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

758–759

I'm not sure if I'm doing right here. If we pick a value that isn't supported by the DWARF sepc, the error message

yaml2obj: error: DWARF expression: DW_OP_blah is not supported
                                   ^~~~~~~~~~

will be left untested.

[jhenderson]

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

758–759

Ah, I see. Perhaps we should have both then. (One with arbitrary unrecognised hex, and the other using a recognised value which isn't supported).

809

This is fine, but I think an expectation might be that if OffsetEntryCount: 0 is specified, (and not Offsets: []), it would have the same effect.

I think you want two more cases:

1. OffsetEntryCount: 0 and no Offsets key at all (will result in no offsets).
2. OffsetEntryCount: 0 and a non-empty Offsets key (will result in 0 in offset_entry_count, but with offsets).

Does that make sense to you?

[Higuoxing]

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

758–759

I've added one test that use a recognized value DW_OP_entry_value since it might not be implemented recently, so that we don't have to update this test very frequently.

809

Done. But we should land D85006 first.

[Higuoxing]

Address review comments.

Updated tests: (t), (w), (x), (y).

[jhenderson]

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

846–847

Same comments apply here as in D85006.

[Higuoxing]

Address review comments.

Thanks for reviewing!

[Higuoxing]

Seems that there are too many changes since previous revision. Most of the changes are caused by rebase. Only test cases (w), (x), (y) are updated.

[jhenderson]

Looks good to me!

[Higuoxing]

Re-run pre-merge tests.

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

 Error emitDebugRanges(raw_ostream &OS, const Data &DI);
 Error emitPubSection(raw_ostream &OS, const PubSection &Sect,
                      bool IsLittleEndian, bool IsGNUPubSec = false);
 Error emitDebugInfo(raw_ostream &OS, const Data &DI);
 Error emitDebugLine(raw_ostream &OS, const Data &DI);
 Error emitDebugAddr(raw_ostream &OS, const Data &DI);
 Error emitDebugStrOffsets(raw_ostream &OS, const Data &DI);
 Error emitDebugRnglists(raw_ostream &OS, const Data &DI);
+Error emitDebugLoclists(raw_ostream &OS, const Data &DI);
 
 Expected<StringMap<std::unique_ptr<MemoryBuffer>>>
 emitDebugSections(StringRef YAMLString, bool ApplyFixups = false,
                   bool IsLittleEndian = sys::IsLittleEndianHost);
 } // end namespace DWARFYAML
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_DWARFEMITTER_H

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 struct StringOffsetsTable {
   dwarf::DwarfFormat Format;
   Optional<yaml::Hex64> Length;
   yaml::Hex16 Version;
   yaml::Hex16 Padding;
   std::vector<yaml::Hex64> Offsets;
 };
 
+struct DWARFOperation {
+  dwarf::LocationAtom Operator;
+  std::vector<yaml::Hex64> Values;
+};
+
 struct RnglistEntry {
   dwarf::RnglistEntries Operator;
   std::vector<yaml::Hex64> Values;
 };
 
-struct Rnglist {
-  std::vector<RnglistEntry> Entries;
+struct LoclistEntry {
+  dwarf::LoclistEntries Operator;
+  std::vector<yaml::Hex64> Values;
+  Optional<yaml::Hex64> DescriptorLength;
+  std::vector<DWARFOperation> Descriptors;
+};
+
+template <typename EntryType> struct ListEntries {
+  std::vector<EntryType> Entries;
 };
 
-struct RnglistTable {
+template <typename EntryType> struct ListTable {
   dwarf::DwarfFormat Format;
   Optional<yaml::Hex64> Length;
   yaml::Hex16 Version;
   Optional<yaml::Hex8> AddrSize;
   yaml::Hex8 SegSelectorSize;
   Optional<uint32_t> OffsetEntryCount;
   Optional<std::vector<yaml::Hex64>> Offsets;
-  std::vector<Rnglist> Lists;
+  std::vector<ListEntries<EntryType>> Lists;
 };
 
 struct Data {
   bool IsLittleEndian;
   bool Is64BitAddrSize;
   std::vector<Abbrev> AbbrevDecls;
   std::vector<StringRef> DebugStrings;
   Optional<std::vector<StringOffsetsTable>> DebugStrOffsets;
   std::vector<ARange> ARanges;
   std::vector<Ranges> DebugRanges;
   std::vector<AddrTableEntry> DebugAddr;
   Optional<PubSection> PubNames;
   Optional<PubSection> PubTypes;
 
   Optional<PubSection> GNUPubNames;
   Optional<PubSection> GNUPubTypes;
 
   std::vector<Unit> CompileUnits;
 
   std::vector<LineTable> DebugLines;
-  Optional<std::vector<RnglistTable>> DebugRnglists;
+  Optional<std::vector<ListTable<RnglistEntry>>> DebugRnglists;
+  Optional<std::vector<ListTable<LoclistEntry>>> DebugLoclists;
 
   bool isEmpty() const;
 
   SetVector<StringRef> getUsedSectionNames() const;
 };
 
 } // end namespace DWARFYAML
 } // end namespace llvm

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::SegAddrPair)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AddrTableEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::StringOffsetsTable)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::RnglistTable)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Rnglist)
+LLVM_YAML_IS_SEQUENCE_VECTOR(
+    llvm::DWARFYAML::ListTable<DWARFYAML::RnglistEntry>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(
+    llvm::DWARFYAML::ListEntries<DWARFYAML::RnglistEntry>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::RnglistEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(
+    llvm::DWARFYAML::ListTable<DWARFYAML::LoclistEntry>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(
+    llvm::DWARFYAML::ListEntries<DWARFYAML::LoclistEntry>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LoclistEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::DWARFOperation)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<DWARFYAML::Data> {
   static void mapping(IO &IO, DWARFYAML::Data &DWARF);
 };
 

 template <> struct MappingTraits<DWARFYAML::LineTable> {
   static void mapping(IO &IO, DWARFYAML::LineTable &LineTable);
 };
 
 template <> struct MappingTraits<DWARFYAML::SegAddrPair> {
   static void mapping(IO &IO, DWARFYAML::SegAddrPair &SegAddrPair);
 };
 
-template <> struct MappingTraits<DWARFYAML::RnglistTable> {
-  static void mapping(IO &IO, DWARFYAML::RnglistTable &RnglistTable);
+template <> struct MappingTraits<DWARFYAML::DWARFOperation> {
+  static void mapping(IO &IO, DWARFYAML::DWARFOperation &DWARFOperation);
+};
+
+template <typename EntryType>
+struct MappingTraits<DWARFYAML::ListTable<EntryType>> {
+  static void mapping(IO &IO, DWARFYAML::ListTable<EntryType> &ListTable);
 };
 
-template <> struct MappingTraits<DWARFYAML::Rnglist> {
-  static void mapping(IO &IO, DWARFYAML::Rnglist &Rnglist);
+template <typename EntryType>
+struct MappingTraits<DWARFYAML::ListEntries<EntryType>> {
+  static void mapping(IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries);
 };
 
 template <> struct MappingTraits<DWARFYAML::RnglistEntry> {
   static void mapping(IO &IO, DWARFYAML::RnglistEntry &RnglistEntry);
 };
 
+template <> struct MappingTraits<DWARFYAML::LoclistEntry> {
+  static void mapping(IO &IO, DWARFYAML::LoclistEntry &LoclistEntry);
+};
+
 template <> struct MappingTraits<DWARFYAML::AddrTableEntry> {
   static void mapping(IO &IO, DWARFYAML::AddrTableEntry &AddrTable);
 };
 
 template <> struct MappingTraits<DWARFYAML::StringOffsetsTable> {
   static void mapping(IO &IO, DWARFYAML::StringOffsetsTable &StrOffsetsTable);
 };
 
#define HANDLE_DW_RLE(unused, name)                                            \
   io.enumCase(value, "DW_RLE_" #name, dwarf::DW_RLE_##name);
 
 template <> struct ScalarEnumerationTraits<dwarf::RnglistEntries> {
   static void enumeration(IO &io, dwarf::RnglistEntries &value) {
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 };
 
+#define HANDLE_DW_LLE(unused, name)                                            \
+  io.enumCase(value, "DW_LLE_" #name, dwarf::DW_LLE_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::LoclistEntries> {
+  static void enumeration(IO &io, dwarf::LoclistEntries &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+  }
+};
+
+#define HANDLE_DW_OP(id, name, version, vendor)                                \
+  io.enumCase(value, "DW_OP_" #name, dwarf::DW_OP_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::LocationAtom> {
+  static void enumeration(IO &io, dwarf::LocationAtom &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+  }
+};
+
 } // end namespace yaml
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_DWARFYAML_H

llvm/lib/ObjectYAML/DWARFEmitter.cpp

for (uint64_t Offset : Table.Offsets) {
                                          OS, DI.IsLittleEndian));
     }
   }
 
   return Error::success();
 }
 
 static Expected<uint64_t>
-writeRnglistEntry(raw_ostream &OS, const DWARFYAML::RnglistEntry &Entry,
+writeDWARFExpression(raw_ostream &OS,
+                     const DWARFYAML::DWARFOperation &Operation,
                      uint8_t AddrSize, bool IsLittleEndian) {
+  auto CheckOperands = [&](uint64_t ExpectedOperands) -> Error {
+    if (Operation.Values.size() != ExpectedOperands) {
+      return createStringError(
+          errc::invalid_argument,
+          "invalid number (%zu) of operands for the operator: %s, %" PRIu64
+          " expected",
+          Operation.Values.size(),
+          dwarf::OperationEncodingString(Operation.Operator).str().c_str(),
+          ExpectedOperands);
+    }
+
+    return Error::success();
+  };
+
+  uint64_t ExpressionBegin = OS.tell();
+  writeInteger((uint8_t)Operation.Operator, OS, IsLittleEndian);
+  switch (Operation.Operator) {
+  case dwarf::DW_OP_consts:
+    if (Error Err = CheckOperands(1))
+      return std::move(Err);
+    encodeSLEB128(Operation.Values[0], OS);
+    break;
+  case dwarf::DW_OP_stack_value:
+    if (Error Err = CheckOperands(0))
+      return std::move(Err);
+    break;
+  default:
+    return createStringError(
+        errc::not_supported,
+        "DWARF expression: " +
+            dwarf::OperationEncodingString(Operation.Operator) +
+            " is not supported");
+  }
+  return OS.tell() - ExpressionBegin;
+}
+
+static Expected<uint64_t> writeListEntry(raw_ostream &OS,
+                                         const DWARFYAML::RnglistEntry &Entry,
+                                         uint8_t AddrSize,
+                                         bool IsLittleEndian) {
   uint64_t BeginOffset = OS.tell();
   writeInteger((uint8_t)Entry.Operator, OS, IsLittleEndian);
 
   auto CheckOperands = [&](uint64_t ExpectedOperands) -> Error {
     if (Entry.Values.size() != ExpectedOperands) {
       return createStringError(
           errc::invalid_argument,
           "invalid number (%zu) of operands for the operator: %s, %" PRIu64
if (Error Err = WriteAddress(Entry.Values[0]))
       return std::move(Err);
     encodeULEB128(Entry.Values[1], OS);
     break;
   }
 
   return OS.tell() - BeginOffset;
 }
 
-Error DWARFYAML::emitDebugRnglists(raw_ostream &OS, const Data &DI) {
-  assert(DI.DebugRnglists && "unexpected emitDebugRnglists() call");
-  for (const DWARFYAML::RnglistTable &Table : *DI.DebugRnglists) {
+static Expected<uint64_t> writeListEntry(raw_ostream &OS,
+                                         const DWARFYAML::LoclistEntry &Entry,
+                                         uint8_t AddrSize,
+                                         bool IsLittleEndian) {
+  uint64_t BeginOffset = OS.tell();
+  writeInteger((uint8_t)Entry.Operator, OS, IsLittleEndian);
+
+  auto CheckOperands = [&](uint64_t ExpectedOperands) -> Error {
+    if (Entry.Values.size() != ExpectedOperands) {
+      return createStringError(
+          errc::invalid_argument,
+          "invalid number (%zu) of operands for the operator: %s, %" PRIu64
+          " expected",
+          Entry.Values.size(),
+          dwarf::LocListEncodingString(Entry.Operator).str().c_str(),
+          ExpectedOperands);
+    }
+
+    return Error::success();
+  };
+
+  auto WriteAddress = [&](uint64_t Addr) -> Error {
+    if (Error Err =
+            writeVariableSizedInteger(Addr, AddrSize, OS, IsLittleEndian))
+      return createStringError(
+          errc::not_supported,
+          "unable to write address for the operator %s: %s",
+          dwarf::LocListEncodingString(Entry.Operator).str().c_str(),
+          toString(std::move(Err)).c_str());
+    return Error::success();
+  };
+
+  auto WriteDWARFOperations = [&]() -> Error {
+    std::string OpBuffer;
+    raw_string_ostream OpBufferOS(OpBuffer);
+    uint64_t DescriptorLength = 0;
+
+    for (const DWARFYAML::DWARFOperation &Op : Entry.Descriptors) {
+      if (Expected<uint64_t> OpSize =
+              writeDWARFExpression(OpBufferOS, Op, AddrSize, IsLittleEndian))
+        DescriptorLength += *OpSize;
+      else
+        return OpSize.takeError();
+    }
+
+    if (Entry.DescriptorLength)
+      DescriptorLength = *Entry.DescriptorLength;
+    else
+      DescriptorLength = OpBuffer.size();
+
+    encodeULEB128(DescriptorLength, OS);
+    OS.write(OpBuffer.data(), OpBuffer.size());
+
+    return Error::success();
+  };
+
+  switch (Entry.Operator) {
+  case dwarf::DW_LLE_end_of_list:
+    if (Error Err = CheckOperands(0))
+      return std::move(Err);
+    break;
+  case dwarf::DW_LLE_base_addressx:
+    if (Error Err = CheckOperands(1))
+      return std::move(Err);
+    encodeULEB128(Entry.Values[0], OS);
+    break;
+  case dwarf::DW_LLE_startx_endx:
+  case dwarf::DW_LLE_startx_length:
+  case dwarf::DW_LLE_offset_pair:
+    if (Error Err = CheckOperands(2))
+      return std::move(Err);
+    encodeULEB128(Entry.Values[0], OS);
+    encodeULEB128(Entry.Values[1], OS);
+    if (Error Err = WriteDWARFOperations())
+      return std::move(Err);
+    break;
+  case dwarf::DW_LLE_default_location:
+    if (Error Err = CheckOperands(0))
+      return std::move(Err);
+    if (Error Err = WriteDWARFOperations())
+      return std::move(Err);
+    break;
+  case dwarf::DW_LLE_base_address:
+    if (Error Err = CheckOperands(1))
+      return std::move(Err);
+    if (Error Err = WriteAddress(Entry.Values[0]))
+      return std::move(Err);
+    break;
+  case dwarf::DW_LLE_start_end:
+    if (Error Err = CheckOperands(2))
+      return std::move(Err);
+    if (Error Err = WriteAddress(Entry.Values[0]))
+      return std::move(Err);
+    cantFail(WriteAddress(Entry.Values[1]));
+    if (Error Err = WriteDWARFOperations())
+      return std::move(Err);
+    break;
+  case dwarf::DW_LLE_start_length:
+    if (Error Err = CheckOperands(2))
+      return std::move(Err);
+    if (Error Err = WriteAddress(Entry.Values[0]))
+      return std::move(Err);
+    encodeULEB128(Entry.Values[1], OS);
+    if (Error Err = WriteDWARFOperations())
+      return std::move(Err);
+    break;
+  }
+
+  return OS.tell() - BeginOffset;
+}
+
+template <typename EntryType>
+Error emitDWARFLists(raw_ostream &OS,
+                     ArrayRef<DWARFYAML::ListTable<EntryType>> Tables,
+                     bool IsLittleEndian, bool Is64BitAddrSize) {
+  for (const DWARFYAML::ListTable<EntryType> &Table : Tables) {
     // sizeof(version) + sizeof(address_size) + sizeof(segment_selector_size) +
     // sizeof(offset_entry_count) = 8
     uint64_t Length = 8;
 
     uint8_t AddrSize;
     if (Table.AddrSize)
       AddrSize = *Table.AddrSize;
     else
-      AddrSize = DI.Is64BitAddrSize ? 8 : 4;
+      AddrSize = Is64BitAddrSize ? 8 : 4;
 
     // Since the length of the current range lists entry is undetermined yet, we
     // firstly write the content of the range lists to a buffer to calculate the
     // length and then serialize the buffer content to the actual output stream.
     std::string ListBuffer;
     raw_string_ostream ListBufferOS(ListBuffer);
 
     // Offsets holds offsets for each range list. The i-th element is the offset
     // from the beginning of the first range list to the location of the i-th
     // range list.
     std::vector<uint64_t> Offsets;
 
-    for (const DWARFYAML::Rnglist &List : Table.Lists) {
+    for (const DWARFYAML::ListEntries<EntryType> &List : Table.Lists) {
       Offsets.push_back(ListBufferOS.tell());
-      for (const DWARFYAML::RnglistEntry &Entry : List.Entries) {
+      for (const EntryType &Entry : List.Entries) {
         Expected<uint64_t> EntrySize =
-            writeRnglistEntry(ListBufferOS, Entry, AddrSize, DI.IsLittleEndian);
+            writeListEntry(ListBufferOS, Entry, AddrSize, IsLittleEndian);
         if (!EntrySize)
           return EntrySize.takeError();
         Length += *EntrySize;
       }
     }
 
     // If the offset_entry_count field isn't specified, yaml2obj will infer it
     // from the 'Offsets' field in the YAML description. If the 'Offsets' field
     // isn't specified either, yaml2obj will infer it from the auto-generated
     // offsets.
     uint32_t OffsetEntryCount;
     if (Table.OffsetEntryCount)
       OffsetEntryCount = *Table.OffsetEntryCount;
     else
       OffsetEntryCount = Table.Offsets ? Table.Offsets->size() : Offsets.size();
     uint64_t OffsetsSize =
         OffsetEntryCount * (Table.Format == dwarf::DWARF64 ? 8 : 4);
     Length += OffsetsSize;
 
     // If the length is specified in the YAML description, we use it instead of
     // the actual length.
     if (Table.Length)
       Length = *Table.Length;
 
-    writeInitialLength(Table.Format, Length, OS, DI.IsLittleEndian);
-    writeInteger((uint16_t)Table.Version, OS, DI.IsLittleEndian);
-    writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
-    writeInteger((uint8_t)Table.SegSelectorSize, OS, DI.IsLittleEndian);
-    writeInteger((uint32_t)OffsetEntryCount, OS, DI.IsLittleEndian);
+    writeInitialLength(Table.Format, Length, OS, IsLittleEndian);
+    writeInteger((uint16_t)Table.Version, OS, IsLittleEndian);
+    writeInteger((uint8_t)AddrSize, OS, IsLittleEndian);
+    writeInteger((uint8_t)Table.SegSelectorSize, OS, IsLittleEndian);
+    writeInteger((uint32_t)OffsetEntryCount, OS, IsLittleEndian);
 
     auto EmitOffsets = [&](ArrayRef<uint64_t> Offsets, uint64_t OffsetsSize) {
       for (uint64_t Offset : Offsets) {
         cantFail(writeVariableSizedInteger(
             OffsetsSize + Offset, Table.Format == dwarf::DWARF64 ? 8 : 4, OS,
-            DI.IsLittleEndian));
+            IsLittleEndian));
       }
     };
 
     if (Table.Offsets)
       EmitOffsets(ArrayRef<uint64_t>((const uint64_t *)Table.Offsets->data(),
                                      Table.Offsets->size()),
                   0);
     else
       EmitOffsets(Offsets, OffsetsSize);
 
     OS.write(ListBuffer.data(), ListBuffer.size());
   }
 
   return Error::success();
 }
 
+Error DWARFYAML::emitDebugRnglists(raw_ostream &OS, const Data &DI) {
+  assert(DI.DebugRnglists && "unexpected emitDebugRnglists() call");
+  return emitDWARFLists<DWARFYAML::RnglistEntry>(
+      OS, *DI.DebugRnglists, DI.IsLittleEndian, DI.Is64BitAddrSize);
+}
+
+Error DWARFYAML::emitDebugLoclists(raw_ostream &OS, const Data &DI) {
+  assert(DI.DebugLoclists && "unexpected emitDebugRnglists() call");
+  return emitDWARFLists<DWARFYAML::LoclistEntry>(
+      OS, *DI.DebugLoclists, DI.IsLittleEndian, DI.Is64BitAddrSize);
+}
+
 using EmitFuncType = Error (*)(raw_ostream &, const DWARFYAML::Data &);
 
 static Error
 emitDebugSectionImpl(const DWARFYAML::Data &DI, EmitFuncType EmitFunc,
                      StringRef Sec,
                      StringMap<std::unique_ptr<MemoryBuffer>> &OutputBuffers) {
   std::string Data;
   raw_string_ostream DebugInfoStream(Data);

llvm/lib/ObjectYAML/DWARFYAML.cpp

SetVector<StringRef> DWARFYAML::Data::getUsedSectionNames() const {
   if (GNUPubNames)
     SecNames.insert("debug_gnu_pubnames");
   if (GNUPubTypes)
     SecNames.insert("debug_gnu_pubtypes");
   if (DebugStrOffsets)
     SecNames.insert("debug_str_offsets");
   if (DebugRnglists)
     SecNames.insert("debug_rnglists");
+  if (DebugLoclists)
+    SecNames.insert("debug_loclists");
   return SecNames;
 }
 
 namespace yaml {
 
 void MappingTraits<DWARFYAML::Data>::mapping(IO &IO, DWARFYAML::Data &DWARF) {
   void *OldContext = IO.getContext();
   DWARFYAML::DWARFContext DWARFCtx;
void MappingTraits<DWARFYAML::Data>::mapping(IO &IO, DWARFYAML::Data &DWARF) {
   DWARFCtx.IsGNUPubSec = true;
   IO.mapOptional("debug_gnu_pubnames", DWARF.GNUPubNames);
   IO.mapOptional("debug_gnu_pubtypes", DWARF.GNUPubTypes);
   IO.mapOptional("debug_info", DWARF.CompileUnits);
   IO.mapOptional("debug_line", DWARF.DebugLines);
   IO.mapOptional("debug_addr", DWARF.DebugAddr);
   IO.mapOptional("debug_str_offsets", DWARF.DebugStrOffsets);
   IO.mapOptional("debug_rnglists", DWARF.DebugRnglists);
+  IO.mapOptional("debug_loclists", DWARF.DebugLoclists);
   IO.setContext(OldContext);
 }
 
 void MappingTraits<DWARFYAML::Abbrev>::mapping(IO &IO,
                                                DWARFYAML::Abbrev &Abbrev) {
   IO.mapOptional("Code", Abbrev.Code);
   IO.mapRequired("Tag", Abbrev.Tag);
   IO.mapRequired("Children", Abbrev.Children);
void MappingTraits<DWARFYAML::StringOffsetsTable>::mapping(
     IO &IO, DWARFYAML::StringOffsetsTable &StrOffsetsTable) {
   IO.mapOptional("Format", StrOffsetsTable.Format, dwarf::DWARF32);
   IO.mapOptional("Length", StrOffsetsTable.Length);
   IO.mapOptional("Version", StrOffsetsTable.Version, 5);
   IO.mapOptional("Padding", StrOffsetsTable.Padding, 0);
   IO.mapOptional("Offsets", StrOffsetsTable.Offsets);
 }
 
+void MappingTraits<DWARFYAML::DWARFOperation>::mapping(
+    IO &IO, DWARFYAML::DWARFOperation &DWARFOperation) {
+  IO.mapRequired("Operator", DWARFOperation.Operator);
+  IO.mapOptional("Values", DWARFOperation.Values);
+}
+
 void MappingTraits<DWARFYAML::RnglistEntry>::mapping(
     IO &IO, DWARFYAML::RnglistEntry &RnglistEntry) {
   IO.mapRequired("Operator", RnglistEntry.Operator);
   IO.mapOptional("Values", RnglistEntry.Values);
 }
 
-void MappingTraits<DWARFYAML::Rnglist>::mapping(IO &IO,
-                                                DWARFYAML::Rnglist &Rnglist) {
-  IO.mapOptional("Entries", Rnglist.Entries);
-}
-
-void MappingTraits<DWARFYAML::RnglistTable>::mapping(
-    IO &IO, DWARFYAML::RnglistTable &RnglistTable) {
-  IO.mapOptional("Format", RnglistTable.Format, dwarf::DWARF32);
-  IO.mapOptional("Length", RnglistTable.Length);
-  IO.mapOptional("Version", RnglistTable.Version, 5);
-  IO.mapOptional("AddressSize", RnglistTable.AddrSize);
-  IO.mapOptional("SegmentSelectorSize", RnglistTable.SegSelectorSize, 0);
-  IO.mapOptional("OffsetEntryCount", RnglistTable.OffsetEntryCount);
-  IO.mapOptional("Offsets", RnglistTable.Offsets);
-  IO.mapOptional("Lists", RnglistTable.Lists);
+void MappingTraits<DWARFYAML::LoclistEntry>::mapping(
+    IO &IO, DWARFYAML::LoclistEntry &LoclistEntry) {
+  IO.mapRequired("Operator", LoclistEntry.Operator);
+  IO.mapOptional("Values", LoclistEntry.Values);
+  IO.mapOptional("DescriptorsLength", LoclistEntry.DescriptorLength);
+  IO.mapOptional("Descriptors", LoclistEntry.Descriptors);
+}
+
+template <typename EntryType>
+void MappingTraits<DWARFYAML::ListEntries<EntryType>>::mapping(
+    IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries) {
+  IO.mapOptional("Entries", ListEntries.Entries);
+}
+
+template <typename EntryType>
+void MappingTraits<DWARFYAML::ListTable<EntryType>>::mapping(
+    IO &IO, DWARFYAML::ListTable<EntryType> &ListTable) {
+  IO.mapOptional("Format", ListTable.Format, dwarf::DWARF32);
+  IO.mapOptional("Length", ListTable.Length);
+  IO.mapOptional("Version", ListTable.Version, 5);
+  IO.mapOptional("AddressSize", ListTable.AddrSize);
+  IO.mapOptional("SegmentSelectorSize", ListTable.SegSelectorSize, 0);
+  IO.mapOptional("OffsetEntryCount", ListTable.OffsetEntryCount);
+  IO.mapOptional("Offsets", ListTable.Offsets);
+  IO.mapOptional("Lists", ListTable.Lists);
 }
 
 void MappingTraits<DWARFYAML::InitialLength>::mapping(
     IO &IO, DWARFYAML::InitialLength &InitialLength) {
   IO.mapRequired("TotalLength", InitialLength.TotalLength);
   if (InitialLength.isDWARF64())
     IO.mapRequired("TotalLength64", InitialLength.TotalLength64);
 }
 
 } // end namespace yaml
 
 } // end namespace llvm

llvm/lib/ObjectYAML/ELFEmitter.cpp

Err = DWARFYAML::emitPubSection(*OS, *DWARF.GNUPubNames,
                                     DWARF.IsLittleEndian, /*IsGNUStyle=*/true);
   else if (Name == ".debug_gnu_pubtypes")
     Err = DWARFYAML::emitPubSection(*OS, *DWARF.GNUPubTypes,
                                     DWARF.IsLittleEndian, /*IsGNUStyle=*/true);
   else if (Name == ".debug_str_offsets")
     Err = DWARFYAML::emitDebugStrOffsets(*OS, DWARF);
   else if (Name == ".debug_rnglists")
     Err = DWARFYAML::emitDebugRnglists(*OS, DWARF);
+  else if (Name == ".debug_loclists")
+    Err = DWARFYAML::emitDebugLoclists(*OS, DWARF);
   else
     llvm_unreachable("unexpected emitDWARF() call");
 
   if (Err)
     return std::move(Err);
 
   return CBA.tell() - BeginOffset;
 }

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

+## Test that yaml2obj emits a .debug_loclists section when requested.
+
+## a) Generate and verify a little endian DWARF32 .debug_loclists section in a 64-bit object file.
+
+# RUN: yaml2obj --docnum=1 -DENDIAN=ELFDATA2LSB %s -o %t1.dwarf32.le.o
+# RUN: llvm-readobj --sections --section-data %t1.dwarf32.le.o | \
+# RUN:   FileCheck -DSIZE=133 -DADDRALIGN=1 %s --check-prefixes=SHDR,DWARF32-LE
+
+#            SHDR: Index: 1
+#       SHDR-NEXT: Name: .debug_loclists (1)
+#       SHDR-NEXT: Type: SHT_PROGBITS (0x1)
+#       SHDR-NEXT: Flags [ (0x0)
+#       SHDR-NEXT: ]
+#       SHDR-NEXT: Address: 0x0
+#       SHDR-NEXT: Offset: 0x40
+#       SHDR-NEXT: Size: [[SIZE]]
+#       SHDR-NEXT: Link: 0
+#       SHDR-NEXT: Info: 0
+#       SHDR-NEXT: AddressAlignment: [[ADDRALIGN]]
+#       SHDR-NEXT: EntrySize: 0
+# DWARF32-LE-NEXT: SectionData (
+# DWARF32-LE-NEXT:   0000: 3D000000 05000800 03000000 0C000000  |=...............|
+##                         ^-------                             unit_length (4-byte)
+##                                  ^---                        version (2-byte)
+##                                      ^-                      address_size (1-byte)
+##                                        ^-                    segment_selector_size (1-byte)
+##                                           ^-------           offset_entry_count (4-byte)
+##                                                    ^-------  offsets[0] (4-byte)
+# DWARF32-LE-NEXT:   0010: 1B000000 2F000000 01B42402 B424A186  |..../.....$..$..|
+##                         ^-------                             offsets[1] (4-byte)
+##                                  ^-------                    offsets[2] (4-byte)
+##                                           ^-                 DW_LLE_base_addressx
+##                                             ^---             operands[0] (ULEB128) 0x1234
+##                                                 ^-           DW_LLE_startx_endx
+##                                                    ^---      operands[0] (ULEB128) 0x1234
+##                                                        ^---  operands[1] (ULEB128) 0x4321
+# DWARF32-LE-NEXT:   0020: 010411B4 249F0003 B424A186 0102117D  |....$....$.....}|
+##                         --
+##                           ^-                                 location descriptors length (ULEB128) 0x04
+##                             ^-                               DW_OP_consts
+##                               ^----                          operands[0] (SLEB128) +0x1234
+##                                    ^-                        DW_OP_stack_value
+##                                      ^-                      DW_LLE_end_of_list
+##                                        ^-                    DW_LLE_startx_length
+##                                           ^---               operands[0] (ULEB128) 0x1234
+##                                               ^------        operands[1] (ULEB128) 0x4321
+##                                                      ^-      location descriptors length (ULEB128) 0x02
+##                                                        ^-    DW_OP_consts
+##                                                          ^-  operands[0] (SLEB128) -0x03
+# DWARF32-LE-NEXT:   0030: 04B424A1 86010311 B4240005 0311B424  |..$......$.....$|
+##                         ^-                                   DW_LLE_offset_pair
+##                           ^---                               operands[0] (ULEB128) 0x1234
+##                               ^------                        operands[1] (ULEB128) 0x4321
+##                                      ^-                      location descriptors length (ULEB128) 0x03
+##                                        ^-                    DW_OP_consts
+##                                           ^---               operands[0] (SLEB128) +0x1234
+##                                               ^-             DW_LLE_end_of_list
+##                                                 ^-           DW_LLE_default_location
+##                                                    ^-        location descriptors length (ULEB128) 0x03
+##                                                      ^-      DW_OP_consts
+##                                                        ^---  operands[0] (SLEB128) +0x1234
+# DWARF32-LE-NEXT:   0040: 00400000 00050008 00020000 00080000  |.@..............|
+##                         ^-                                   DW_LLE_end_of_list
+##                           ^--------                          unit_length (4-byte)
+##                                    ^---                      version (2-byte)
+##                                        ^-                    address_size (1-byte)
+##                                           ^-                 segment_selector_size (1-byte)
+##                                             ^--------        offset_entry_count (4-byte)
+##                                                      ^-----  offsets[0] (4-byte)
+# DWARF32-LE-NEXT:   0050: 00270000 00063412 00000000 00000734  |.'....4........4|
+##                         --
+##                           ^--------                          offsets[1] (4-byte)
+##                                    ^-                        DW_LLE_base_address
+##                                      ^-----------------      operands[0] (8-byte)
+##                                                        ^-    DW_LLE_start_end
+##                                                          ^-  operands[0] (8-byte)
+# DWARF32-LE-NEXT:   0060: 12000000 00000021 43000000 00000003  |.......!C.......|
+##                         ---------------
+##                                        ^-----------------    operands[1] (8-byte)
+##                                                          ^-  location descriptors length (ULEB128) 0x03
+# DWARF32-LE-NEXT:   0070: 11B42400 08341200 00000000 00A18601  |..$..4..........|
+##                         ^-                                   DW_OP_consts
+##                           ^---                               operands[0] (SLEB128) +0x1234
+##                               ^-                             DW_LLE_end_of_list
+##                                  ^-                          DW_LLE_start_length
+##                                    ^-----------------        operands[0] (8-byte)
+##                                                      ^-----  operands[1] (LEB128) 0x4321
+# DWARF32-LE-NEXT:   0080: 0311B424 00                          |...$.|
+##                         ^-                                   location descriptors length (ULEB128) 0x03
+##                           ^-                                 DW_OP_consts
+##                             ^---                             operands[0] (SLEB128) +0x1234
+##                                  ^-                          DW_LLE_end_of_list
+# DWARF32-LE-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    [[ENDIAN]]
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - Lists:
+        - Entries:
+            - Operator: DW_LLE_base_addressx
+              Values:   [ 0x1234 ]
+            - Operator: DW_LLE_startx_endx
+              Values:   [ 0x1234, 0x4321 ]
+              Descriptors:
+                - Operator: DW_OP_consts
+                  Values:   [ 0x1234 ]
+                - Operator: DW_OP_stack_value
+            - Operator: DW_LLE_end_of_list
+        - Entries:
+            - Operator: DW_LLE_startx_length
+              Values:   [ 0x1234, 0x4321 ]
+              Descriptors:
+                - Operator: DW_OP_consts
+                  ## Test a negative number (-3).
+                  Values:   [ 0xfffffffffffffffd ]
+            - Operator: DW_LLE_offset_pair
+              Values:   [ 0x1234, 0x4321 ]
+              Descriptors:
+                - Operator: DW_OP_consts
+                  Values:   [ 0x1234 ]
+            - Operator: DW_LLE_end_of_list
+        - Entries:
+            - Operator: DW_LLE_default_location
+              Descriptors:
+                - Operator: DW_OP_consts
+                  Values:   [ 0x1234 ]
+            - Operator: DW_LLE_end_of_list
+    - Lists:
+        - Entries:
+            - Operator: DW_LLE_base_address
+              Values:   [ 0x1234 ]
+            - Operator: DW_LLE_start_end
+              Values:   [ 0x1234, 0x4321 ]
+              Descriptors:
+                - Operator: DW_OP_consts
+                  Values:   [ 0x1234 ]
+            - Operator: DW_LLE_end_of_list
+        - Entries:
+            - Operator: DW_LLE_start_length
+              Values:   [ 0x1234, 0x4321 ]
+              Descriptors:
+                - Operator: DW_OP_consts
+                  Values:   [ 0x1234 ]
+            - Operator: DW_LLE_end_of_list
+
+## b) Generate and verify a big endian DWARF32 .debug_loclists section in a 64-bit object file.
+
+# RUN: yaml2obj --docnum=1 -DENDIAN=ELFDATA2MSB %s -o %t.dwarf32.be.o
+# RUN: llvm-readobj --sections --section-data %t.dwarf32.be.o | \
+# RUN:   FileCheck -DSIZE=133 -DADDRALIGN=1 %s --check-prefixes=SHDR,DWARF32-BE
+
+# DWARF32-BE-NEXT: SectionData (
+# DWARF32-BE-NEXT:   0000: 0000003D 00050800 00000003 0000000C  |...=............|
+##                         ^-------                             unit_length (4-byte)
+##                                  ^---                        version (2-byte)
+##                                      ^-                      address_size (1-byte)
+##                                        ^-                    segment_selector_size (1-byte)
+##                                           ^-------           offset_entry_count (4-byte)
+##                                                    ^-------  offsets[0] (4-byte)
+# DWARF32-BE-NEXT:   0010: 0000001B 0000002F 01B42402 B424A186  |......./..$..$..|
+##                         ^-------                             offsets[1] (4-byte)
+##                                  ^-------                    offsets[2] (4-byte)
+##                                           ^-                 DW_LLE_base_addressx
+##                                             ^---             operands[0] (ULEB128) 0x1234
+##                                                 ^-           DW_LLE_startx_endx
+##                                                    ^---      operands[0] (ULEB128) 0x1234
+##                                                        ^---  operands[1] (ULEB128) 0x4321
+# DWARF32-BE-NEXT:   0020: 010411B4 249F0003 B424A186 0102117D  |....$....$.....}|
+##                         --
+##                           ^-                                 location descriptors length (ULEB128) 0x04
+##                             ^-                               DW_OP_consts
+##                               ^----                          operands[0] (SLEB128) +0x1234
+##                                    ^-                        DW_OP_stack_value
+##                                      ^-                      DW_LLE_end_of_list
+##                                        ^-                    DW_LLE_startx_length
+##                                           ^---               operands[0] (ULEB128) 0x1234
+##                                               ^------        operands[1] (ULEB128) 0x4321
+##                                                      ^-      location descriptors length (ULEB128) 0x02
+##                                                        ^-    DW_OP_consts
+##                                                          ^-  operands[0] (SLEB128) -0x03
+# DWARF32-BE-NEXT:   0030: 04B424A1 86010311 B4240005 0311B424  |..$......$.....$|
+##                         ^-                                   DW_LLE_offset_pair
+##                           ^---                               operands[0] (ULEB128) 0x1234
+##                               ^------                        operands[1] (ULEB128) 0x4321
+##                                      ^-                      location descriptors length (ULEB128) 0x03
+##                                        ^-                    DW_OP_consts
+##                                           ^---               operands[0] (SLEB128) +0x1234
+##                                               ^-             DW_LLE_end_of_list
+##                                                 ^-           DW_LLE_default_location
+##                                                    ^-        location descriptors length (ULEB128) 0x03
+##                                                      ^-      DW_OP_consts
+##                                                        ^---  operands[0] (SLEB128) +0x1234
+# DWARF32-BE-NEXT:   0040: 00000000 40000508 00000000 02000000  |....@...........|
+##                         ^-                                   DW_LLE_end_of_list
+##                           ^--------                          unit_length (4-byte)
+##                                    ^---                      version (2-byte)
+##                                        ^-                    address_size (1-byte)
+##                                           ^-                 segment_selector_size (1-byte)
+##                                             ^--------        offset_entry_count (4-byte)
+##                                                      ^-----  offsets[0] (4-byte)
+# DWARF32-BE-NEXT:   0050: 08000000 27060000 00000000 12340700  |....'........4..|
+##                         --
+##                           ^--------                          offsets[1] (4-byte)
+##                                    ^-                        DW_LLE_base_address
+##                                      ^-----------------      operands[0] (8-byte)
+##                                                        ^-    DW_LLE_start_end
+##                                                          ^-  operands[0] (8-byte)
+# DWARF32-BE-NEXT:   0060: 00000000 00123400 00000000 00432103  |......4......C!.|
+##                         ---------------
+##                                        ^-----------------    operands[1] (8-byte)
+##                                                          ^-  location descriptors length (ULEB128) 0x03
+# DWARF32-BE-NEXT:   0070: 11B42400 08000000 00000012 34A18601  |..$.........4...|
+##                         ^-                                   DW_OP_consts
+##                           ^---                               operands[0] (SLEB128) +0x1234
+##                               ^-                             DW_LLE_end_of_list
+##                                  ^-                          DW_LLE_start_length
+##                                    ^-----------------        operands[0] (8-byte)
+##                                                      ^-----  operands[1] (LEB128) 0x4321
+# DWARF32-BE-NEXT:   0080: 0311B424 00                          |...$.|
+##                         ^-                                   location descriptors length (ULEB128) 0x03
+##                           ^-                                 DW_OP_consts
+##                             ^---                             operands[0] (SLEB128) +0x1234
+##                                  ^-                          DW_LLE_end_of_list
+# DWARF32-BE-NEXT: )
+
+## c) Generate and verify a little endian DWARF64 .debug_loclists section in a 64-bit object file.
+
+# RUN: yaml2obj --docnum=2 -DENDIAN=ELFDATA2LSB %s -o %t2.dwarf64.le.o
+# RUN: llvm-readobj --sections --section-data %t2.dwarf64.le.o | \
+# RUN:   FileCheck -DSIZE=47 -DADDRALIGN=1 %s --check-prefixes=SHDR,DWARF64-LE
+
+# DWARF64-LE-NEXT: SectionData (
+# DWARF64-LE-NEXT:   0000: FFFFFFFF 23000000 00000000 05000800  |....#...........|
+##                         ^-------------------------           unit_length (12-byte)
+##                                                    ^---      version (2-byte)
+##                                                        ^-    address_size (1-byte)
+##                                                          ^-  segment_selector_size (1-byte)
+# DWARF64-LE-NEXT:   0010: 02000000 10000000 00000000 1A000000  |................|
+##                         ^-------                             offset_entry_count (4-byte)
+##                                  ^----------------           offsets[0] (8-byte)
+##                                                    ^-------  offsets[1] (8-byte)
+# DWARF64-LE-NEXT:   0020: 00000000 02B424A1 86010311 B42400    |......$......$.|
+##                         --------
+##                                  ^-                          DW_LLE_startx_endx
+##                                    ^---                      operands[0] (ULEB128) 0x1234
+##                                        ^------               operands[1] (ULEB128) 0x4321
+##                                               ^-             location descriptors length (ULEB128) 0x03
+##                                                 ^-           DW_OP_consts
+##                                                    ^---      operands[0] (SLEB128) +0x1234
+##                                                        ^-    DW_LLE_end_of_list
+# DWARF64-LE-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    [[ENDIAN]]
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - Format:  DWARF64
+      Lists:
+        - Entries:
+            - Operator: DW_LLE_startx_endx
+              Values:   [ 0x1234, 0x4321 ]
+              Descriptors:
+                - Operator: DW_OP_consts
+                  Values:   [ 0x1234 ]
+        - Entries:
+            - Operator: DW_LLE_end_of_list
+
+## d) Generate and verify a big endian DWARF64 .debug_loclists section in a 64-bit object file.
+
+# RUN: yaml2obj --docnum=2 -DENDIAN=ELFDATA2MSB %s -o %t2.dwarf64.be.o
+# RUN: llvm-readobj --sections --section-data %t2.dwarf64.be.o | \
+# RUN:   FileCheck -DSIZE=47 -DADDRALIGN=1 %s --check-prefixes=SHDR,DWARF64-BE
+
+# DWARF64-BE-NEXT: SectionData (
+# DWARF64-BE-NEXT:   0000: FFFFFFFF 00000000 00000023 00050800  |...........#....|
+##                         ^-------------------------           unit_length (12-byte)
+##                                                    ^---      version (2-byte)
+##                                                        ^-    address_size (1-byte)
+##                                                          ^-  segment_selector_size (1-byte)
+# DWARF64-BE-NEXT:   0010: 00000002 00000000 00000010 00000000  |................|
+##                         ^-------                             offset_entry_count (4-byte)
+##                                  ^----------------           offsets[0] (8-byte)
+##                                                    ^-------  offsets[1] (8-byte)
+# DWARF64-BE-NEXT:   0020: 0000001A 02B424A1 86010311 B42400    |......$......$.|
+##                         --------
+##                                  ^-                          DW_LLE_startx_endx
+##                                    ^---                      operands[0] (ULEB128) 0x1234
+##                                        ^------               operands[1] (ULEB128) 0x4321
+##                                               ^-             location descriptors length (ULEB128) 0x03
+##                                                 ^-           DW_OP_consts
+##                                                    ^---      operands[0] (SLEB128) +0x1234
+##                                                        ^-    DW_LLE_end_of_list
+# DWARF64-BE-NEXT: )
+
+## e) Test that the length, version, segment_selector_size, address_size, offset_entry_count,
+## offsets and location descriptors length fields can be specified manually.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3.o
+# RUN: llvm-readelf --hex-dump=.debug_loclists %t3.o | \
+# RUN:   FileCheck %s --check-prefix=OVERWRITE
+
+#      OVERWRITE: Hex dump of section '.debug_loclists':
+# OVERWRITE-NEXT: 0x00000000 34120000 06000303 04000000 01000000 4...............
+##                           ^-------                            unit_length (4-byte) 0x1234
+##                                    ^---                       version (2-byte) 0x06
+##                                        ^-                     address_size (1-byte) 0x03
+##                                          ^-                   segment_selector_size (1-byte) 0x03
+##                                             ^-------          offset_entry_count (4-byte) 0x04
+##                                                      ^------- offsets[0] (4-byte) 0x01
+# OVERWRITE-NEXT: 0x00000010 02b424a1 8601a186 019f00            ..$........
+##                           ^-                                  DW_LLE_startx_endx
+##                             ^---                              operands[0] (ULEB128) 0x1234
+##                                 ^------                       operands[1] (ULEB128) 0x4321
+##                                        ^------                location descriptors length (ULEB128) 0x4321
+##                                               ^-              DW_OP_stack_value
+##                                                 ^-            DW_LLE_end_of_list
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - Length:              0x1234
+      Version:             6
+      AddressSize:         3
+      SegmentSelectorSize: 3
+      OffsetEntryCount:    4
+      Offsets:             [ 0x01 ]
+      Lists:
+        - Entries:
+            - Operator:          DW_LLE_startx_endx
+              Values:            [ 0x1234, 0x4321 ]
+              DescriptorsLength: 0x4321
+              Descriptors:
+                - Operator: DW_OP_stack_value
+        - Entries:
+            - Operator: DW_LLE_end_of_list
+
+## f) Test that location descriptors can be omitted in the YAML description.
+
+# RUN: yaml2obj --docnum=4 %s -o %t4.o
+# RUN: llvm-readelf --hex-dump=.debug_loclists %t4.o | \
+# RUN:   FileCheck %s --check-prefix=OMIT-DESCRIPTORS
+
+#      OMIT-DESCRIPTORS: Hex dump of section '.debug_loclists':
+# OMIT-DESCRIPTORS-NEXT: 0x00000000 42000000 05000800 01000000 04000000 B...............
+# OMIT-DESCRIPTORS-NEXT: 0x00000010 02b424a1 86010003 b424a186 010004b4 ..$......$......
+##                                  ^-                                  DW_LLE_startx_endx
+##                                    ^---                              operands[0] (ULEB128) 0x1234
+##                                        ^------                       operands[1] (ULEB128) 0x4321
+##                                               ^-                     location descriptors length (ULEB128) 0x00
+##                                                 ^-                   DW_LLE_startx_length
+##                                                    ^---              operands[0] (ULEB128) 0x1234
+##                                                        ^------       operands[1] (ULEB128) 0x4321
+##                                                               ^-     location descriptors length (ULEB128) 0x00
+##                                                                 ^-   DW_LLE_offset_pair
+##                                                                   ^- operands[0] (ULEB128) 0x1234
+# OMIT-DESCRIPTORS-NEXT: 0x00000020 24a18601 00050007 34120000 00000000 $.......4.......
+##                                  --
+##                                    ^-----                            operands[1] (ULEB128) 0x4321
+##                                           ^-                         location descriptors length (ULEB128) 0x00
+##                                             ^-                       DW_LLE_default_location
+##                                               ^-                     location descriptors length (ULEB128) 0x00
+##                                                 ^-                   DW_LLE_start_end
+##                                                    ^---------------- operands[0] (8-byte)
+# OMIT-DESCRIPTORS-NEXT: 0x00000030 21430000 00000000 00083412 00000000 !C........4.....
+##                                  ^----------------                   operands[1] (8-byte)
+##                                                    ^-                location descriptors length (ULEB128) 0x00
+##                                                      ^-              DW_LLE_start_length
+##                                                        ^------------ operands[0] (8-byte)
+# OMIT-DESCRIPTORS-NEXT: 0x00000040 0000a186 0100                       ......
+##                                  ----
+##                                      ^------                         operands[1] (ULEB128) 0x4321
+##                                             ^-                       location descriptors length (ULEB128) 0x00
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - Lists:
+        - Entries:
+            - Operator: DW_LLE_startx_endx
+              Values:   [ 0x1234, 0x4321 ]
+            - Operator: DW_LLE_startx_length
+              Values:   [ 0x1234, 0x4321 ]
+            - Operator: DW_LLE_offset_pair
+              Values:   [ 0x1234, 0x4321 ]
+            - Operator: DW_LLE_default_location
+            - Operator: DW_LLE_start_end
+              Values:   [ 0x1234, 0x4321 ]
+            - Operator: DW_LLE_start_length
+              Values:   [ 0x1234, 0x4321 ]
+
+## g) Test that the default value of the address_size field in a 32-bit object file is 4.
+
+# RUN: yaml2obj --docnum=5 %s -o %t5.o
+# RUN: llvm-readelf --hex-dump=.debug_loclists %t5.o | \
+# RUN:   FileCheck %s --check-prefix=ADDRSIZE32
+
+#      ADDRSIZE32: Hex dump of section '.debug_loclists':
+# ADDRSIZE32-NEXT: 0x00000000 24000000 05000400 01000000 04000000 $...............
+##                                         ^-                     address_size (1-byte) 0x04
+# ADDRSIZE32-NEXT: 0x00000010 06341200 00073412 00002143 00000008 .4....4...!C....
+##                            ^-                                  DW_LLE_base_address
+##                              ^--------                         operands[0] (4-byte)
+##                                       ^-                       DW_LLE_start_end
+##                                         ^--------              operands[0] (4-byte)
+##                                                  ^--------     operands[1] (4-byte)
+##                                                             ^- DW_LLE_start_length
+# ADDRSIZE32-NEXT: 0x00000020 34120000 a1860100                   4.......
+##                            ^-------                            operands[0] (4-byte)
+##                                     ^-----                     operands[1] (ULEB128) 0x4321
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - Lists:
+        - Entries:
+            - Operator: DW_LLE_base_address
+              Values:   [ 0x1234 ]
+            - Operator: DW_LLE_start_end
+              Values:   [ 0x1234, 0x4321 ]
+            - Operator: DW_LLE_start_length
+              Values:   [ 0x1234, 0x4321 ]
+
+## h) Test that the address_size field can be specified manually and the size of
+## corresponding operands will be changed accordingly.
+
+# RUN: yaml2obj --docnum=6 %s -o %t6.o
+# RUN: llvm-readelf --hex-dump=.debug_loclists %t6.o | \
+# RUN:   FileCheck %s --check-prefix=ADDRSIZE32
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - AddressSize: 4
+      Lists:
+        - Entries:
+            - Operator: DW_LLE_base_address
+              Values:   [ 0x1234 ]
+            - Operator: DW_LLE_start_end
+              Values:   [ 0x1234, 0x4321 ]
+            - Operator: DW_LLE_start_length
+              Values:   [ 0x1234, 0x4321 ]
+
+## i) Test that yaml2obj emits an error message if we try to assign an invalid value to
+## 'AddressSize' when there is an entry whose operands contain address.
+
+# RUN: not yaml2obj -DOPERATOR=base_address -DVALUES=[0x01] --docnum=7 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=base_address %s --check-prefix=INVALID-ADDRSIZE
+
+# RUN: not yaml2obj -DOPERATOR=start_end -DVALUES=[0x01,0x02] --docnum=7 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=start_end %s --check-prefix=INVALID-ADDRSIZE
+
+# RUN: not yaml2obj -DOPERATOR=start_length -DVALUES=[0x01,0x02] --docnum=7 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=start_length %s --check-prefix=INVALID-ADDRSIZE
+
+# INVALID-ADDRSIZE: yaml2obj: error: unable to write address for the operator DW_LLE_[[OPERATOR]]: invalid integer write size: 3
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - AddressSize: 3
+      Lists:
+        - Entries:
+            - Operator: DW_LLE_[[OPERATOR]]
+              Values:   [[VALUES]]
+
+## j) Test that an invalid address_size can be used when there are no address-using operators.
+
+# RUN: yaml2obj --docnum=8 %s -o %t8.o
+# RUN: llvm-readelf --hex-dump=.debug_loclists %t8.o | \
+# RUN:   FileCheck %s --check-prefix=ADDRSIZE-NOERROR
+
+#      ADDRSIZE-NOERROR: Hex dump of section '.debug_loclists':
+# ADDRSIZE-NOERROR-NEXT: 0x00000000 0e000000 05000300 01000000 04000000 ................
+##                                               ^-                     address_size (1-byte) 0x03
+# ADDRSIZE-NOERROR-NEXT: 0x00000010 0101                                ..
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - AddressSize: 3
+      Lists:
+        - Entries:
+            - Operator: DW_LLE_base_addressx
+              Values:   [ 0x01 ]
+
+## k) Test that yaml2obj emits an error message if we specify invalid numbers of operands
+## for a location list encoding.
+
+# RUN: not yaml2obj -DOPERATOR=end_of_list -DVALUES=[0x01] --docnum=9 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=end_of_list -DACTUAL=1 -DEXPECTED=0 %s --check-prefix=INVALID-LLE-OPERANDS
+
+# RUN: not yaml2obj -DOPERATOR=base_addressx -DVALUES=[] --docnum=9 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=base_addressx -DACTUAL=0 -DEXPECTED=1 %s --check-prefix=INVALID-LLE-OPERANDS
+
+# RUN: not yaml2obj -DOPERATOR=startx_endx -DVALUES=[0x01] --docnum=9 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=startx_endx -DACTUAL=1 -DEXPECTED=2 %s --check-prefix=INVALID-LLE-OPERANDS
+
+# RUN: not yaml2obj -DOPERATOR=startx_length -DVALUES=[0x01] --docnum=9 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=startx_length -DACTUAL=1 -DEXPECTED=2 %s --check-prefix=INVALID-LLE-OPERANDS
+
+# RUN: not yaml2obj -DOPERATOR=offset_pair -DVALUES=[] --docnum=9 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=offset_pair -DACTUAL=0 -DEXPECTED=2 %s --check-prefix=INVALID-LLE-OPERANDS
+
+# RUN: not yaml2obj -DOPERATOR=default_location -DVALUES=[0x01] --docnum=9 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=default_location -DACTUAL=1 -DEXPECTED=0 %s --check-prefix=INVALID-LLE-OPERANDS
+
+# RUN: not yaml2obj -DOPERATOR=base_address -DVALUES=[0x01,0x02] --docnum=9 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=base_address -DACTUAL=2 -DEXPECTED=1 %s --check-prefix=INVALID-LLE-OPERANDS
+
+# RUN: not yaml2obj -DOPERATOR=start_end -DVALUES=[0x01,0x02,0x03] --docnum=9 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=start_end -DACTUAL=3 -DEXPECTED=2 %s --check-prefix=INVALID-LLE-OPERANDS
+
+# RUN: not yaml2obj -DOPERATOR=start_length -DVALUES=[0x01] --docnum=9 %s 2>&1 | \
+# RUN:   FileCheck -DOPERATOR=start_length -DACTUAL=1 -DEXPECTED=2 %s --check-prefix=INVALID-LLE-OPERANDS
+
+# INVALID-LLE-OPERANDS: yaml2obj: error: invalid number ([[ACTUAL]]) of operands for the operator: DW_LLE_[[OPERATOR]], [[EXPECTED]] expected
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - Lists:
+        - Entries:
+            - Operator: DW_LLE_[[OPERATOR]]
+              Values:   [[VALUES]]
+
+## l) Test that yaml2obj emits an error message if we specify invalid numbers of operands
+## for a DWARF expression operator.
+
+# RUN: not yaml2obj --docnum=10 -DOPERATOR=consts -DVALUES=[0x01,0x02] %s 2>&1 | \
+# RUN:   FileCheck -DACTUAL=2 -DEXPECTED=1 -DOPERATOR=consts %s --check-prefix=INVALID-OP-OPERANDS
+
+# RUN: not yaml2obj --docnum=10 -DOPERATOR=stack_value -DVALUES=[0x01] %s 2>&1 | \
+# RUN:   FileCheck -DACTUAL=1 -DEXPECTED=0 -DOPERATOR=stack_value %s --check-prefix=INVALID-OP-OPERANDS
+
+# INVALID-OP-OPERANDS: yaml2obj: error: invalid number ([[ACTUAL]]) of operands for the operator: DW_OP_[[OPERATOR]], [[EXPECTED]] expected
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - Lists:
+        - Entries:
+            - Operator: DW_LLE_startx_endx
+              Values:   [ 0x01, 0x02 ]
+              Descriptors:
+                - Operator: DW_OP_[[OPERATOR]]
+                  Values:   [[VALUES]]
+
+## m) Test that an empty list is allowed for a location list table.
+
+# RUN: yaml2obj --docnum=11 %s -o %t11.o
+# RUN: llvm-readelf --hex-dump=.debug_loclists %t11.o | \
+# RUN:   FileCheck %s --check-prefix=EMPTY-LIST
+
+#      EMPTY-LIST: Hex dump of section '.debug_loclists':
+# EMPTY-LIST-NEXT: 0x00000000 08000000 05000800 00000000 ............
+##                            ^-------                   unit_length (4-byte)
+##                                     ^---              version (2-byte)
+##                                         ^-            address_size (1-byte)
+##                                           ^-          segment_selector_size (1-byte)
+##                                              ^------- offset_entry_count (4-byte)
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - Lists: []
+
+## n) Generate the .debug_loclists section from raw section content.
+
+# RUN: yaml2obj --docnum=12 %s -o %t12.o
+# RUN: llvm-readobj --sections --section-data %t12.o | \
+# RUN:   FileCheck %s -DSIZE=3 -DADDRALIGN=0 --check-prefixes=SHDR,ARBITRARY-CONTENT
+
+#      ARBITRARY-CONTENT: SectionData (
+# ARBITRARY-CONTENT-NEXT:   0000: 112233
+# ARBITRARY-CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .debug_loclists
+    Type:    SHT_PROGBITS
+    Content: "112233"
+
+## o) Generate the .debug_loclists section when the "Size" is specified.
+
+# RUN: yaml2obj --docnum=13 %s -o %t13.o
+# RUN: llvm-readelf --hex-dump=.debug_loclists %t13.o | \
+# RUN:   FileCheck %s --check-prefix=SIZE
+
+#       SIZE: Hex dump of section '.debug_loclists':
+#  SIZE-NEXT: 0x00000000 00000000 00000000 00000000 00000000 ................
+# SIZE-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name: .debug_loclists
+    Type: SHT_PROGBITS
+    Size: 0x10
+
+## p) Test that yaml2obj emits an error message when both the "Size" and the
+## "debug_loclists" entry are specified at the same time.
+
+# RUN: not yaml2obj --docnum=14 %s 2>&1 | FileCheck %s --check-prefix=ERROR
+
+# ERROR: yaml2obj: error: cannot specify section '.debug_loclists' 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_loclists
+    Type: SHT_PROGBITS
+    Size: 0x10
+DWARF:
+  debug_loclists:
+    - Lists: []
+
+## q) Test that yaml2obj emits an error message when both the "Content" and the
+## "debug_loclists" entry are specified at the same time.
+
+# RUN: not yaml2obj --docnum=15 %s 2>&1 | FileCheck %s --check-prefix=ERROR
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .debug_loclists
+    Type:    SHT_PROGBITS
+    Content: "00"
+DWARF:
+  debug_loclists:
+    - Lists: []
+
+## r) Test that all the properties can be overridden by the section header when
+## the "debug_loclists" entry doesn't exist.
+
+# RUN: yaml2obj --docnum=16 %s -o %t16.o
+# RUN: llvm-readelf --sections %t16.o | FileCheck %s --check-prefix=OVERRIDDEN
+
+#      OVERRIDDEN: [Nr] Name            Type   Address          Off    Size   ES Flg Lk Inf Al
+#      OVERRIDDEN: [ 1] .debug_loclists STRTAB 0000000000002020 000050 00000c 01   A  2   1  2
+# OVERRIDDEN-NEXT: [ 2] .sec            STRTAB 0000000000000000 00005c 000000 00      0   0  0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_loclists
+    Type:         SHT_STRTAB  ## SHT_PROGBITS by default.
+    Flags:        [SHF_ALLOC] ## 0 by default.
+    Link:         .sec        ## 0 by default.
+    EntSize:      1           ## 0 by default.
+    Info:         1           ## 0 by default.
+    AddressAlign: 2           ## 0 by default.
+    Address:      0x2020      ## 0x00 by default.
+    Offset:       0x50        ## 0x40 for the first section.
+    Size:         0x0c        ## Set the "Size" so that we can reuse the check tag "OVERRIDDEN".
+  - Name:         .sec        ## Linked by .debug_rnglists.
+    Type:         SHT_STRTAB
+
+## s) Test that all the properties can be overridden by the section header when
+## the "debug_loclists" entry exists.
+
+# RUN: yaml2obj --docnum=17 %s -o %t17.o
+# RUN: llvm-readelf --sections %t17.o | FileCheck %s --check-prefix=OVERRIDDEN
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_loclists
+    Type:         SHT_STRTAB  ## SHT_PROGBITS by default.
+    Flags:        [SHF_ALLOC] ## 0 by default.
+    Link:         .sec        ## 0 by default.
+    EntSize:      1           ## 0 by default.
+    Info:         1           ## 0 by default.
+    AddressAlign: 2           ## 1 by default.
+    Address:      0x2020      ## 0x00 by default.
+    Offset:       0x50        ## 0x40 for the first section.
+  - Name:         .sec        ## Linked by .debug_rnglists.
+    Type:         SHT_STRTAB
+DWARF:
+  debug_loclists:
+    - Lists: []
+
+## t) Test that the .debug_loclists section header is emitted if the "debug_loclists"
+## entry is empty.
+
+# RUN: yaml2obj --docnum=18 %s -o %t18.o
+# RUN: llvm-readobj --sections --section-data %t18.o | \
+# RUN:   FileCheck -DSIZE=0 -DADDRALIGN=1 %s --check-prefixes=SHDR,EMPTY-CONTENT
+
+# EMPTY-CONTENT-NEXT: SectionData (
+# EMPTY-CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists: []
+
+## u) Test that yaml2obj emits an error message if we use an unimplemented DWARF expression
+## operator.
+
+# RUN: not yaml2obj --docnum=19 %s -o %t19.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=UNIMPLEMENTED-OP
+
+# UNIMPLEMENTED-OP: yaml2obj: error: DWARF expression: DW_OP_reg0 is not supported
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_loclists:
+    - Lists:
+        - Entries:
+            - Operator: DW_LLE_default_location
+              Descriptors:
+                - Operator: DW_OP_reg0