[clang][OpenMP][DebugInfo] Debug support for TLS variables when present in OpenMP consructs

[alok]

Summary

In case of OpenMP programs, thread local variables can be present in any clause pertaining to
OpenMP constructs, as we know that compiler generates artificial functions and in some cases
values are passed to those artificial functions thru parameters.
For an example, if thread local variable is present in copyin clause (testcase attached with the
patch), parameter with same name is generated as parameter to artificial function. When user
inquires the thread Local variable, its debug info is hidden by the parameter. The debug info
for parameters (for thread local) must be suppressed.

Without the patch, attached testcase behaves wrongly under debuggers.

Thread 3 "a.out" hit Breakpoint 3, .omp_outlined._debug__ (.global_tid.=0x155547ffde20, .bound_tid.=0x155547ffde18, nt=@0x7fffffffe2b8: 4, gbl_int=@0x15555553333c: 65)
    at simple.c:29
29                  printf ("In parallel region total threads = %d, thread id = %d data=%d gbl_addr = %p\n", nt, tid, data, &gbl_int);
(gdb) p tid
$1 = 2
(gdb) p &gbl_int
$2 = (int *) 0x15555553333c
(gdb) c
Continuing.
[Switching to Thread 0x155553ad2b80 (LWP 12279)]

Thread 2 "a.out" hit Breakpoint 2, .omp_outlined._debug__ (.global_tid.=0x155553ad1de0, .bound_tid.=0x155553ad1dd8, nt=@0x7fffffffe2b8: 4, gbl_int=@0x15555553333c: 65)
    at simple.c:27
27                  printf ("In parallel region total threads = %d, thread id = %d data=%d gbl_addr = %p\n", nt, tid, data, &gbl_int);
(gdb) p tid
$3 = 1
(gdb) p &gbl_int
$4 = (int *) 0x15555553333c

Please note that same address is shown for all the threads which is wrong (for thread local variable).

With the current patch, the issue is fixed.

[aprantl]

For an example, if thread local variable is present in copyin clause (testcase attached with the

patch), parameter with same name is generated as parameter to artificial function. When user
inquires the thread Local variable, its debug info is hidden by the parameter. The debug info
for parameters (for thread local) must be suppressed.

What does the dwarfdump output for the old behavior look like? Are the two in the same scope?

[alok]

In D123787#3452970, @aprantl wrote:

For an example, if thread local variable is present in copyin clause (testcase attached with the

patch), parameter with same name is generated as parameter to artificial function. When user
inquires the thread Local variable, its debug info is hidden by the parameter. The debug info
for parameters (for thread local) must be suppressed.

What does the dwarfdump output for the old behavior look like? Are the two in the same scope?

The dwarfdump output looks like below. DIE (0x00000023) is for actual user defined variable and artificial one DIE (0x000000b1) is at local scope, the one at local scope gets precedence.

0x0000000c: DW_TAG_compile_unit
              DW_AT_producer    ("clang version 14.0.0")
              DW_AT_language    (DW_LANG_C99)
              DW_AT_name        ("debug_threadprivate_copyin.c")
              DW_AT_str_offsets_base    (0x00000008)
              DW_AT_stmt_list   (0x00000000)
              DW_AT_comp_dir    ("/home/alok/amdllvm/build.llvm.d")
              DW_AT_low_pc      (0x0000000000000000)
              DW_AT_high_pc     (0x000000000000029b)
              DW_AT_addr_base   (0x00000008)

0x00000023:   DW_TAG_variable
                DW_AT_name      ("gbl_dynamic_int")
                DW_AT_type      (0x00000036 "int")
                DW_AT_external  (true)
                DW_AT_decl_file ("debug_threadprivate_copyin.c")
                DW_AT_decl_line (22)
                DW_AT_location  (DW_OP_const8u 0x0, DW_OP_GNU_push_tls_address)

0x00000089:   DW_TAG_subprogram
                DW_AT_low_pc    (0x0000000000000090)
                DW_AT_high_pc   (0x0000000000000260)
                DW_AT_frame_base        (DW_OP_reg6 RBP)
                DW_AT_call_all_calls    (true)
                DW_AT_name      (".omp_outlined._debug__")
                DW_AT_decl_file ("debug_threadprivate_copyin.c")
                DW_AT_decl_line (35)
                DW_AT_prototyped        (true)

0x000000b1:     DW_TAG_formal_parameter
                  DW_AT_location        (DW_OP_fbreg -32)
                  DW_AT_name    ("gbl_dynamic_int")
                  DW_AT_decl_file       ("debug_threadprivate_copyin.c")
                  DW_AT_decl_line       (22)
                  DW_AT_type    (0x00000154 "int &")

[alok]

Re-based.

[aprantl]

Oh, it's a global variable that supposed to shadow the function parameter! Thanks for clarifying.

clang/include/clang/AST/Decl.h

enum ImplicitParamKind : unsigned {
     CXXThis,
 
     /// Parameter for C++ virtual table pointers
     CXXVTT,
 
     /// Parameter for captured context
     CapturedContext,
 
+    /// Parameter for Thread private variable
+    ThreadPrivateVar,
+
     /// Other implicit parameter
     Other,
   };
 
   /// Create implicit parameter.
   static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
                                    SourceLocation IdLoc, IdentifierInfo *Id,
                                    QualType T, ImplicitParamKind ParamKind);

clang/lib/CodeGen/CGDecl.cpp

struct ConsumeARCParameter final : EHScopeStack::Cleanup {
     }
   };
 } // end anonymous namespace
 
 /// Emit an alloca (or GlobalValue depending on target)
 /// for the specified parameter and set up LocalDeclMap.
 void CodeGenFunction::EmitParmDecl(const VarDecl &D, ParamValue Arg,
                                    unsigned ArgNo) {
+  bool NoDebugInfo = false;
   // FIXME: Why isn't ImplicitParamDecl a ParmVarDecl?
   assert((isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) &&
          "Invalid argument to EmitParmDecl");
 
   Arg.getAnyValue()->setName(D.getName());
 
   QualType Ty = D.getType();
 
   // Use better IR generation for certain implicit parameters.
   if (auto IPD = dyn_cast<ImplicitParamDecl>(&D)) {
     // The only implicit argument a block has is its literal.
     // This may be passed as an inalloca'ed value on Windows x86.
     if (BlockInfo) {
       llvm::Value *V = Arg.isIndirect()
                            ? Builder.CreateLoad(Arg.getIndirectAddress())
                            : Arg.getDirectValue();
       setBlockContextParameter(IPD, ArgNo, V);
       return;
     }
+    // Suppressing debug info for ThreadPrivateVar parameters, else it hides
+    // debug info of TLS variables.
+    NoDebugInfo =
+        (IPD->getParameterKind() == ImplicitParamDecl::ThreadPrivateVar);
   }
 
   Address DeclPtr = Address::invalid();
   Address AllocaPtr = Address::invalid();
   bool DoStore = false;
   bool IsScalar = hasScalarEvaluationKind(Ty);
   // If we already have a pointer to the argument, reuse the input pointer.
   if (Arg.isIndirect()) {
void CodeGenFunction::EmitParmDecl(const VarDecl &D, ParamValue Arg,
   // Store the initial value into the alloca.
   if (DoStore)
     EmitStoreOfScalar(ArgVal, lv, /* isInitialization */ true);
 
   setAddrOfLocalVar(&D, DeclPtr);
 
   // Emit debug info for param declarations in non-thunk functions.
   if (CGDebugInfo *DI = getDebugInfo()) {
-    if (CGM.getCodeGenOpts().hasReducedDebugInfo() && !CurFuncIsThunk) {
+    if (CGM.getCodeGenOpts().hasReducedDebugInfo() && !CurFuncIsThunk &&
+        !NoDebugInfo) {
       llvm::DILocalVariable *DILocalVar = DI->EmitDeclareOfArgVariable(
           &D, AllocaPtr.getPointer(), ArgNo, Builder);
       if (const auto *Var = dyn_cast_or_null<ParmVarDecl>(&D))
         DI->getParamDbgMappings().insert({Var, DILocalVar});
     }
   }
 
   if (D.hasAttr<AnnotateAttr>())

clang/lib/CodeGen/CGStmtOpenMP.cpp

if (I->capturesVariable() || I->capturesVariableByCopy()) {
       II = &Ctx.Idents.get("this");
     } else {
       assert(I->capturesVariableArrayType());
       II = &Ctx.Idents.get("vla");
     }
     if (ArgType->isVariablyModifiedType())
       ArgType = getCanonicalParamType(Ctx, ArgType);
     VarDecl *Arg;
-    if (DebugFunctionDecl && (CapVar || I->capturesThis())) {
+    if (CapVar && (CapVar->getTLSKind() != clang::VarDecl::TLS_None)) {
+      Arg = ImplicitParamDecl::Create(Ctx, /*DC=*/nullptr, FD->getLocation(),
+                                      II, ArgType,
+                                      ImplicitParamDecl::ThreadPrivateVar);
+    } else if (DebugFunctionDecl && (CapVar || I->capturesThis())) {
       Arg = ParmVarDecl::Create(
           Ctx, DebugFunctionDecl,
           CapVar ? CapVar->getBeginLoc() : FD->getBeginLoc(),
           CapVar ? CapVar->getLocation() : FD->getLocation(), II, ArgType,
           /*TInfo=*/nullptr, SC_None, /*DefArg=*/nullptr);
     } else {
       Arg = ImplicitParamDecl::Create(Ctx, /*DC=*/nullptr, FD->getLocation(),
                                       II, ArgType, ImplicitParamDecl::Other);

clang/test/OpenMP/debug_threadprivate_copyin.c

+// This testcase checks emission of debug info for threadprivate variables
+// present in any clause of OpenMP construct.
+
+// REQUIRES: x86_64-linux
+
+// RUN: %clang_cc1 -debug-info-kind=constructor -x c -verify -triple x86_64-pc-linux-gnu -fopenmp -emit-llvm %s -o - | FileCheck %s
+// expected-no-diagnostics
+
+// CHECK: define internal void @.omp_outlined._debug__(
+// CHECK: call void @llvm.dbg.declare(metadata ptr %.global_tid..addr,
+// CHECK: call void @llvm.dbg.declare(metadata ptr %.bound_tid..addr,
+// CHECK: call void @llvm.dbg.declare(metadata ptr %nt.addr
+// CHECK: store ptr %gbl_dynamic_int, ptr %gbl_dynamic_int.addr, align 8
+// CHECK-NOT: call void @llvm.dbg.declare(metadata ptr %gbl_dynamic_int.addr
+// CHECK-NOT: call void @llvm.dbg.declare(metadata ptr %gbl_static_int.addr
+
+extern int printf(const char *, ...);
+extern void omp_set_num_threads(int);
+extern int omp_get_num_threads(void);
+extern int omp_get_thread_num(void);
+
+int gbl_dynamic_int;
+__thread int gbl_static_int;
+
+#pragma omp threadprivate(gbl_dynamic_int)
+
+int main() {
+  int nt = 0;
+  int offset = 10;
+  gbl_dynamic_int = 55;
+  gbl_static_int = 77;
+
+  omp_set_num_threads(4);
+#pragma omp parallel copyin(gbl_dynamic_int, gbl_static_int)
+  {
+    int data;
+    int tid;
+    nt = omp_get_num_threads();
+    tid = omp_get_thread_num();
+    data = gbl_dynamic_int + gbl_static_int;
+    gbl_dynamic_int += 10;
+    gbl_static_int += 20;
+#pragma omp barrier
+    if (tid == 0)
+      printf("In parallel region total threads = %d, thread id = %d data=%d gbl_dyn_addr = %p, gbl_static_addr = %p\n",
+             nt, tid, data, &gbl_dynamic_int, &gbl_static_int);
+    if (tid == 1)
+      printf("In parallel region total threads = %d, thread id = %d data=%d gbl_dyn_addr = %p, gbl_static_addr = %p\n",
+             nt, tid, data, &gbl_dynamic_int, &gbl_static_int);
+    if (tid == 2)
+      printf("In parallel region total threads = %d, thread id = %d data=%d gbl_dyn_addr = %p, gbl_static_addr = %p\n",
+             nt, tid, data, &gbl_dynamic_int, &gbl_static_int);
+    if (tid == 3)
+      printf("In parallel region total threads = %d, thread id = %d data=%d gbl_dyn_addr = %p, gbl_static_addr = %p\n",
+             nt, tid, data, &gbl_dynamic_int, &gbl_static_int);
+  }
+
+  return 0;
+}