Fix the llvmir translation by getting valid type from global

Author: skc7

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

@@ -2285,12 +2285,15 @@ def GroupprivateOp : OpenMP_Op<"groupprivate",
     each group having its own copy.
 
     This operation takes in the address of a symbol that represents the original
-    variable, optional DeviceTypeAttr and returns the address of its groupprivate copy.
-    All occurrences of groupprivate variables in a parallel region should
-    use the groupprivate copy returned by this operation.
+    variable and returns the address of its groupprivate copy. The symbol must
+    refer to a global variable so that type information can be obtained from it.
 
     The `sym_addr` refers to the address of the symbol, which is a pointer to
-    the original variable.
+    the original variable. It must be obtained via `llvm.mlir.addressof` from
+    a global variable.
+
+    The optional `device_type` attribute specifies where the groupprivate
+    storage should be allocated (host, nohost, or any).
   }];
 
   let arguments = (ins

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

@@ -7112,7 +7112,7 @@ convertOmpGroupprivate(Operation &opInst, llvm::IRBuilderBase &builder,
   bool isTargetDevice = ompBuilder->Config.isTargetDevice();
   auto deviceType = groupprivateOp.getDeviceType();
 
-  // skip allocation based on device_type
+  // Skip allocation based on device_type
   bool shouldAllocate = true;
   if (deviceType.has_value()) {
     switch (*deviceType) {
@@ -7132,44 +7132,59 @@ convertOmpGroupprivate(Operation &opInst, llvm::IRBuilderBase &builder,
   }
 
   Value symAddr = groupprivateOp.getSymAddr();
-  Operation *symOp = symAddr.getDefiningOp();
+  llvm::Value *symValue = moduleTranslation.lookupValue(symAddr);
+  llvm::Value *resultPtr;
 
-  LLVM::GlobalOp global =
-      getGlobalFromSymbol(symOp, moduleTranslation, &opInst);
-  if (!global)
-    return failure();
+  // Get the element type and variable name from the global.
+  // Groupprivate requires sym_addr to come from a global variable.
+  llvm::Type *varType = nullptr;
+  std::string varName = "omp.groupprivate";
+
+  if (Operation *symOp = symAddr.getDefiningOp()) {
+    if (LLVM::GlobalOp global =
+            getGlobalFromSymbol(symOp, moduleTranslation, nullptr)) {
+      // Get type from the global
+      varType = moduleTranslation.convertType(global.getType());
+      // Get name from the global
+      if (llvm::GlobalValue *globalValue =
+              moduleTranslation.lookupGlobal(global)) {
+        varName = globalValue->getName().str();
+      }
+    }
+  }
 
-  llvm::GlobalValue *globalValue = moduleTranslation.lookupGlobal(global);
-  llvm::Value *resultPtr;
+  if (!varType) {
+    return opInst.emitError()
+           << "Groupprivate requires sym_addr to reference a global variable";
+  }
 
   if (shouldAllocate) {
     if (isTargetDevice) {
-      // Get the size of the variable
-      llvm::Type *varType = globalValue->getValueType();
       llvm::Module *llvmModule = moduleTranslation.getLLVMModule();
-      // Create a llvm global variable in shared memory
       llvm::Triple targetTriple = llvm::Triple(llvmModule->getTargetTriple());
       if (targetTriple.isAMDGCN() || targetTriple.isNVPTX()) {
-        // Shared address space is 3 for amdgpu and nvptx targets.
+        // Shared address space is 3 for AMDGPU and NVPTX targets.
         unsigned sharedAddressSpace = 3;
         llvm::GlobalVariable *sharedVar = new llvm::GlobalVariable(
-            *llvmModule, varType, false, llvm::GlobalValue::InternalLinkage,
-            llvm::PoisonValue::get(varType), globalValue->getName(), nullptr,
-            llvm::GlobalValue::NotThreadLocal, sharedAddressSpace, false);
+            *llvmModule, varType, /*isConstant=*/false,
+            llvm::GlobalValue::InternalLinkage, llvm::PoisonValue::get(varType),
+            varName, /*InsertBefore=*/nullptr,
+            llvm::GlobalValue::NotThreadLocal, sharedAddressSpace,
+            /*isExternallyInitialized=*/false);
         resultPtr = sharedVar;
       } else {
         return opInst.emitError()
                << "Groupprivate operation is not supported for this target: "
                << targetTriple.str();
       }
     } else {
-      // Use original global address when allocating on host device.
+      // Use original address when allocating on host device.
       // TODO: Add support for allocating group-private storage on host device.
-      resultPtr = globalValue;
+      resultPtr = symValue;
     }
   } else {
-    // Use original global address when not allocating group-private storage.
-    resultPtr = globalValue;
+    // Use original address when not allocating group-private storage.
+    resultPtr = symValue;
   }
 
   moduleTranslation.mapValue(opInst.getResult(0), resultPtr);
@@ -7184,8 +7199,8 @@ LogicalResult OpenMPDialectLLVMIRTranslationInterface::convertOperation(
   llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
 
   if (ompBuilder->Config.isTargetDevice() &&
-      !isa<omp::TargetOp, omp::MapInfoOp, omp::TerminatorOp, omp::YieldOp>(
-          op) &&
+      !isa<omp::TargetOp, omp::MapInfoOp, omp::TerminatorOp, omp::YieldOp,
+           omp::GroupprivateOp>(op) &&
       isHostDeviceOp(op))
     return op->emitOpError() << "unsupported host op found in device";