[MI300] Improved fix for SWDEV-443900

Restructured the method body of canUseAMDGPUFastFPAtomics. A type check is only performed if a fast atomic
operation can be emitted at all. The patch also fixes the failure of some lit tests. None of them meet the
conditions to emit a fast atomic fp operation.

Change-Id: I35275de8639173b84f6e6defa4ad34b484181cf5

Author: ThorBl

clang/lib/CodeGen/CGStmtOpenMP.cpp

@@ -6306,7 +6306,7 @@ static void emitOMPAtomicWriteExpr(CodeGenFunction &CGF,
 
 static bool canUseAMDGPUFastFPAtomics(CodeGenFunction &CGF, LValue X,
                                       RValue Update, BinaryOperatorKind BO,
-                                      const Expr *Hint) {
+                                      const Expr *Hint, SourceLocation Loc) {
 
   if (!Update.isScalar())
     return false;
@@ -6345,10 +6345,11 @@ static bool canUseAMDGPUFastFPAtomics(CodeGenFunction &CGF, LValue X,
     }
   }
 
-  // Fast FP atomics only work when the Update type is the same as the target X.
-  // If not, rever to atomicxchg and warn the user.
-  bool hasXandUpdateSameType =
-      (Update.getScalarVal()->getType() == X.getAddress(CGF).getElementType());
+  bool supportsFastFPAtomics =
+      Context.getTargetInfo().getTriple().isAMDGCN() &&
+      CGF.CGM.getOpenMPRuntime().supportFastFPAtomics() &&
+      CGF.CGM.getLangOpts().OpenMPIsTargetDevice &&
+      userRequestsAMDGPUFastFPAtomics;
 
   bool addOpHasAMDGPUFastVersion =
       BO == BO_Add && (Update.getScalarVal()->getType()->isDoubleTy() ||
@@ -6358,18 +6359,42 @@ static bool canUseAMDGPUFastFPAtomics(CodeGenFunction &CGF, LValue X,
       (BO == BO_LT || BO == BO_GT) &&
       Update.getScalarVal()->getType()->isDoubleTy();
 
-  return Context.getTargetInfo().getTriple().isAMDGCN() &&
-         CGF.CGM.getOpenMPRuntime().supportFastFPAtomics() &&
-         CGF.CGM.getLangOpts().OpenMPIsTargetDevice &&
-         userRequestsAMDGPUFastFPAtomics &&
-         (addOpHasAMDGPUFastVersion || minMaxOpHasAMDGPUFastVersion) &&
-         hasXandUpdateSameType && X.isSimple();
+  if (!supportsFastFPAtomics ||
+      (!addOpHasAMDGPUFastVersion && !minMaxOpHasAMDGPUFastVersion))
+    return false;
+
+  llvm::Type *UpdateType = Update.getScalarVal()->getType();
+  llvm::Type *XType = X.getAddress(CGF).getElementType();
+
+  bool isUpdateLosslesslyCastableToX =
+      UpdateType->canLosslesslyBitCastTo(XType);
+
+  if (!isUpdateLosslesslyCastableToX) {
+
+    auto getTypeNameAsString = [](llvm::Type* T) -> std::string {
+      std::string TypeNameStr;
+      llvm::raw_string_ostream OutputStream(TypeNameStr);
+      T->print(OutputStream);
+      return TypeNameStr;
+    };
+
+    unsigned DiagID = CGF.CGM.getDiags().getCustomDiagID(
+        DiagnosticsEngine::Warning,
+        "Can't emit fast FP atomic call due to type mismatch. The operation "
+        "tries to assign %0 to %1. A fallback atomic operation is "
+        "emitted which ignores the type conflict. Result may be incorrect!");
+    clang::DiagnosticBuilder DB = CGF.CGM.getDiags().Report(Loc, DiagID);
+    DB.AddString(getTypeNameAsString(UpdateType));
+    DB.AddString(getTypeNameAsString(XType));
+  }
+
+  return isUpdateLosslesslyCastableToX;
 }
 
 static std::pair<bool, RValue>
 emitOMPAtomicRMW(CodeGenFunction &CGF, LValue X, RValue Update,
                  BinaryOperatorKind BO, llvm::AtomicOrdering AO,
-                 bool IsXLHSInRHSPart, const Expr *Hint) {
+                 bool IsXLHSInRHSPart, const Expr *Hint, SourceLocation Loc) {
   ASTContext &Context = CGF.getContext();
 
   if (CGF.CGM.getOpenMPRuntime().mustEmitSafeAtomic(CGF, X, Update, BO)) {
@@ -6378,7 +6403,7 @@ emitOMPAtomicRMW(CodeGenFunction &CGF, LValue X, RValue Update,
     return std::make_pair(false, RValue::get(nullptr));
   }
 
-  bool useFPAtomics = canUseAMDGPUFastFPAtomics(CGF, X, Update, BO, Hint);
+  bool useFPAtomics = canUseAMDGPUFastFPAtomics(CGF, X, Update, BO, Hint, Loc);
   if (useFPAtomics) {
     auto Ret = CGF.CGM.getOpenMPRuntime().emitFastFPAtomicCall(
         CGF, X, Update, BO, IsXLHSInRHSPart);
@@ -6509,7 +6534,7 @@ std::pair<bool, RValue> CodeGenFunction::EmitOMPAtomicSimpleUpdateExpr(
   // x--, --x -> xrval - 1;
   // x = x binop expr; -> xrval binop expr
   // x = expr Op x; - > expr binop xrval;
-  auto Res = emitOMPAtomicRMW(*this, X, E, BO, AO, IsXLHSInRHSPart, Hint);
+  auto Res = emitOMPAtomicRMW(*this, X, E, BO, AO, IsXLHSInRHSPart, Hint, Loc);
   if (!Res.first) {
     if (X.isGlobalReg()) {
       // Emit an update expression: 'xrval' binop 'expr' or 'expr' binop
@@ -6745,9 +6770,9 @@ static void emitOMPAtomicCompareExpr(
   }
 
   // Check if fast AMDGPU FP atomics can be used for the current operation:
-  bool canUseFastAtomics =
-      canUseAMDGPUFastFPAtomics(CGF, XLVal, RValue::get(EVal),
-                                cast<BinaryOperator>(CE)->getOpcode(), Hint);
+  bool canUseFastAtomics = canUseAMDGPUFastFPAtomics(
+      CGF, XLVal, RValue::get(EVal), cast<BinaryOperator>(CE)->getOpcode(),
+      Hint, Loc);
   if (canUseFastAtomics) {
     CGF.CGM.getOpenMPRuntime().emitFastFPAtomicCall(
         CGF, XLVal, RValue::get(EVal), cast<BinaryOperator>(CE)->getOpcode(),