[Autobackout][FuncReg]Revert of change: 709c40c

 Applied EmitScalarAtomics for 64 bit uniform atomics

Extended EmitScalarAtomics function for atomics with 64 bit type

Author: ppogotov

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -13329,10 +13329,6 @@ void EmitPass::emitScalarAtomics(
     {
     case EATOMIC_IADD:
     case EATOMIC_SUB:
-    case EATOMIC_IADD64:
-    case EATOMIC_SUB64:
-    case EATOMIC_FADD64:
-    case EATOMIC_FSUB64:
     case EATOMIC_INC:
     case EATOMIC_DEC:
     case EATOMIC_FADD:
@@ -13378,18 +13374,13 @@ void EmitPass::emitScalarAtomics(
     {
         type = ISA_TYPE_F;
     }
-    else if (atomic_op == EATOMIC_FADD64 || atomic_op == EATOMIC_FSUB64)
-    {
-        type = ISA_TYPE_DF;
-    }
     else
     {
         type =
             bitWidth == 16 ? ISA_TYPE_W :
             bitWidth == 32 ? ISA_TYPE_D :
                         ISA_TYPE_Q;
     }
-
     IGC_ASSERT_MESSAGE((bitWidth == 16) || (bitWidth == 32) || (bitWidth == 64), "invalid bitsize");
     if (atomic_op == EATOMIC_INC || atomic_op == EATOMIC_DEC)
     {
@@ -13415,22 +13406,6 @@ void EmitPass::emitScalarAtomics(
         negateSrc = true;
         uniformAtomicOp = EATOMIC_IADD;
     }
-    else if (atomic_op == EATOMIC_SUB64)
-    {
-        negateSrc = true;
-        uniformAtomicOp = EATOMIC_IADD64;
-    }
-    else if (atomic_op == EATOMIC_FSUB)
-    {
-        negateSrc = true;
-        uniformAtomicOp = EATOMIC_FADD;
-    }
-    else if (atomic_op == EATOMIC_FSUB64)
-    {
-        negateSrc = true;
-        uniformAtomicOp = EATOMIC_FADD64;
-    }
-
     bool returnsImmValue = (!pInst->use_empty());
     CVariable* pFinalAtomicSrcVal;
     CVariable* pSrcsArr[2] = { nullptr, nullptr };
@@ -13555,27 +13530,9 @@ void EmitPass::emitScalarAtomics(
     m_encoder->SetSimdSize(SIMDMode::SIMD1);
     m_encoder->SetNoMask();
 
-    VISA_Type pReturnValType;
-    if (type == ISA_TYPE_Q)
-    {
-        pReturnValType = ISA_TYPE_UQ;
-    }
-    else if (type == ISA_TYPE_DF)
-    {
-        pReturnValType = ISA_TYPE_DF;
-    }
-    else if (type == ISA_TYPE_F)
-    {
-        pReturnValType = ISA_TYPE_F;
-    }
-    else
-    {
-        pReturnValType = ISA_TYPE_UD;
-    }
-
     CVariable* pReturnVal = returnsImmValue ?
         m_currShader->GetNewVariable(
-            1, pReturnValType, EALIGN_GRF, true, CName::NONE) :
+            1, ISA_TYPE_UD, EALIGN_GRF, true, CName::NONE) :
         nullptr;
 
     if (bitWidth == 16)
@@ -13621,7 +13578,7 @@ void EmitPass::emitScalarAtomics(
             m_encoder->Add(pSrcsArr[i], pSrcsArr[i], pReturnVal);
             m_encoder->Push();
 
-            if (atomic_op == EATOMIC_IADD || atomic_op == EATOMIC_IADD64 || atomic_op == EATOMIC_FADD || atomic_op == EATOMIC_FADD64)
+            if (atomic_op == EATOMIC_IADD)
             {
                 m_encoder->SetSrcModifier(1, EMOD_NEG);
             }
@@ -13751,30 +13708,14 @@ bool EmitPass::IsUniformAtomic(llvm::Instruction* pInst)
         {
             Function* F = pInst->getParent()->getParent();
             //We cannot optimize float atomics if the flag "unsafe-fp-math" was not passed.
-
-            unsigned short bitwidth = pInst->getType()->getScalarSizeInBits();
-            //We cannot optimize float and double atomics if the flag "unsafe-fp-math" was not passed.
-            if (id == GenISAIntrinsic::GenISA_floatatomicrawA64)
-            {
-                if (!F->hasFnAttribute("unsafe-fp-math") || !(F->getFnAttribute("unsafe-fp-math").getValueAsString() == "true") || bitwidth == 16)
-                {
+            if (id == GenISAIntrinsic::GenISA_floatatomicrawA64) {
+                if (pInst->getType()->getScalarSizeInBits() != 32) {
                     return false;
                 }
-            }
-
-            if (bitwidth == 64)
-            {
-                AtomicOp atomic_op = static_cast<AtomicOp>(llvm::cast<llvm::ConstantInt>(pInst->getOperand(3))->getZExtValue());
-
-                bool is_i64 = (atomic_op == EATOMIC_IADD64 || atomic_op == EATOMIC_SUB64);
-                bool is_f64 = (atomic_op == EATOMIC_FADD64 || atomic_op == EATOMIC_FSUB64);
-
-                if ((!is_i64 || !m_currShader->m_Platform->hasInt64Add()) && (!is_f64 || !m_currShader->m_Platform->hasFP64GlobalAtomicAdd()))
-                {
+                if (!F->hasFnAttribute("unsafe-fp-math") || !(F->getFnAttribute("unsafe-fp-math").getValueAsString() == "true")) {
                     return false;
                 }
             }
-
             if (IGC_IS_FLAG_ENABLED(DisableScalarAtomics) ||
                 F->hasFnAttribute("KMPLOCK") ||
                 m_currShader->m_DriverInfo->WASLMPointersDwordUnit())
@@ -13791,10 +13732,6 @@ bool EmitPass::IsUniformAtomic(llvm::Instruction* pInst)
 
                 bool isAtomicAdd =
                     atomic_op == EATOMIC_IADD ||
-                    atomic_op == EATOMIC_IADD64 ||
-                    atomic_op == EATOMIC_SUB64 ||
-                    atomic_op == EATOMIC_FADD64 ||
-                    atomic_op == EATOMIC_FSUB64 ||
                     atomic_op == EATOMIC_INC ||
                     atomic_op == EATOMIC_SUB ||
                     atomic_op == EATOMIC_DEC ||
@@ -13962,8 +13899,8 @@ void EmitPass::emitAtomicRaw(llvm::GenIntrinsicInst* pInsn)
     // Dst address in bytes.
     CVariable* pDstAddr = GetSymbol(pllDstAddr);
     // If DisableScalarAtomics regkey is enabled or DisableIGCOptimizations regkey is enabled then
-    // don't enable scalar atomics
-    if (IsUniformAtomic(pInsn))
+    // don't enable scalar atomics, also do not enable for 64 bit
+    if (IsUniformAtomic(pInsn) && bitwidth != 64)
     {
         PointerType* PtrTy = dyn_cast<PointerType>(pllDstAddr->getType());
         bool isA64 = PtrTy && isA64Ptr(PtrTy, m_currShader->GetContext());