[DebugInfo] Append extended dereferencing mechanism to variables' DIExpression for targets that support more than one address space

[arsenm]

lib/CodeGen/CGDebugInfo.cpp

3351

Is this hook necessary? Can you just not append if the returned address space is the default, or do we want to be explicit even with private address space?

[dblaikie]

lib/Basic/Targets.cpp

2275

Is this necessary? Or could it be done only when the address space is non-zero (so the getTargetAddressspace would be called unconditionally, if the result is non-zero add the addr space xderef thing)?

[aprantl]

lib/CodeGen/CGDebugInfo.cpp

3187

MutableArrayRef?

test/CodeGenOpenCL/debugger-amdgpu-variable-locations.cl

49

Does this work in a noasserts build where most names are stripped from IR?

[tony-tye]

lib/Basic/Targets.cpp

2275

I had the same thought. I think the question is what assumption can be made about the consumer of the DWARF. I do not think DWARF requires that an omitted address space should be treated as 0, so if a target chooses not to do so then omitting the address space is not necessarily the same as generating a 0 address space. At least always generating them is safe!

Another issue is what the consumer of the DWARF requires. For AMDGPU address space 0 is private since alloca allocates space in the per-thread address space. To support address spaces the debugger needs a core address that can access any of the address spaces, which would be the generic address space. The XDREF is telling the debugger to do the affect of an address space cast, which is needed to map from the private address space to the generic address space. So omitting it would prevent the target specific mapping to happen.

Another observation is that the target specific address space numbering in LLVM need not necessarily be the address class/address space numbering in DWARF. So should there be a mapping function? If such a function existed, then the target could define DWARF address space 0 to be generic (and so need no conversion) and then address class and XDREF could be omitted for DWARF address class/space 0 (which for AMDGPU would not map to LLVM address space 0).

[arsenm]

It would also be good if we could leave open the possibility of decoupling LLVM address space 0 from OpenCL private address space. I would like to be able to someday be able to change that

[frej]

lib/Basic/Targets.cpp

2275

Missing override.

[frej]

lib/Basic/Targets.cpp

2275

Another observation is that the target specific address space numbering in LLVM need not necessarily be the address class/address space numbering in DWARF.

For the out-of-tree target I'm involved with, this is the case.

[kzhuravl]

Address review feedback

lib/Basic/Targets.cpp

2275

Added a function for mapping LLVM AS -> DWARF AS.

lib/CodeGen/CGDebugInfo.cpp

3187

I have currently changed it to SmallVectorImpl. I am not sure if MutableArrayRef should be used here?

What if we decide to add more expressions before appending address space xderef?

3351

We want to be explicit about private and lds.

test/CodeGenOpenCL/debugger-amdgpu-variable-locations.cl

49

Fixed. Thanks.

[tony-tye]

LGTM

[aprantl]

lib/CodeGen/CGDebugInfo.cpp

3187

SmallVectorImpl is fine.

[kzhuravl]

No changes, just a rebase

include/clang/Basic/TargetInfo.h

virtual LangAS::ID getOpenCLImageAddrSpace() const {
     return LangAS::opencl_global;
   }
 
   /// \brief Get address space to use for global variables.
   virtual unsigned getGlobalAddrSpace() const {
     return 0;
   }
 
+  /// \brief Returns true if subtarget supports more than one address space,
+  /// false otherwise.
+  virtual bool targetSupportsMultipleAddressSpaces() const {
+    return false;
+  }
+
   /// \brief Check the target is valid after it is fully initialized.
   virtual bool validateTarget(DiagnosticsEngine &Diags) const {
     return true;
   }
 
 protected:
   virtual uint64_t getPointerWidthV(unsigned AddrSpace) const {
     return PointerWidth;

lib/Basic/Targets.cpp

public:
   uint64_t getNullPointerValue(unsigned AS) const override {
     return AS != LangAS::opencl_local && AS != 0 ? 0 : ~0;
   }
 
   /// \brief Get address space to use for global variables.
   unsigned getGlobalAddrSpace() const {
     return 1; // opencl_global.
   }
+
+  /// \brief Returns true if subtarget supports more than one address space,
+  /// false otherwise.
+  bool targetSupportsMultipleAddressSpaces() const {
+    return true;
+  }
 };
 
 const Builtin::Info AMDGPUTargetInfo::BuiltinInfo[] = {
 #define BUILTIN(ID, TYPE, ATTRS)                \
   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
 #include "clang/Basic/BuiltinsAMDGPU.def"

lib/CodeGen/CGDebugInfo.h

#include "clang/Basic/OpenCLImageTypes.def"
   void CollectVTableInfo(const CXXRecordDecl *Decl, llvm::DIFile *F,
                          SmallVectorImpl<llvm::Metadata *> &EltTys,
                          llvm::DICompositeType *RecordTy);
   /// @}
 
   /// Create a new lexical block node and push it on the stack.
   void CreateLexicalBlock(SourceLocation Loc);
 
+  /// \brief Appends extended dereferencing mechanism for given \p AddressSpace
+  /// to complex expression \p Expr.
+  void appendAddressSpaceXDeref(unsigned AddressSpace,
+                                SmallVector<int64_t, 9> &Expr) const;
+
 public:
   CGDebugInfo(CodeGenModule &CGM);
   ~CGDebugInfo();
 
   void finalize();
 
   /// Module debugging: Support for building PCMs.
   /// @{

lib/CodeGen/CGDebugInfo.cpp

void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
   llvm::MDNode *Back = nullptr;
   if (!LexicalBlockStack.empty())
     Back = LexicalBlockStack.back().get();
   LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
       cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
       getColumnNumber(CurLoc)));
 }
 
+void CGDebugInfo::appendAddressSpaceXDeref(
+    unsigned AddressSpace,
+    SmallVector<int64_t, 9> &Expr) const {
+  Expr.push_back(llvm::dwarf::DW_OP_constu);
+  Expr.push_back(AddressSpace);
+  Expr.push_back(llvm::dwarf::DW_OP_swap);
+  Expr.push_back(llvm::dwarf::DW_OP_xderef);
+}
+
 void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder,
                                         SourceLocation Loc) {
   // Set our current location.
   setLocation(Loc);
 
   // Emit a line table change for the current location inside the new scope.
   Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
       getLineNumber(Loc), getColumnNumber(Loc), LexicalBlockStack.back()));
void CGDebugInfo::EmitDeclare(const VarDecl *VD, llvm::Value *Storage,
   }
   SmallVector<int64_t, 9> Expr;
   llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
   if (VD->isImplicit())
     Flags |= llvm::DINode::FlagArtificial;
 
   auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
 
+  // Append extended dereferencing mechanism for VD's address space.
+  if (CGM.getTarget().targetSupportsMultipleAddressSpaces()) {
+    unsigned AddressSpace =
+        CGM.getContext().getTargetAddressSpace(VD->getType());
+    appendAddressSpaceXDeref(AddressSpace, Expr);
+  }
+
   // If this is the first argument and it is implicit then
   // give it an object pointer flag.
   // FIXME: There has to be a better way to do this, but for static
   // functions there won't be an implicit param at arg1 and
   // otherwise it is 'self' or 'this'.
   if (isa<ImplicitParamDecl>(VD) && ArgNo && *ArgNo == 1)
     Flags |= llvm::DINode::FlagObjectPointer;
   if (auto *Arg = dyn_cast<llvm::Argument>(Storage))
void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
   // variable for each member of the anonymous union so that it's possible
   // to find the name of any field in the union.
   if (T->isUnionType() && DeclName.empty()) {
     const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
     assert(RD->isAnonymousStructOrUnion() &&
            "unnamed non-anonymous struct or union?");
     GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
   } else {
+    // Append extended dereferencing mechanism for D's address space.
+    SmallVector<int64_t, 9> Expr;
+    if (CGM.getTarget().targetSupportsMultipleAddressSpaces()) {
+      unsigned AddressSpace =
+          CGM.getContext().getTargetAddressSpace(D->getType());
+      appendAddressSpaceXDeref(AddressSpace, Expr);
+    }
+
     auto Align = getDeclAlignIfRequired(D, CGM.getContext());
     GVE = DBuilder.createGlobalVariableExpression(
         DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
-        Var->hasLocalLinkage(), /*Expr=*/nullptr,
+        Var->hasLocalLinkage(),
+        Expr.empty() ? nullptr : DBuilder.createExpression(Expr),
         getOrCreateStaticDataMemberDeclarationOrNull(D), Align);
     Var->addDebugInfo(GVE);
   }
   DeclCache[D->getCanonicalDecl()].reset(GVE);
 }
 
 void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
   assert(DebugKind >= codegenoptions::LimitedDebugInfo);

test/CodeGenOpenCL/debugger-amdgpu-variable-locations.cl

+// RUN: %clang -cl-std=CL2.0 -emit-llvm -g -O0 -S -target amdgcn-amd-amdhsa -mcpu=fiji -o - %s | FileCheck %s
+
+// CHECK-DAG: ![[ADDRSPACE0:[0-9]+]] = !DIExpression(DW_OP_constu, 0, DW_OP_swap, DW_OP_xderef)
+// CHECK-DAG: ![[ADDRSPACE1:[0-9]+]] = !DIExpression(DW_OP_constu, 1, DW_OP_swap, DW_OP_xderef)
+// CHECK-DAG: ![[ADDRSPACE2:[0-9]+]] = !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef)
+// CHECK-DAG: ![[ADDRSPACE3:[0-9]+]] = !DIExpression(DW_OP_constu, 3, DW_OP_swap, DW_OP_xderef)
+
+// CHECK-DAG: ![[FILEVAR0:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar0", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR0]], expr: ![[ADDRSPACE1]])
+global int *FileVar0;
+// CHECK-DAG: ![[FILEVAR1:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar1", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR1]], expr: ![[ADDRSPACE1]])
+constant int *FileVar1;
+// CHECK-DAG: ![[FILEVAR2:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar2", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR2]], expr: ![[ADDRSPACE1]])
+local int *FileVar2;
+// CHECK-DAG: ![[FILEVAR3:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar3", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR3]], expr: ![[ADDRSPACE1]])
+int *FileVar3;
+
+// CHECK-DAG: ![[FILEVAR4:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar4", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR4]], expr: ![[ADDRSPACE1]])
+global int *global FileVar4;
+// CHECK-DAG: ![[FILEVAR5:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar5", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR5]], expr: ![[ADDRSPACE1]])
+constant int *global FileVar5;
+// CHECK-DAG: ![[FILEVAR6:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar6", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR6]], expr: ![[ADDRSPACE1]])
+local int *global FileVar6;
+// CHECK-DAG: ![[FILEVAR7:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar7", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR7]], expr: ![[ADDRSPACE1]])
+int *global FileVar7;
+
+// CHECK-DAG: ![[FILEVAR8:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar8", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR8]], expr: ![[ADDRSPACE2]])
+global int *constant FileVar8 = 0;
+// CHECK-DAG: ![[FILEVAR9:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar9", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR9]], expr: ![[ADDRSPACE2]])
+constant int *constant FileVar9 = 0;
+// CHECK-DAG: ![[FILEVAR10:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar10", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR10]], expr: ![[ADDRSPACE2]])
+local int *constant FileVar10 = 0;
+// CHECK-DAG: ![[FILEVAR11:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar11", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR11]], expr: ![[ADDRSPACE2]])
+int *constant FileVar11 = 0;
+
+// CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(1)** %KernelArg0.addr, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+// CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(2)** %KernelArg1.addr, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+// CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(3)** %KernelArg2.addr, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+kernel void kernel1(global int *KernelArg0,
+                    constant int *KernelArg1,
+                    local int *KernelArg2) {
+  int *Tmp;
+
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(1)** %FuncVar0, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+  global int *FuncVar0 = KernelArg0;
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(2)** %FuncVar1, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+  constant int *FuncVar1 = KernelArg1;
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(3)** %FuncVar2, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+  local int *FuncVar2 = KernelArg2;
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(4)** %FuncVar3, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+  int *FuncVar3 = Tmp;
+
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(1)** %FuncVar4, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE2]])
+  global int *constant FuncVar4 = KernelArg0;
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(2)** %FuncVar5, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE2]])
+  constant int *constant FuncVar5 = KernelArg1;
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(3)** %FuncVar6, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE2]])
+  local int *constant FuncVar6 = KernelArg2;
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(4)** %FuncVar7, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE2]])
+  int *constant FuncVar7 = Tmp;
+
+  // CHECK-DAG: ![[FUNCVAR8:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar8", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
+  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR8]], expr: ![[ADDRSPACE3]])
+  global int *local FuncVar8; FuncVar8 = KernelArg0;
+  // CHECK-DAG: ![[FUNCVAR9:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar9", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
+  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR9]], expr: ![[ADDRSPACE3]])
+  constant int *local FuncVar9; FuncVar9 = KernelArg1;
+  // CHECK-DAG: ![[FUNCVAR10:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar10", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
+  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR10]], expr: ![[ADDRSPACE3]])
+  local int *local FuncVar10; FuncVar10 = KernelArg2;
+  // CHECK-DAG: ![[FUNCVAR11:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar11", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
+  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR11]], expr: ![[ADDRSPACE3]])
+  int *local FuncVar11; FuncVar11 = Tmp;
+
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(1)** %FuncVar12, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+  global int *private FuncVar12 = KernelArg0;
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(2)** %FuncVar13, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+  constant int *private FuncVar13 = KernelArg1;
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(3)** %FuncVar14, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+  local int *private FuncVar14 = KernelArg2;
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(4)** %FuncVar15, metadata !{{[0-9]+}}, metadata ![[ADDRSPACE0]])
+  int *private FuncVar15 = Tmp;
+}