[DebugInfo] Support zero-length CIE in the _eh_frame parser

[igor-laevsky]

Summary

MCJIT emits zero-length CIE at the end of the _eh_frame section. This change
ensures that parser inside DebugInfo will not crash and correctly record such cases.
We are now recording DW_EH_PE_omit as a default value for FDE and LSDA encodings.
This seems to be in sync with MCDwarf.cpp _eh_frame emitter. Also Offset != EndAugmentationOffset
assertion check will only happen if augmentation string had 'z' letter in it.

Unfortunately I couldn't think of an easy way to write llvm-lit tests for this.
However feature seems simple enough to survive using existing tests.

[pete]

I took a look at the code in LLVM to emit the eh_frame's and there are paths in there that would allow us to get an eh_frame emitted with omitted LSDA's. I can't really get my head around what it would take to write a test for that either, but the code being able to emit such a thing means I think its good to support it in the parser too.

So after all that, LGTM :)

[• rafael]

You should be able to test it by writing a .eh_frame manually. In
particularly, the terminator CIE is just

.section .eh_frame
.long 0

No?

Cheers,
Rafael

[igor-laevsky]

In D16588#336313, @rafael wrote:

You should be able to test it by writing a .eh_frame manually. In
particularly, the terminator CIE is just

.section .eh_frame
.long 0

Yes, actually this works. For some reason I though it shouldn't. Submitted change with a test case.

[ygao]

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

645

I noticed a compile-time warning on this line:
warning: variable ‘LSDA’ set but not used [-Wunused-but-set-variable]

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

 class CIE : public FrameEntry {
 public:
   // CIEs (and FDEs) are simply container classes, so the only sensible way to
   // create them is by providing the full parsed contents in the constructor.
   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
       SmallString<8> Augmentation, uint8_t AddressSize,
       uint8_t SegmentDescriptorSize, uint64_t CodeAlignmentFactor,
       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister,
-      SmallString<8> AugmentationData, Optional<uint32_t> FDEPointerEncoding,
-      Optional<uint32_t> LSDAPointerEncoding)
+      SmallString<8> AugmentationData, uint32_t FDEPointerEncoding,
+      uint32_t LSDAPointerEncoding)
       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
         Augmentation(std::move(Augmentation)),
         AddressSize(AddressSize),
         SegmentDescriptorSize(SegmentDescriptorSize),
         CodeAlignmentFactor(CodeAlignmentFactor),
         DataAlignmentFactor(DataAlignmentFactor),
         ReturnAddressRegister(ReturnAddressRegister),
         AugmentationData(AugmentationData),
         FDEPointerEncoding(FDEPointerEncoding),
         LSDAPointerEncoding(LSDAPointerEncoding) { }
 
   ~CIE() override {}
 
   StringRef getAugmentationString() const { return Augmentation; }
   uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
   int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
-  Optional<uint32_t> getFDEPointerEncoding() const {
+  uint32_t getFDEPointerEncoding() const {
     return FDEPointerEncoding;
   }
-  Optional<uint32_t> getLSDAPointerEncoding() const {
+  uint32_t getLSDAPointerEncoding() const {
     return LSDAPointerEncoding;
   }
 
   void dumpHeader(raw_ostream &OS) const override {
     OS << format("%08x %08x %08x CIE",
                  (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
        << "\n";
     OS << format("  Version:               %d\n", Version);
private:
   uint8_t AddressSize;
   uint8_t SegmentDescriptorSize;
   uint64_t CodeAlignmentFactor;
   int64_t DataAlignmentFactor;
   uint64_t ReturnAddressRegister;
 
   // The following are used when the CIE represents an EH frame entry.
   SmallString<8> AugmentationData;
-  Optional<uint32_t> FDEPointerEncoding;
-  Optional<uint32_t> LSDAPointerEncoding;
+  uint32_t FDEPointerEncoding;
+  uint32_t LSDAPointerEncoding;
 };
 
 
 /// \brief DWARF Frame Description Entry (FDE)
 class FDE : public FrameEntry {
 public:
   // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
   // an offset to the CIE (provided by parsing the FDE header). The CIE itself
if (IsCIE) {
                                           Data.getU8(&Offset);
       Data.setAddressSize(AddressSize);
       uint8_t SegmentDescriptorSize = Version < 4 ? 0 : Data.getU8(&Offset);
       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
 
       // Parse the augmentation data for EH CIEs
-      StringRef AugmentationData;
-      Optional<uint32_t> FDEPointerEncoding;
-      Optional<uint32_t> LSDAPointerEncoding;
+      StringRef AugmentationData("");
+      uint32_t FDEPointerEncoding = DW_EH_PE_omit;
+      uint32_t LSDAPointerEncoding = DW_EH_PE_omit;
       if (IsEH) {
         Optional<uint32_t> PersonalityEncoding;
         Optional<uint64_t> Personality;
 
-        uint64_t AugmentationLength = 0;
-        uint32_t StartAugmentationOffset = 0;
-        uint32_t EndAugmentationOffset = 0;
+        Optional<uint64_t> AugmentationLength;
+        uint32_t StartAugmentationOffset;
+        uint32_t EndAugmentationOffset;
 
         // Walk the augmentation string to get all the augmentation data.
         for (unsigned i = 0, e = AugmentationString.size(); i != e; ++i) {
           switch (AugmentationString[i]) {
             default:
               ReportError("Unknown augmentation character in entry at %lx");
             case 'L':
-              if (LSDAPointerEncoding)
-                ReportError("Duplicate LSDA encoding in entry at %lx");
               LSDAPointerEncoding = Data.getU8(&Offset);
               break;
             case 'P': {
               if (Personality)
                 ReportError("Duplicate personality in entry at %lx");
               PersonalityEncoding = Data.getU8(&Offset);
               Personality = readPointer(Data, Offset, *PersonalityEncoding);
               break;
             }
             case 'R':
-              if (FDEPointerEncoding)
-                ReportError("Duplicate FDE encoding in entry at %lx");
               FDEPointerEncoding = Data.getU8(&Offset);
               break;
             case 'z':
               if (i)
                 ReportError("'z' must be the first character at %lx");
               // Parse the augmentation length first.  We only parse it if
               // the string contains a 'z'.
               AugmentationLength = Data.getULEB128(&Offset);
               StartAugmentationOffset = Offset;
-              EndAugmentationOffset =
-                Offset + static_cast<uint32_t>(AugmentationLength);
+              EndAugmentationOffset = Offset +
+                static_cast<uint32_t>(*AugmentationLength);
           }
         }
 
+        if (AugmentationLength.hasValue()) {
           if (Offset != EndAugmentationOffset)
             ReportError("Parsing augmentation data at %lx failed");
 
           AugmentationData = Data.getData().slice(StartAugmentationOffset,
                                                   EndAugmentationOffset);
         }
+      }
 
       auto Cie = make_unique<CIE>(StartOffset, Length, Version,
-                                  StringRef(Augmentation), AddressSize,
+                                  AugmentationString, AddressSize,
                                   SegmentDescriptorSize, CodeAlignmentFactor,
                                   DataAlignmentFactor, ReturnAddressRegister,
                                   AugmentationData, FDEPointerEncoding,
                                   LSDAPointerEncoding);
       CIEs[StartOffset] = Cie.get();
       Entries.emplace_back(std::move(Cie));
     } else {
       // FDE
       uint64_t CIEPointer = Id;
       uint64_t InitialLocation = 0;
       uint64_t AddressRange = 0;
       CIE *Cie = CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer];
 
       if (IsEH) {
         // The address size is encoded in the CIE we reference.
         if (!Cie)
           ReportError("Parsing FDE data at %lx failed due to missing CIE");
 
-        Optional<uint32_t> FDEPointerEncoding = Cie->getFDEPointerEncoding();
-        if (!FDEPointerEncoding)
-          ReportError("Parsing at %lx failed due to missing pointer encoding");
+        InitialLocation = readPointer(Data, Offset,
+                                      Cie->getFDEPointerEncoding());
+        AddressRange = readPointer(Data, Offset,
+                                   Cie->getFDEPointerEncoding());
 
-        InitialLocation = readPointer(Data, Offset, *FDEPointerEncoding);
-        AddressRange = readPointer(Data, Offset, *FDEPointerEncoding);
         StringRef AugmentationString = Cie->getAugmentationString();
         if (!AugmentationString.empty()) {
           // Parse the augmentation length and data for this FDE.
           uint64_t AugmentationLength = Data.getULEB128(&Offset);
 
           uint32_t EndAugmentationOffset =
             Offset + static_cast<uint32_t>(AugmentationLength);
 
           // Decode the LSDA if the CIE augmentation string said we should.
           uint64_t LSDA = 0;
-          if (Optional<uint32_t> Encoding = Cie->getLSDAPointerEncoding())
-            LSDA = readPointer(Data, Offset, *Encoding);
+          if (Cie->getLSDAPointerEncoding() != DW_EH_PE_omit)
+            LSDA = readPointer(Data, Offset, Cie->getLSDAPointerEncoding());
 
           if (Offset != EndAugmentationOffset)
             ReportError("Parsing augmentation data at %lx failed");
         }
       } else {
         InitialLocation = Data.getAddress(&Offset);
         AddressRange = Data.getAddress(&Offset);
       }

llvm/trunk/test/tools/llvm-objdump/eh_frame_zero_cie.test

+# RUN: llvm-objdump -dwarf=frames %p/Inputs/eh_frame_zero_cie.o 2>/dev/null | FileCheck %s
+
+# CHECK: .eh_frame contents:
+
+# CHECK: 00000000 00000000 ffffffff CIE
+# CHECK:   Version:               0
+# CHECK:   Augmentation:          ""
+# CHECK:   Code alignment factor: 0
+# CHECK:   Data alignment factor: 0
+# CHECK:   Return address column: 0