Implement DIGlobalVariable handling in DWARF part 1

Partially Implemented global variable handling in DWARF. Now
global variables with type `DIGlobalVariable` and in global
addrspace can be visible in debugger.

This commit skips emmiting DW_AT_Location and DW_OP_addr.

Author: MiloszSkobejko

IGC/DebugInfo/DwarfCompileUnit.cpp

@@ -386,7 +386,7 @@ void CompileUnit::addBlock(DIE *Die, dwarf::Attribute Attribute, IGC::DIEBlock *
 /// entry.
 void CompileUnit::addSourceLine(DIE *Die, DIScope *S, unsigned Line) {
   // If the line number is 0, don't add it.
-  if (Line == 0)
+  if (Line == 0 || !S)
     return;
 
   unsigned FileID = DD->getOrCreateSourceID(S->getFilename(), S->getDirectory(), DD->getMD5AsBytes(S->getFile()),
@@ -444,6 +444,16 @@ void CompileUnit::addSourceLine(DIE *Die, DIType *Ty) {
   addSourceLine(Die, Ty, Ty->getLine());
 }
 
+/// addSourceLine - Add location information to specified debug information
+/// entry.
+void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable *GV) {
+  // Verify type.
+  if (!isa<DIGlobalVariable>(GV))
+    return;
+
+  addSourceLine(Die, GV->getScope(), GV->getLine());
+}
+
 void CompileUnit::addRegOrConst(IGC::DIEBlock *TheDie, unsigned DWReg) {
   // TODO: Confirm if this function is correctly used.
   auto DWRegEncoded = GetEncodedRegNum<RegisterNumbering::GRFBase>(DWReg);
@@ -1505,10 +1515,6 @@ void CompileUnit::constructTemplateValueParameterDIE(DIE &Buffer, DITemplateValu
 /// constructImportedEntityDIE - Create a DIE for DIImportedEntity.
 IGC::DIE *CompileUnit::constructImportedEntityDIE(DIImportedEntity *Module) {
   DINode *Entity = Module->getEntity();
-  if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
-    return nullptr; // Missing support for imported entity linked to a global
-                    // variable
-
   DIE *IMDie = new DIE(Module->getTag());
   insertDIE(Module, IMDie);
 
@@ -1521,9 +1527,8 @@ IGC::DIE *CompileUnit::constructImportedEntityDIE(DIImportedEntity *Module) {
     EntityDie = getOrCreateSubprogramDIE(SP);
   else if (auto *T = dyn_cast<DIType>(Entity))
     EntityDie = getOrCreateTypeDIE(T);
-  // else if (auto* GV = dyn_cast<DIGlobalVariable>(Entity))  // TODO missing
-  // support
-  //    EntityDie = getOrCreateGlobalVariableDIE(GV, {});
+  else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
+    EntityDie = getOrCreateGlobalVariableDIE(GV, {});
   else
     EntityDie = getDIE(Entity);
 
@@ -1556,6 +1561,59 @@ IGC::DIE *CompileUnit::getOrCreateNameSpace(DINamespace *NS) {
   return NDie;
 }
 
+IGC::DIE *CompileUnit::getOrCreateGlobalVariableDIE(DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
+  // Check for pre-existence.
+  if (DIE *Die = getDIE(GV))
+    return Die;
+
+  auto *GVContext = GV->getScope();
+  DIType *GTy = GV->getType();
+
+  DIE *ContextDIE = getOrCreateContextDIE(GVContext);
+
+  // Add to map.
+  DIE *VariableDIE = createAndAddDIE(GV->getTag(), *ContextDIE, GV);
+  DIScope *DeclContext;
+  if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
+    DeclContext = SDMDecl->getScope();
+    assert(SDMDecl->isStaticMember() && "Expected static member decl");
+    assert(GV->isDefinition());
+    // We need the declaration DIE that is in the static member's class.
+    DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
+    addDIEEntry(VariableDIE, dwarf::DW_AT_specification, VariableSpecDIE);
+    // If the global variable's type is different from the one in the class
+    // member type, assume that it's more specific and also emit it.
+    if (GTy != SDMDecl->getBaseType())
+      addType(VariableDIE, GTy);
+  } else {
+    DeclContext = GV->getScope();
+    // Add name and type.
+    addString(VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
+    if (GTy)
+      addType(VariableDIE, GTy);
+
+    // Add scoping info.
+    if (!GV->isLocalToUnit())
+      addFlag(VariableDIE, dwarf::DW_AT_external);
+
+    // Add line number info.
+    addSourceLine(VariableDIE, GV);
+  }
+
+  if (!GV->isDefinition())
+    addFlag(VariableDIE, dwarf::DW_AT_declaration);
+
+  if (uint32_t AlignInBytes = GV->getAlignInBytes())
+    addUInt(VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, AlignInBytes);
+
+  if (MDTuple *TP = GV->getTemplateParams())
+    addTemplateParams(*VariableDIE, DINodeArray(TP));
+
+  // TODO: Add location and relocation entry to Global Variable
+  // addLocationAttribute(VariableDIE, GV, GlobalExprs);
+  return VariableDIE;
+}
+
 /// getOrCreateSubprogramDIE - Create new DIE using SP.
 IGC::DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram *SP) {
   // Construct the context before querying for the existence of the DIE in case

IGC/DebugInfo/DwarfCompileUnit.hpp

@@ -24,6 +24,7 @@ See LICENSE.TXT for details.
 #include "llvm/ADT/DenseMap.h"
 #include <llvmWrapper/ADT/Optional.h>
 #include "llvm/ADT/SmallVector.h"
+#include <llvm/ADT/ArrayRef.h>
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/llvm-config.h"
@@ -161,6 +162,12 @@ class CompileUnit {
 
   DIEBlock *getDIEBlock() { return new (DIEValueAllocator) DIEBlock(); }
 
+  /// A pair of GlobalVariable and DIExpression.
+  struct GlobalExpr {
+    const llvm::GlobalVariable *Var;
+    const llvm::DIExpression *Expr;
+  };
+
   /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
   /// when the llvm::MDNode can be part of the type system, since DIEs for
   /// the type system can be shared across CUs and the mappings are
@@ -240,6 +247,7 @@ class CompileUnit {
   void addSourceLine(DIE *Die, llvm::DIVariable *V);
   void addSourceLine(DIE *Die, llvm::DISubprogram *SP);
   void addSourceLine(DIE *Die, llvm::DIType *Ty);
+  void addSourceLine(DIE *Die, llvm::DIGlobalVariable *GV);
 
   /// addConstantValue - Add constant value entry in variable DIE.
   void addConstantValue(DIE *Die, const llvm::ConstantInt *CI, bool Unsigned);
@@ -325,6 +333,9 @@ class CompileUnit {
   /// getOrCreateNameSpace - Create a DIE for DINameSpace.
   DIE *getOrCreateNameSpace(llvm::DINamespace *NS);
 
+  /// Get or create global variable DIE.
+  DIE *getOrCreateGlobalVariableDIE(llvm::DIGlobalVariable *GV, llvm::ArrayRef<GlobalExpr> GlobalExprs);
+
   /// getOrCreateSubprogramDIE - Create new DIE using SP.
   DIE *getOrCreateSubprogramDIE(llvm::DISubprogram *SP);
 

IGC/DebugInfo/DwarfDebug.cpp

@@ -1068,6 +1068,28 @@ IGCLLVM::optional<llvm::MD5::MD5Result> DwarfDebug::getMD5AsBytes(const llvm::DI
   return CKMem;
 }
 
+/// Sort and unique GVEs by comparing their fragment offset.
+static SmallVectorImpl<CompileUnit::GlobalExpr> &sortGlobalExprs(SmallVectorImpl<CompileUnit::GlobalExpr> &GVEs) {
+  llvm::sort(GVEs, [](CompileUnit::GlobalExpr A, CompileUnit::GlobalExpr B) {
+    // Sort order: first null exprs, then exprs without fragment
+    // info, then sort by fragment offset in bits.
+    // FIXME: Come up with a more comprehensive comparator so
+    // the sorting isn't non-deterministic, and so the following
+    // std::unique call works correctly.
+    if (!A.Expr || !B.Expr)
+      return !!B.Expr;
+    auto FragmentA = A.Expr->getFragmentInfo();
+    auto FragmentB = B.Expr->getFragmentInfo();
+    if (!FragmentA || !FragmentB)
+      return !!FragmentB;
+    return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
+  });
+  GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
+                         [](CompileUnit::GlobalExpr A, CompileUnit::GlobalExpr B) { return A.Expr == B.Expr; }),
+             GVEs.end());
+  return GVEs;
+}
+
 // Emit all Dwarf sections that should come prior to the content. Create
 // global DIEs and emit initial debug info sections.
 void DwarfDebug::beginModule() {
@@ -1077,6 +1099,14 @@ void DwarfDebug::beginModule() {
   if (M->debug_compile_units().begin() == M->debug_compile_units().end())
     return;
 
+  DenseMap<DIGlobalVariable *, SmallVector<CompileUnit::GlobalExpr, 1>> GVMap;
+  for (const GlobalVariable &Global : M->globals()) {
+    SmallVector<DIGlobalVariableExpression *, 1> GVs;
+    Global.getDebugInfo(GVs);
+    for (auto *GVE : GVs)
+      GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
+  }
+
   // discover DISubprogramNodes for all the registered visaModules
   discoverDISPNodes();
   // Emit initial sections so we can reference labels later.
@@ -1085,6 +1115,35 @@ void DwarfDebug::beginModule() {
   DICompileUnit *CUNode = *M->debug_compile_units_begin();
   CompileUnit *CU = constructCompileUnit(CUNode);
 
+  // Global Variables.
+  for (auto *GVE : CUNode->getGlobalVariables()) {
+    // Don't bother adding DIGlobalVariableExpressions listed in the CU if we
+    // already know about the variable and it isn't adding a constant
+    // expression.
+    auto &GVMapEntry = GVMap[GVE->getVariable()];
+    auto *Expr = GVE->getExpression();
+    if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
+      GVMapEntry.push_back({nullptr, Expr});
+  }
+
+  DenseSet<DIGlobalVariable *> Processed;
+  for (auto *GVE : CUNode->getGlobalVariables()) {
+    DIGlobalVariable *GV = GVE->getVariable();
+
+    // Skip variables in different addrspaces than global,
+    // SLM globals and constants will be handled later. This
+    // will avoid duplication.
+    if (GVMap.find(GV) == GVMap.end())
+      continue;
+
+    bool AllInGlobalAS = llvm::all_of(GVMap.find(GV)->second, [](const CompileUnit::GlobalExpr &GE) {
+      return GE.Var && GE.Var->getAddressSpace() == ADDRESS_SPACE_GLOBAL;
+    });
+
+    if (Processed.insert(GV).second && AllInGlobalAS)
+      CU->getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
+  }
+
   for (auto *DISP : DISubprogramNodes)
     constructSubprogramDIE(CU, DISP);
 

IGC/ocloc_tests/DebugInfo/Dwarf/generate_global_variable_dwarf.ll

@@ -0,0 +1,55 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; Test generates DWARF for global variable.
+
+; UNSUPPORTED: sys32
+
+; REQUIRES: regkeys, oneapi-readelf, llvm-15-plus
+
+; LLVM with opaque pointers:
+; RUN: llvm-as -opaque-pointers=1 %s -o %t
+; RUN: ocloc compile -llvm_input -file %t -device dg2 -options "-g -cl-opt-disable -igc_opts 'EnableOpaquePointersBackend=1, ElfDumpEnable=1, DumpUseShorterName=0, DebugDumpNamePrefix=%t_'"
+; RUN: oneapi-readelf --debug-dump %t_OCL_simd32_foo.elf | FileCheck %s
+
+; LLVM with typed pointers/default pointer typing:
+; RUN: llvm-as -opaque-pointers=0 %s -o %t
+; RUN: ocloc compile -llvm_input -file %t -device dg2 -options "-g -cl-opt-disable -igc_opts 'ElfDumpEnable=1, DumpUseShorterName=0, DebugDumpNamePrefix=%t_'"
+; RUN: oneapi-readelf --debug-dump %t_OCL_simd32_foo.elf | FileCheck %s
+
+@global = addrspace(1) global i64 0, align 8, !dbg !0
+; CHECK: DW_TAG_variable
+; CHECK-NEXT: DW_AT_name        : global
+; CHECK-NEXT: DW_AT_type        : {{.*}}
+; CHECK-NEXT: DW_AT_external    : {{.*}}
+; CHECK-NEXT: DW_AT_decl_file   : {{.*}}
+; CHECK-NEXT: DW_AT_decl_line   : {{.*}}
+
+; Function Attrs: nounwind
+define spir_kernel void @foo() #0 !dbg !6 {
+entry:
+  ret void
+}
+
+attributes #0 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!9, !10}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "global", scope: !2, file: !3, line: 5, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.5", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4)
+!3 = !DIFile(filename: "global.cpp", directory: "/tmp")
+!4 = !{!0}
+!5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!6 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 3, type: !7, flags: DIFlagPrototyped, unit: !2, retainedNodes: !11)
+!7 = !DISubroutineType(types: !8)
+!8 = !{null}
+!9 = !{i32 2, !"Dwarf Version", i32 4}
+!10 = !{i32 1, !"Debug Info Version", i32 3}
+!11 = !{}