[DWARF][WIP] Add Skeleton CU to DWO CU during creation.

[ayermolo]

Summary

Context: https://lists.llvm.org/pipermail/llvm-dev/2021-February/148521.html

Work in progress diff, to start a conversation how to fix address/location apis for debug fission.

[dblaikie]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

420–421

It's not clear to me how/what this API does - "Unit" is a DWO CU and "this" is the DWARFContext for the executable file (as opposed to for the DWO or DWP file)? Or the other way around?

[ayermolo]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

420–421

The "this" DWARFContext is tied to DWO CU. The Unit is for the CU from the binary, the Skeleton CU.

So for example in this user code:
The DwCtx is Context for the binary.

for (const auto &CU : DwCtx->compile_units()) {

auto *const DwarfUnit = CU.get();
 if (llvm::Optional<uint64_t> DWOId = DwarfUnit->getDWOId()) {
   auto *CUDWO = static_cast<DWARFCompileUnit*>(DwarfUnit->getNonSkeletonUnitDIE(false).getDwarfUnit());
   ...
 }

}

When getNonSkeletonUnitDIE is invoked, it invokes:
DWARFUnit::parseDWO
It creates the DWOContext for the dwo CU in the .o/.dwo file.

We then call:
DWOContext->addSkeletonCU(this)

So in this case "this" is the DwarfUnit from earlier in user code.
After everything is done.
In the CU from binary the DWO field will point to the DWO CU.
In the DWO CU NormalUnits vector will have one entry that is CU from the binary.

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

public:
   }
 
   /// Return the compile unit which contains instruction with provided
   /// address.
   /// TODO: change input parameter from "uint64_t Address"
   ///       into "SectionedAddress Address"
   DWARFCompileUnit *getCompileUnitForAddress(uint64_t Address);
 
+  /// Add Skeleton CU for DWO CU.
+  Error addSkeletonCU(DWARFUnit *Unit);
+
 private:
   /// Parse a macro[.dwo] or macinfo[.dwo] section.
   std::unique_ptr<DWARFDebugMacro>
   parseMacroOrMacinfo(MacroSecType SectionType);
 
   void addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram, DWARFDie Die,
                        std::vector<DILocal> &Result);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

class DWARFUnit {
 
   uint32_t getDIEIndex(const DWARFDebugInfoEntry *Die) {
     auto First = DieArray.data();
     assert(Die >= First && Die < First + DieArray.size());
     return Die - First;
   }
 
 protected:
-  const DWARFUnitHeader &getHeader() const { return Header; }
 
   /// Size in bytes of the parsed unit header.
   uint32_t getHeaderSize() const { return Header.getSize(); }
 
   /// Find the unit's contribution to the string offsets table and determine its
   /// length and form. The given offset is expected to be derived from the unit
   /// DIE's DW_AT_str_offsets_base attribute.
   Expected<Optional<StrOffsetsContributionDescriptor>>
DWARFUnit(DWARFContext &Context, const DWARFSection &Section,
             const DWARFUnitHeader &Header, const DWARFDebugAbbrev *DA,
             const DWARFSection *RS, const DWARFSection *LocSection,
             StringRef SS, const DWARFSection &SOS, const DWARFSection *AOS,
             const DWARFSection &LS, bool LE, bool IsDWO,
             const DWARFUnitVector &UnitVector);
 
   virtual ~DWARFUnit();
 
+  const DWARFUnitHeader &getHeader() const { return Header; }
   bool isDWOUnit() const { return IsDWO; }
   DWARFContext& getContext() const { return Context; }
   const DWARFSection &getInfoSection() const { return InfoSection; }
   uint64_t getOffset() const { return Header.getOffset(); }
   const dwarf::FormParams &getFormParams() const {
     return Header.getFormParams();
   }
   uint16_t getVersion() const { return Header.getVersion(); }

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

uint8_t DWARFContext::getCUAddrSize() {
   // In theory, different compile units may have different address byte
   // sizes, but for simplicity we just use the address byte size of the
   // first compile unit. In practice the address size field is repeated across
   // various DWARF headers (at least in version 5) to make it easier to dump
   // them independently, not to enable varying the address size.
   auto CUs = compile_units();
   return CUs.empty() ? 0 : (*CUs.begin())->getAddressByteSize();
 }
+
+Error DWARFContext::addSkeletonCU(DWARFUnit *Unit) {
+  if (this->DWOUnits.empty()) {
+    return createError("Not DWO Unit.",
+                          errorCodeToError(object_error::parse_failed));
+  }
+
+  auto &DCtx = Unit->getContext();
+  auto &DObj = DCtx.getDWARFObj();
+  auto *NUnit = NormalUnits.addUnit(std::make_unique<DWARFCompileUnit>(
+            DCtx, Unit->getInfoSection(), Unit->getHeader(), DCtx.getDebugAbbrev(), &DObj.getRangesSection(),
+            &DObj.getLocSection(), DObj.getStrSection(),
+            DObj.getStrOffsetsSection(), &DObj.getAddrSection(),
+            DObj.getLineSection(), DCtx.isLittleEndian(), false,
+            NormalUnits));
+
+  auto AddrOffsetSectionBase = Unit->getAddrOffsetSectionBase();
+  if (AddrOffsetSectionBase)
+    NUnit->setAddrOffsetSection(&DObj.getAddrSection(), *AddrOffsetSectionBase);
+  return Error::success();
+}

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

if (!DWOId)
     return false;
   auto DWOContext = Context.getDWOContext(AbsolutePath);
   if (!DWOContext)
     return false;
 
   DWARFCompileUnit *DWOCU = DWOContext->getDWOCompileUnitForHash(*DWOId);
   if (!DWOCU)
     return false;
+  if(Error Err = DWOContext->addSkeletonCU(this))
+    return false;
   DWO = std::shared_ptr<DWARFCompileUnit>(std::move(DWOContext), DWOCU);
   // Share .debug_addr and .debug_ranges section with compile unit in .dwo
   if (AddrOffsetSectionBase)
     DWO->setAddrOffsetSection(AddrOffsetSection, *AddrOffsetSectionBase);
   if (getVersion() >= 5) {
     DWO->setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(),
                           DWARFListTableHeader::getHeaderSize(getFormat()));
   } else {