merge amd-debug into amd-staging (llvm#2511)

Author: ronlieb

.github/workflows/buildbot-psdb-trigger.yml

@@ -9,7 +9,8 @@ on:
 jobs:  
   trigger-build:
     if: github.event.pull_request.draft == false
-    runs-on: self-hosted
+    runs-on: 
+      group: compiler-generic-runners
     env:  
       PR_SHA: ${{ github.event.pull_request.head.sha != '' && github.event.pull_request.head.sha || github.sha }}
       PR_NUMBER: ${{ github.event.pull_request.number != '' && github.event.pull_request.number || 0 }}

llvm/include/llvm/IR/DebugInfoMetadata.h

@@ -1262,6 +1262,12 @@ class DIDerivedType : public DIType {
 
   TempDIDerivedType clone() const { return cloneImpl(); }
 
+  TempDIDerivedType cloneWithAddressSpace(unsigned DWARFAddrSpace) const {
+    auto Tmp = clone();
+    Tmp->DWARFAddressSpace = DWARFAddrSpace;
+    return Tmp;
+  }
+
   /// Get the base type this is derived from.
   DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
   Metadata *getRawBaseType() const { return getOperand(3); }
@@ -3705,6 +3711,19 @@ class DIExpression : public MDNode {
   element_iterator elements_begin() const { return getElements().begin(); }
   element_iterator elements_end() const { return getElements().end(); }
 
+  /// Returns the pointer address space this DIOp-based DIExpression produces.
+  /// Note that this may diverge from the the pointer address space of the
+  /// result type. When there is a divergent address space, the DIExpression
+  /// must produce a generic pointer whose value can be proven to belong to a
+  /// more specific address space. For instance in this expression, this
+  /// function returns 4:
+  ///
+  ///   !DIExpression(DIOpArg(0, ptr addrspace(4)), DIOpConvert(ptr))
+  ///
+  /// A divergent address space can be created by a DIOpConvert, and is
+  /// preserved across DIOpReinterpret.
+  std::optional<unsigned> getNewDivergentAddrSpace() const;
+
   /// A lightweight wrapper around an expression operand.
   ///
   /// TODO: Store arguments directly and change \a DIExpression to store a

llvm/include/llvm/Transforms/Utils/Local.h

@@ -366,7 +366,7 @@ Value *salvageDebugInfoImpl(Instruction &I, uint64_t CurrentLocOps,
 /// introducing a use-before-def, it is either salvaged (\ref salvageDebugInfo)
 /// or deleted. Returns true if any debug users were updated.
 bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint,
-                           DominatorTree &DT);
+                           const DominatorTree &DT);
 
 /// If a terminator in an unreachable basic block has an operand of type
 /// Instruction, transform it into poison. Return true if any operands

llvm/lib/CodeGen/AsmPrinter/DebugLocStream.cpp

@@ -40,5 +40,5 @@ void DebugLocStream::finalizeEntry() {
 DebugLocStream::ListBuilder::~ListBuilder() {
   if (!Locs.finalizeList(Asm))
     return;
-  V.emplace<Loc::Multi>(ListIndex, TagOffset);
+  V.emplace<Loc::Multi>(ListIndex, TagOffset, CommonAddrSpace);
 }

llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h

@@ -157,6 +157,7 @@ class DebugLocStream::ListBuilder {
   DbgVariable &V;
   size_t ListIndex;
   std::optional<uint8_t> TagOffset;
+  std::optional<unsigned> CommonAddrSpace;
 
 public:
   ListBuilder(DebugLocStream &Locs, DwarfCompileUnit &CU, AsmPrinter &Asm,
@@ -168,6 +169,11 @@ class DebugLocStream::ListBuilder {
     TagOffset = TO;
   }
 
+  void setCommonDivergentAddrSpace(unsigned AS) { CommonAddrSpace = AS; }
+  bool hasCommonDivergentAddrSpace() const {
+    return CommonAddrSpace != std::nullopt;
+  }
+
   /// Finalize the list.
   ///
   /// If the list is empty, delete it.  Otherwise, finalize it by creating a

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

@@ -891,6 +891,8 @@ void DwarfCompileUnit::applyConcreteDbgVariableAttributes(
 
   if (Expr) {
     if (auto NewElementsRef = Expr->getNewElementsRef()) {
+      if (DV.isDivergentAddrSpaceCompatible())
+        DwarfExpr.permitDivergentAddrSpace();
       DwarfExpr.addExpression(*NewElementsRef, DVal->getLocEntries(), &TRI);
       addBlock(VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
       return;
@@ -973,6 +975,8 @@ void DwarfCompileUnit::applyConcreteDbgVariableAttributes(const Loc::MMI &MMI,
     addBlock(VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
     return;
   }
+  if (DV.isDivergentAddrSpaceCompatible())
+    DwarfExpr.permitDivergentAddrSpace();
   for (const auto &Fragment : MMI.getFrameIndexExprs()) {
     Register FrameReg;
     const DIExpression *Expr = Fragment.Expr;
@@ -1758,7 +1762,19 @@ void DwarfCompileUnit::applyCommonDbgVariableAttributes(const DbgVariable &Var,
   }
 
   addSourceLine(VariableDie, DIVar);
-  addType(VariableDie, Var.getType());
+
+  const DIType *VarTy = Var.getType();
+  if (Var.isDivergentAddrSpaceCompatible()) {
+    if (std::optional<unsigned> EntityAS = Var.getCommonDivergentAddrSpace()) {
+      if (auto DwarfAS = getAsmPrinter()->TM.mapToDWARFAddrSpace(*EntityAS)) {
+        TempDIDerivedType Tmp =
+            cast<DIDerivedType>(VarTy)->cloneWithAddressSpace(*DwarfAS);
+        VarTy = MDNode::replaceWithUniqued(std::move(Tmp));
+      }
+    }
+  }
+
+  addType(VariableDie, VarTy);
   if (Var.isArtificial())
     addFlag(VariableDie, dwarf::DW_AT_artificial);
 }

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

@@ -233,6 +233,63 @@ void DebugLocDwarfExpression::commitTemporaryBuffer() {
   TmpBuf->Comments.clear();
 }
 
+namespace {
+/// Utility class for finding the common divergent address space of all the
+/// DIExpressions that describe the location of a variable, if such an address
+/// space exists.
+class CommonDivergentAddrSpaceFinder {
+  std::optional<unsigned> CommonAS;
+  bool HasCommonAddrSpace = true;
+
+public:
+  void addSubExpr(const DIExpression *Expr) {
+    if (!Expr || !HasCommonAddrSpace)
+      return;
+    std::optional<unsigned> ExprAS = Expr->getNewDivergentAddrSpace();
+    if (!ExprAS)
+      HasCommonAddrSpace = false;
+    else if (!CommonAS)
+      CommonAS = *ExprAS;
+    else if (*CommonAS != *ExprAS)
+      HasCommonAddrSpace = false;
+  }
+
+  std::optional<unsigned> get() const {
+    return HasCommonAddrSpace ? CommonAS : std::nullopt;
+  }
+};
+} // namespace
+
+std::optional<unsigned> DbgVariable::getCommonDivergentAddrSpace() const {
+  const Loc::Variant *Loc = &asVariant();
+
+  if (auto *LM = std::get_if<Loc::Multi>(Loc))
+    return LM->getCommonDivergentAddrSpace();
+
+  CommonDivergentAddrSpaceFinder Finder;
+  if (auto *LS = std::get_if<Loc::Single>(Loc)) {
+    Finder.addSubExpr(LS->getExpr());
+  } else if (auto *MMI = std::get_if<Loc::MMI>(Loc)) {
+    for (auto &FIE : MMI->getFrameIndexExprs())
+      Finder.addSubExpr(FIE.Expr);
+  } else if (auto *EV = std::get_if<Loc::EntryValue>(Loc)) {
+    for (auto &Val : EV->EntryValues)
+      Finder.addSubExpr(&Val.Expr);
+  }
+
+  return Finder.get();
+}
+
+bool DbgVariable::isDivergentAddrSpaceCompatible() const {
+  if (auto *DT = dyn_cast<DIDerivedType>(getType()))
+    return DT->getTag() == dwarf::DW_TAG_pointer_type ||
+           DT->getTag() == dwarf::DW_TAG_reference_type ||
+           DT->getTag() == dwarf::DW_TAG_rvalue_reference_type;
+  // FIXME: We could support divergent address spaces on pointer/reference
+  // fields of struct types.
+  return false;
+}
+
 const DIType *DbgVariable::getType() const {
   return getVariable()->getType();
 }
@@ -1952,6 +2009,18 @@ void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU,
       continue;
     }
 
+    // If all entries in the location list produce a consistent divergent
+    // address space we need to inform the expression emitter that it is
+    // permitted to produce divergent address spaces.
+    if (RegVar->isDivergentAddrSpaceCompatible()) {
+      CommonDivergentAddrSpaceFinder Finder;
+      for (const DebugLocEntry &DLE : Entries)
+        for (const DbgValueLoc &DVL : DLE.getValues())
+          Finder.addSubExpr(DVL.getExpression());
+      if (std::optional<unsigned> AS = Finder.get())
+        List.setCommonDivergentAddrSpace(*AS);
+    }
+
     // If the variable has a DIBasicType, extract it.  Basic types cannot have
     // unique identifiers, so don't bother resolving the type with the
     // identifier map.
@@ -3181,6 +3250,8 @@ void DebugLocEntry::finalize(const AsmPrinter &AP,
   DebugLocStream::EntryBuilder Entry(List, Begin, End);
   BufferByteStreamer Streamer = Entry.getStreamer();
   DebugLocDwarfExpression DwarfExpr(AP, Streamer, TheCU);
+  if (List.hasCommonDivergentAddrSpace())
+    DwarfExpr.permitDivergentAddrSpace();
   const DbgValueLoc &Value = Values[0];
   if (Value.isFragment()) {
     // Emit all fragments that belong to the same variable and range.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

@@ -145,15 +145,25 @@ class Multi {
   /// DW_OP_LLVM_tag_offset value from DebugLocs.
   std::optional<uint8_t> DebugLocListTagOffset;
 
+  /// In DIOp-DIExpressions, if this variable has pointer type and all entries
+  /// in the loclist produce the same divergent address space, this is set to be
+  /// the that address space.
+  std::optional<unsigned> CommonAddrSpace;
+
 public:
   explicit Multi(unsigned DebugLocListIndex,
-                 std::optional<uint8_t> DebugLocListTagOffset)
+                 std::optional<uint8_t> DebugLocListTagOffset,
+                 std::optional<unsigned> CommonAddrSpace = std::nullopt)
       : DebugLocListIndex(DebugLocListIndex),
-        DebugLocListTagOffset(DebugLocListTagOffset) {}
+        DebugLocListTagOffset(DebugLocListTagOffset),
+        CommonAddrSpace(CommonAddrSpace) {}
   unsigned getDebugLocListIndex() const { return DebugLocListIndex; }
   std::optional<uint8_t> getDebugLocListTagOffset() const {
     return DebugLocListTagOffset;
   }
+  std::optional<unsigned> getCommonDivergentAddrSpace() const {
+    return CommonAddrSpace;
+  }
 };
 /// Single location defined by (potentially multiple) MMI entries.
 struct MMI {
@@ -277,6 +287,9 @@ class DbgVariable : public DbgEntity, public Loc::Variant {
 
   const DIType *getType() const;
 
+  bool isDivergentAddrSpaceCompatible() const;
+  std::optional<unsigned> getCommonDivergentAddrSpace() const;
+
   static bool classof(const DbgEntity *N) {
     return N->getDbgEntityID() == DbgVariableKind;
   }