[OPENMP]Fix PR49649: The introduction of $ref globals is not always valid.

[ABataev]

Summary

Need to emit the reference in the global address space and the
referenced to static variable should be bitcasted to the generic address
space to be compatible with NVPTX.
Required to avoid early optimization of the static variables

[ABataev]

Rebase

[ABataev]

Rebase

[jdoerfert]

The cast was never the problem but the fact that the $ref lives in the global address space while the global value might be in the shared one.
D101030 gives a way out here by not creating $ref variables if there is no host version of a global. This makes sense because we don't need to copy to the global ever.
So, users can have static globals in shared memory by ensuring they are not host accessible. We probably should emit an error if they try to do global in shared memory
that has a host version.

Long story short, this cast won't help.

[ABataev]

In D99350#2721724, @jdoerfert wrote:

The cast was never the problem but the fact that the $ref lives in the global address space while the global value might be in the shared one.
D101030 gives a way out here by not creating $ref variables if there is no host version of a global. This makes sense because we don't need to copy to the global ever.
So, users can have static globals in shared memory by ensuring they are not host accessible. We probably should emit an error if they try to do global in shared memory
that has a host version.

Long story short, this cast won't help.

I checked that this cast helps to fix a problem with ptxas with shared/global memory refs. I'm not saying that this is the best solution, but better to have a fix while the final solution is not landed. Plus. maybe, it will fix some other potential issues until the $refs will go away. Maybe need a new attribute to avoid early optimization of the internal vars.

[ABataev]

Rebase

[ABataev]

Rebase

[ABataev]

Rebase

[jdoerfert]

I don't understand why the cast makes ptxas happy, can you include a test in the runtime so we can make sure that stays that way and is not some ptxas artifact. After all, we still point to a shared memory symbol from global memory which doesn't make too much sense.

[ABataev]

In D99350#2894305, @jdoerfert wrote:

I don't understand why the cast makes ptxas happy, can you include a test in the runtime so we can make sure that stays that way and is not some ptxas artifact. After all, we still point to a shared memory symbol from global memory which doesn't make too much sense.

Here is the related info https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#initializers. Take a look at the Examples:

      .const  .u32 foo = 42;
...
      .global .u32 p2 = generic(foo); // generic address of foo

After the patch, we have this:

.shared .align 4 .u32 _ZL1X;
.global .align 8 .u64 __ZL1X$ref = generic(_ZL1X);

which is similar to the example.

[ABataev]

Added runtime test.

[ABataev]

Better to fix this before the next release.

[ABataev]

Rebase

[ABataev]

Rebase

clang/lib/CodeGen/CGOpenMPRuntime.cpp

if (*Res == OMPDeclareTargetDeclAttr::MT_To &&
     if (CGM.getLangOpts().OpenMPIsDevice && !VD->isExternallyVisible()) {
       // Do not create a "ref-variable" if the original is not also available
       // on the host.
       if (!OffloadEntriesInfoManager.hasDeviceGlobalVarEntryInfo(VarName))
         return;
       std::string RefName = getName({VarName, "ref"});
       if (!CGM.GetGlobalValue(RefName)) {
         llvm::Constant *AddrRef =
-            getOrCreateInternalVariable(Addr->getType(), RefName);
+            getOrCreateInternalVariable(CGM.VoidPtrTy, RefName);
         auto *GVAddrRef = cast<llvm::GlobalVariable>(AddrRef);
         GVAddrRef->setConstant(/*Val=*/true);
         GVAddrRef->setLinkage(llvm::GlobalValue::InternalLinkage);
-        GVAddrRef->setInitializer(Addr);
+        GVAddrRef->setInitializer(
+            llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
+                Addr, CGM.VoidPtrTy));
         CGM.addCompilerUsedGlobal(GVAddrRef);
       }
     }
   } else {
     assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
             (*Res == OMPDeclareTargetDeclAttr::MT_To &&
              HasRequiresUnifiedSharedMemory)) &&
            "Declare target attribute must link or to with unified memory.");

clang/test/OpenMP/declare_target_codegen.cpp

 // CHECK-DAG: @eee_decl_tgt_ref_ptr = weak global i32* null
 // CHECK-DAG: @{{.*}}maini1{{.*}}aaa = internal global i64 23,
 // CHECK-DAG: @pair = {{.*}}addrspace(3) global %struct.PAIR undef
 // CHECK-DAG: @b ={{ hidden | }}global i32 15,
 // CHECK-DAG: @d ={{ hidden | }}global i32 0,
 // CHECK-DAG: @c = external global i32,
 // CHECK-DAG: @globals ={{ hidden | }}global %struct.S zeroinitializer,
 // CHECK-DAG: [[STAT:@.+stat]] = internal global %struct.S zeroinitializer,
-// CHECK-DAG: [[STAT_REF:@.+]] = internal constant %struct.S* [[STAT]]
+// CHECK-DAG: [[STAT_REF:@.+]] = internal constant i8* bitcast (%struct.S* [[STAT]] to i8*)
 // CHECK-DAG: @out_decl_target ={{ hidden | }}global i32 0,
 // CHECK-DAG: @llvm.used = appending global [2 x i8*] [i8* bitcast (void ()* @__omp_offloading__{{.+}}_globals_l[[@LINE+84]]_ctor to i8*), i8* bitcast (void ()* @__omp_offloading__{{.+}}_stat_l[[@LINE+85]]_ctor to i8*)],
-// CHECK-DAG: @llvm.compiler.used = appending global [1 x i8*] [i8* bitcast (%struct.S** [[STAT_REF]] to i8*)],
+// CHECK-DAG: @llvm.compiler.used = appending global [1 x i8*] [i8* bitcast (i8** [[STAT_REF]] to i8*)],
 
 // CHECK-DAG: define {{.*}}i32 @{{.*}}{{foo|bar|baz2|baz3|FA|f_method}}{{.*}}()
 // CHECK-DAG: define {{.*}}void @{{.*}}TemplateClass{{.*}}(%class.TemplateClass* {{[^,]*}} %{{.*}})
 // CHECK-DAG: define {{.*}}i32 @{{.*}}TemplateClass{{.*}}f_method{{.*}}(%class.TemplateClass* {{[^,]*}} %{{.*}})
 // CHECK-DAG: define {{.*}}void @__omp_offloading__{{.*}}_globals_l[[@LINE+78]]_ctor()
 
 #ifndef HEADER
 #define HEADER

openmp/libomptarget/test/offloading/ref_to_shared.cpp

+// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
+// REQUIRES: nvptx64-nvidia-cuda
+
+#include <iostream>
+#include <omp.h>
+#pragma omp declare target
+
+static int X;
+#pragma omp allocate(X) allocator(omp_pteam_mem_alloc)
+
+int main() {
+  // CHECK: PASS
+  std::cout << "PASS\n";
+  return 0;
+}
+
+#pragma omp end declare target