[DebugInfo] Make base type placeholder values larger than 0

[dstenb]

Summary

This is a preparatory change for allowing LLVM to emit DW_OP_convert
operations converting to the generic type.

When we emit a base type reference in location lists, we first emit a
placeholder in the byte stream, and later on resolve that to the DIE's
actual offset. That placeholder value was the index in the
ExprRefedBaseTypes array; i.e. starting from 0. To allow us to
distinguish generic type DW_OP_convert operations (i.e., with operand 0)
from the ones that refer to base types, this patch changes the code so
that the placeholder values instead start at 1. To avoid future
programmering errors due to this change, this patch also does some
refactoring:

• Makes ExprRefedBaseTypes private in DwarfCompileUnit, and adds helper functions to create and retrieve base types, so that outside users don't index the array directly.
• Renames the placeholder "index" to "key" instead to reduce the risk for off-by-one errors in the code.

This patch means that we reduce the number of unique placeholder values
by one (now 2^28 - 1). However, as the resolved DIE offsets must fit
inside the same ULEB widths as the placeholder values, we cannot support
nearly that many base types, so this should not be a problem in
practice. Otherwise, this should be a non-functional change, so I have
not added any new tests.

[dstenb]

This was something I overlooked when implementing D76145.

llvm/include/llvm/CodeGen/DIE.h

public:
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A BaseTypeRef DIE.
 class DIEBaseTypeRef {
   const DwarfCompileUnit *CU;
-  const uint64_t Index;
+  const uint64_t Key;
   static constexpr unsigned ULEB128PadSize = 4;
 
 public:
-  explicit DIEBaseTypeRef(const DwarfCompileUnit *TheCU, uint64_t Idx)
-    : CU(TheCU), Index(Idx) {}
+  explicit DIEBaseTypeRef(const DwarfCompileUnit *TheCU, uint64_t TheKey)
+      : CU(TheCU), Key(TheKey) {}
 
   /// EmitValue - Emit base type reference.
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   /// SizeOf - Determine size of the base type reference in bytes.
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };

llvm/lib/CodeGen/AsmPrinter/DIE.cpp

 LLVM_DUMP_METHOD
 void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
 
 //===----------------------------------------------------------------------===//
 // DIEBaseTypeRef Implementation
 //===----------------------------------------------------------------------===//
 
 void DIEBaseTypeRef::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
-  uint64_t Offset = CU->ExprRefedBaseTypes[Index].Die->getOffset();
+  uint64_t Offset = CU->getBaseTypeDIE(Key)->getOffset();
   assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
   AP->emitULEB128(Offset, nullptr, ULEB128PadSize);
 }
 
 unsigned DIEBaseTypeRef::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
   return ULEB128PadSize;
 }
 
 LLVM_DUMP_METHOD
-void DIEBaseTypeRef::print(raw_ostream &O) const { O << "BaseTypeRef: " << Index; }
+void DIEBaseTypeRef::print(raw_ostream &O) const {
+  O << "BaseTypeRef: " << Key;
+}
 
 //===----------------------------------------------------------------------===//
 // DIEDelta Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit delta value.
 ///
 void DIEDelta::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

class DwarfCompileUnit final : public DwarfUnit {
   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {
     if (isDwoUnit() && !DD->shareAcrossDWOCUs())
       return AbstractEntities;
     return DU->getAbstractEntities();
   }
 
   void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) override;
 
+  struct BaseTypeRef {
+    BaseTypeRef(unsigned BitSize, dwarf::TypeKind Encoding)
+        : BitSize(BitSize), Encoding(Encoding) {}
+    unsigned BitSize;
+    dwarf::TypeKind Encoding;
+    DIE *Die = nullptr;
+  };
+
+  std::vector<BaseTypeRef> ExprRefedBaseTypes;
+
 public:
   DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A,
                    DwarfDebug *DW, DwarfFile *DWU,
                    UnitKind Kind = UnitKind::Full);
 
   bool hasRangeLists() const { return HasRangeLists; }
   unsigned getUniqueID() const { return UniqueID; }
 
public:
   void applyStmtList(DIE &D);
 
   /// A pair of GlobalVariable and DIExpression.
   struct GlobalExpr {
     const GlobalVariable *Var;
     const DIExpression *Expr;
   };
 
-  struct BaseTypeRef {
-    BaseTypeRef(unsigned BitSize, dwarf::TypeKind Encoding) :
-      BitSize(BitSize), Encoding(Encoding) {}
-    unsigned BitSize;
-    dwarf::TypeKind Encoding;
-    DIE *Die = nullptr;
-  };
+  /// Return the placeholder key for the base type with the given properties and
+  /// create one if necessary.
+  unsigned getOrCreateBaseType(unsigned BitSize, dwarf::TypeKind Encoding) {
+    // Reuse the base_type if we already have one in this CU otherwise we
+    // create a new one.
+    unsigned I = 0, E = ExprRefedBaseTypes.size();
+    for (; I != E; ++I)
+      if (ExprRefedBaseTypes[I].BitSize == BitSize &&
+          ExprRefedBaseTypes[I].Encoding == Encoding)
+        break;
+
+    if (I == E)
+      ExprRefedBaseTypes.emplace_back(BitSize, Encoding);
+
+    // Some operations that take base type reference operands can have a
+    // zero-valued operand to indicate the generic type in DWARF, rather than a
+    // base type. An example of such an operation is DW_OP_convert. To be able
+    // to distinguish between the generic type and the placeholder keys we
+    // return from this function we increment the index by one here, and that is
+    // later on accounted for by getBaseTypeDIE().
+    return I + 1;
+  }
 
-  std::vector<BaseTypeRef> ExprRefedBaseTypes;
+  /// Return the DIE corresponding to the given placeholder key.
+  DIE *getBaseTypeDIE(unsigned Key) const {
+    assert(Key > 0 &&
+           "The value 0 is reserved for the generic type, not base type DIEs");
+    return ExprRefedBaseTypes[Key - 1].Die;
+  }
 
   /// Get or create global variable DIE.
   DIE *
   getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV,
                                ArrayRef<GlobalExpr> GlobalExprs);
 
   DIE *getOrCreateCommonBlock(const DICommonBlock *CB,
                               ArrayRef<GlobalExpr> GlobalExprs);
public:
   void setBaseAddress(const MCSymbol *Base) { BaseAddress = Base; }
   const MCSymbol *getBaseAddress() const { return BaseAddress; }
 
   uint64_t getDWOId() const { return DWOId; }
   void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
 
   bool hasDwarfPubSections() const;
 
-  void addBaseTypeRef(DIEValueList &Die, int64_t Idx);
+  void addBaseTypeRef(DIEValueList &Die, int64_t Key);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

void DwarfCompileUnit::addAddrTableBase() {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
   MCSymbol *Label = DD->getAddressPool().getLabel();
   addSectionLabel(getUnitDie(),
                   getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base
                                          : dwarf::DW_AT_GNU_addr_base,
                   Label, TLOF.getDwarfAddrSection()->getBeginSymbol());
 }
 
-void DwarfCompileUnit::addBaseTypeRef(DIEValueList &Die, int64_t Idx) {
+void DwarfCompileUnit::addBaseTypeRef(DIEValueList &Die, int64_t Key) {
   Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, dwarf::DW_FORM_udata,
-               new (DIEValueAllocator) DIEBaseTypeRef(this, Idx));
+               new (DIEValueAllocator) DIEBaseTypeRef(this, Key));
 }
 
 void DwarfCompileUnit::createBaseTypeDIEs() {
   // Insert the base_type DIEs directly after the CU so that their offsets will
   // fit in the fixed size ULEB128 used inside the location expressions.
   // Maintain order by iterating backwards and inserting to the front of CU
   // child list.
   for (auto &Btr : reverse(ExprRefedBaseTypes)) {

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) {
   getActiveStreamer().emitULEB128(Value, Twine(Value));
 }
 
 void DebugLocDwarfExpression::emitData1(uint8_t Value) {
   getActiveStreamer().EmitInt8(Value, Twine(Value));
 }
 
-void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
-  assert(Idx < (1ULL << (ULEB128PadSize * 7)) && "Idx wont fit");
-  getActiveStreamer().emitULEB128(Idx, Twine(Idx), ULEB128PadSize);
+void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Key) {
+  assert(Key < (1ULL << (ULEB128PadSize * 7)) && "Key wont fit");
+  getActiveStreamer().emitULEB128(Key, Twine(Key), ULEB128PadSize);
 }
 
 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
                                               unsigned MachineReg) {
   // This information is not available while emitting .debug_loc entries.
   return false;
 }
 
for (auto &Op : Expr) {
     assert(Op.getCode() != dwarf::DW_OP_const_type &&
            "3 operand ops not yet supported");
     Streamer.EmitInt8(Op.getCode(), Comment != End ? *(Comment++) : "");
     Offset++;
     for (unsigned I = 0; I < 2; ++I) {
       if (Op.getDescription().Op[I] == Encoding::SizeNA)
         continue;
       if (Op.getDescription().Op[I] == Encoding::BaseTypeRef) {
-        uint64_t Offset =
-            CU->ExprRefedBaseTypes[Op.getRawOperand(I)].Die->getOffset();
+        assert(Op.getRawOperand(I) &&
+               "BaseTypeRefs referring to the generic type are not supported");
+        uint64_t Offset = CU->getBaseTypeDIE(Op.getRawOperand(I))->getOffset();
         assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
         Streamer.emitULEB128(Offset, "", ULEB128PadSize);
         // Make sure comments stay aligned.
         for (unsigned J = 0; J < ULEB128PadSize; ++J)
           if (Comment != End)
             Comment++;
       } else {
         for (uint64_t J = Offset; J < Op.getOperandEndOffset(I); ++J)

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h

protected:
   /// Emit a raw signed value.
   virtual void emitSigned(int64_t Value) = 0;
 
   /// Emit a raw unsigned value.
   virtual void emitUnsigned(uint64_t Value) = 0;
 
   virtual void emitData1(uint8_t Value) = 0;
 
-  virtual void emitBaseTypeRef(uint64_t Idx) = 0;
+  virtual void emitBaseTypeRef(uint64_t Key) = 0;
 
   /// Start emitting data to the temporary buffer. The data stored in the
   /// temporary buffer can be committed to the main output using
   /// commitTemporaryBuffer().
   virtual void enableTemporaryBuffer() = 0;
 
   /// Disable emission to the temporary buffer. This does not commit data
   /// in the temporary buffer to the main output.
bool addMachineRegExpression(const TargetRegisterInfo &TRI,
                                unsigned FragmentOffsetInBits = 0);
 
   /// Begin emission of an entry value dwarf operation. The entry value's
   /// first operand is the size of the DWARF block (its second operand),
   /// which needs to be calculated at time of emission, so we don't emit
   /// any operands here.
   void beginEntryValueExpression(DIExpressionCursor &ExprCursor);
 
-  /// Return the index of a base type with the given properties and
-  /// create one if necessary.
-  unsigned getOrCreateBaseType(unsigned BitSize, dwarf::TypeKind Encoding);
-
   /// Emit all remaining operations in the DIExpressionCursor.
   ///
   /// \param FragmentOffsetInBits     If this is one fragment out of multiple
   ///                                 locations, this is the offset of the
   ///                                 fragment inside the entire variable.
   void addExpression(DIExpressionCursor &&Expr,
                      unsigned FragmentOffsetInBits = 0);
 
class DebugLocDwarfExpression final : public DwarfExpression {
 
   /// Return the byte streamer that currently is being emitted to.
   ByteStreamer &getActiveStreamer() { return IsBuffering ? TmpBuf->BS : OutBS; }
 
   void emitOp(uint8_t Op, const char *Comment = nullptr) override;
   void emitSigned(int64_t Value) override;
   void emitUnsigned(uint64_t Value) override;
   void emitData1(uint8_t Value) override;
-  void emitBaseTypeRef(uint64_t Idx) override;
+  void emitBaseTypeRef(uint64_t Key) override;
 
   void enableTemporaryBuffer() override;
   void disableTemporaryBuffer() override;
   unsigned getTemporaryBufferSize() override;
   void commitTemporaryBuffer() override;
 
   bool isFrameRegister(const TargetRegisterInfo &TRI,
                        unsigned MachineReg) override;
class DIEDwarfExpression final : public DwarfExpression {
 
   /// Return the DIE that currently is being emitted to.
   DIELoc &getActiveDIE() { return IsBuffering ? TmpDIE : OutDIE; }
 
   void emitOp(uint8_t Op, const char *Comment = nullptr) override;
   void emitSigned(int64_t Value) override;
   void emitUnsigned(uint64_t Value) override;
   void emitData1(uint8_t Value) override;
-  void emitBaseTypeRef(uint64_t Idx) override;
+  void emitBaseTypeRef(uint64_t Key) override;
 
   void enableTemporaryBuffer() override;
   void disableTemporaryBuffer() override;
   unsigned getTemporaryBufferSize() override;
   void commitTemporaryBuffer() override;
 
   bool isFrameRegister(const TargetRegisterInfo &TRI,
                        unsigned MachineReg) override;

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

void DwarfExpression::finalizeEntryValue() {
   emitUnsigned(Size);
 
   // Emit the entry value's DWARF block operand.
   commitTemporaryBuffer();
 
   IsEmittingEntryValue = false;
 }
 
-unsigned DwarfExpression::getOrCreateBaseType(unsigned BitSize,
-                                              dwarf::TypeKind Encoding) {
-  // Reuse the base_type if we already have one in this CU otherwise we
-  // create a new one.
-  unsigned I = 0, E = CU.ExprRefedBaseTypes.size();
-  for (; I != E; ++I)
-    if (CU.ExprRefedBaseTypes[I].BitSize == BitSize &&
-        CU.ExprRefedBaseTypes[I].Encoding == Encoding)
-      break;
-
-  if (I == E)
-    CU.ExprRefedBaseTypes.emplace_back(BitSize, Encoding);
-  return I;
-}
-
 /// Assuming a well-formed expression, match "DW_OP_deref*
 /// DW_OP_LLVM_fragment?".
 static bool isMemoryLocation(DIExpressionCursor ExprCursor) {
   while (ExprCursor) {
     auto Op = ExprCursor.take();
     switch (Op->getOp()) {
     case dwarf::DW_OP_deref:
     case dwarf::DW_OP_LLVM_fragment:
case dwarf::DW_OP_constu:
       assert(!isRegisterLocation());
       emitConstu(Op->getArg(0));
       break;
     case dwarf::DW_OP_LLVM_convert: {
       unsigned BitSize = Op->getArg(0);
       dwarf::TypeKind Encoding = static_cast<dwarf::TypeKind>(Op->getArg(1));
       if (DwarfVersion >= 5) {
         emitOp(dwarf::DW_OP_convert);
-        // If targeting a location-list; simply emit the index into the raw
-        // byte stream as ULEB128, DwarfDebug::emitDebugLocEntry has been
+        // If targeting a location-list; simply emit a placeholder key into the
+        // raw byte stream as ULEB128, DwarfDebug::emitDebugLocEntry has been
         // fitted with means to extract it later.
         // If targeting a inlined DW_AT_location; insert a DIEBaseTypeRef
-        // (containing the index and a resolve mechanism during emit) into the
-        // DIE value list.
-        emitBaseTypeRef(getOrCreateBaseType(BitSize, Encoding));
+        // (containing the placeholder key and a resolve mechanism during emit)
+        // into the DIE value list.
+        emitBaseTypeRef(CU.getOrCreateBaseType(BitSize, Encoding));
       } else {
         if (PrevConvertOp && PrevConvertOp->getArg(0) < BitSize) {
           if (Encoding == dwarf::DW_ATE_signed)
             emitLegacySExt(PrevConvertOp->getArg(0));
           else if (Encoding == dwarf::DW_ATE_unsigned)
             emitLegacyZExt(PrevConvertOp->getArg(0));
           PrevConvertOp = None;
         } else {

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
   CU.addUInt(getActiveDIE(), dwarf::DW_FORM_udata, Value);
 }
 
 void DIEDwarfExpression::emitData1(uint8_t Value) {
   CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Value);
 }
 
-void DIEDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
-  CU.addBaseTypeRef(getActiveDIE(), Idx);
+void DIEDwarfExpression::emitBaseTypeRef(uint64_t Key) {
+  CU.addBaseTypeRef(getActiveDIE(), Key);
 }
 
 void DIEDwarfExpression::enableTemporaryBuffer() {
   assert(!IsBuffering && "Already buffering?");
   IsBuffering = true;
 }
 
 void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; }