This is a minor change to allow stateful transformation for non-gep

pointer.

This change should have not functional change yet. The next one will
enable this change.

Author: jgu222

IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStatefull/StatelessToStatefull.cpp

@@ -334,13 +334,11 @@ bool StatelessToStatefull::getOffsetFromGEP(
     return true;
 }
 
-const KernelArg* StatelessToStatefull::gepIsFromKernelArgument(const PointerType& ptrType, GetElementPtrInst* gep)
+const KernelArg* StatelessToStatefull::getKernelArgFromPtr(const PointerType& ptrType, Value* pVal)
 {
-    // skip if no gep at all
-    if (gep == nullptr)
+    if (pVal == nullptr)
         return nullptr;
-
-    Value* base = gep->getPointerOperand()->stripPointerCasts();
+    Value* base = pVal;
 
     // stripPointerCasts might skip addrSpaceCast, thus check if AS is still
     // the original one.
@@ -364,10 +362,10 @@ bool StatelessToStatefull::pointerIsFromKernelArgument(Value& ptr)
         base = gep->getPointerOperand()->stripPointerCasts();
     }
 
-    if (gep == nullptr)
+    if (!m_supportNonGEPPtr && gep == nullptr)
         return false;
 
-    if (gepIsFromKernelArgument(*dyn_cast<PointerType>(ptr.getType()), gep) != nullptr)
+    if (getKernelArgFromPtr(*dyn_cast<PointerType>(ptr.getType()), base) != nullptr)
         return true;
     return false;
 }
@@ -409,8 +407,13 @@ bool StatelessToStatefull::pointerIsPositiveOffsetFromKernelArgument(
         base = gep->getPointerOperand()->stripPointerCasts();
     }
 
-    // if the last gep is from kerenl argument
-    if (const KernelArg * arg = gepIsFromKernelArgument(*ptrType, gep))
+    if (!m_supportNonGEPPtr && gep == nullptr)
+    {
+        return false;
+    }
+
+    // if the base is from kerenl argument
+    if (const KernelArg * arg = getKernelArgFromPtr(*ptrType, base))
     {
         // base is the argument!
         argNumber = arg->getAssociatedArgNo();
@@ -430,6 +433,15 @@ bool StatelessToStatefull::pointerIsPositiveOffsetFromKernelArgument(
             ? true
             : (getPointeeAlign(DL, base) >= 4);
 
+        // special handling
+        if (m_supportNonGEPPtr && gep == nullptr && !arg->isImplicitArg())
+        {
+            // For NonGEP ptr, do stateful only if arg isn't char*/short*
+            // (We hit bugs when allowing stateful for char*/short* arg without GEP.
+            //  Here, we simply avoid doing stateful for char*/short*.)
+            isAlignedPointee = (getPointeeAlign(DL, base) >= 4);
+        }
+
         // If m_hasBufferOffsetArg is true, the offset argument is added to
         // the final offset to make it definitely positive. Thus skip checking
         // if an offset is positive.

IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStatefull/StatelessToStatefull.hpp

@@ -78,10 +78,9 @@ namespace IGC
         bool pointerIsPositiveOffsetFromKernelArgument(
             llvm::Function* F, llvm::Value* V, llvm::Value*& offset, unsigned int& argNumber, const KernelArg*& kernelArg);
 
-        // Check if the given gep can be traced back to any kernel argument.
+        // Check if the given pointer value can be traced back to any kernel argument.
         // return the kernel argument if found, otherwise return nullptr.
-        // lastGep - the last gep of pointer address, nullptr if no GEP
-        const KernelArg* gepIsFromKernelArgument(const llvm::PointerType& ptrType, llvm::GetElementPtrInst* gep);
+        const KernelArg* getKernelArgFromPtr(const llvm::PointerType& ptrType, llvm::Value* pVal);
 
         // check if the given pointer can be traced back to any kernel argument
         bool pointerIsFromKernelArgument(llvm::Value& ptr);
@@ -134,6 +133,11 @@ namespace IGC
         // When true, every messages that are in ptrArg + offset will have offset >= 0.
         bool       m_hasPositivePointerOffset;
 
+        // Handle non-gep pointer
+        //   For historic reason (probably non-DW aligned arg), non-gep ptr isn't handled.
+        //   If this field is true, non-gep ptr shall be handled.
+        const bool m_supportNonGEPPtr = false;
+
         llvm::AssumptionCacheTracker* m_ACT;
         llvm::AssumptionCache* getAC(llvm::Function* F)
         {