Changes in code.

Author: AnBodrova

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp

@@ -306,6 +306,12 @@ namespace IGC
                 IntelHasPositivePointerOffset = true;
             }
 
+            // -cl-intel-has-subDW-aligned-ptr-arg, -ze-opt-has-subDW-aligned-ptr-arg
+            else if (suffix.equals("-has-subDW-aligned-ptr-arg"))
+            {
+                IntelHasSubDWAlignedPtrArg = true;
+            }
+
             // -cl-intel-disable-a64WA
             else if (suffix.equals("-disable-a64WA"))
             {

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.hpp

@@ -34,6 +34,7 @@ namespace IGC
                 IntelHasPositivePointerOffset(false),
                 IntelHasBufferOffsetArg(false),
                 IntelBufferOffsetArgOptional(true),
+                IntelHasSubDWAlignedPtrArg(false),
                 LargeGRFKernels(),
                 RegularGRFKernels()
             {
@@ -71,6 +72,10 @@ namespace IGC
             bool IntelHasPositivePointerOffset; // default: false
             bool IntelHasBufferOffsetArg;       // default: false
             bool IntelBufferOffsetArgOptional;  // default: true
+            bool IntelHasSubDWAlignedPtrArg;
+            // default: false, meaning kernel's sub-DW ptrArgs (char*, short*) are DW-aligned.
+            // This default is stronger than the natural alignment implied by char*/short*. But
+            // for historical reason, we have this.
 
             bool replaceGlobalOffsetsByZero = false;
             bool IntelEnablePreRAScheduling = true;

IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStateful/StatelessToStateful.cpp

@@ -132,6 +132,7 @@ StatelessToStateful::StatelessToStateful()
     : FunctionPass(ID),
     m_hasBufferOffsetArg(false),
     m_hasOptionalBufferOffsetArg(false),
+    m_hasSubDWAlignedPtrArg(false),
     m_hasPositivePointerOffset(false),
     m_ACT(nullptr),
     m_pImplicitArgs(nullptr),
@@ -174,6 +175,8 @@ bool StatelessToStateful::runOnFunction(llvm::Function& F)
     m_hasOptionalBufferOffsetArg = (m_hasBufferOffsetArg &&
         (IGC_IS_FLAG_ENABLED(EnableOptionalBufferOffset) || modMD->compOpt.BufferOffsetArgOptional));
 
+    m_hasSubDWAlignedPtrArg = (IGC_IS_FLAG_ENABLED(UseSubDWAlignedPtrArg) || modMD->compOpt.HasSubDWAlignedPtrArg);
+
     m_hasPositivePointerOffset = (IGC_IS_FLAG_ENABLED(SToSProducesPositivePointer) || modMD->compOpt.HasPositivePointerOffset);
 
     m_pImplicitArgs = new ImplicitArgs(F, pMdUtils);
@@ -424,7 +427,10 @@ bool StatelessToStateful::pointerIsPositiveOffsetFromKernelArgument(
         // guarantted to be DW-aligned.)
         //
         // Note that implicit arg is always aligned.
-        bool isAlignedPointee = arg->isImplicitArg() ? true : (getPointeeAlign(DL, base) >= 4);
+        bool isAlignedPointee =
+            (!m_hasSubDWAlignedPtrArg || arg->isImplicitArg())
+            ? true
+            : (getPointeeAlign(DL, base) >= 4);
 
         // special handling
         if (m_supportNonGEPPtr && gep == nullptr && !arg->isImplicitArg())

IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStateful/StatelessToStateful.hpp

@@ -151,6 +151,11 @@ namespace IGC
         // can be on or off, which is indicated by this boolean flag.
         bool       m_hasOptionalBufferOffsetArg;
 
+        // For historic reason, kernel ptrArgs, such as char*, short*, are assumed to
+        // be aligned on DW (which is stronger than what OCL's natural alignment) in this
+        // stateful optimization.  If this is not a case, this arg should be set to true!
+        bool       m_hasSubDWAlignedPtrArg;
+
         // When true, every messages that are in ptrArg + offset will have offset >= 0.
         bool       m_hasPositivePointerOffset;
 

IGC/Compiler/tests/StatelessToStateful/bufferOffset/char_pointer_argument.ll

@@ -392,6 +392,7 @@ namespace IGC
         bool HasPositivePointerOffset                   = false;
         bool HasBufferOffsetArg                         = false;
         bool BufferOffsetArgOptional                    = true;
+        bool HasSubDWAlignedPtrArg                      = false;
         bool replaceGlobalOffsetsByZero                 = false;
         unsigned forcePixelShaderSIMDMode               = 0;
         bool pixelShaderDoNotAbortOnSpill               = false;

IGC/common/MDFrameWork.h

@@ -287,6 +287,7 @@ DECLARE_IGC_REGKEY(DWORD, DebugInternalSwitch,          0,     "Code pass select
 DECLARE_IGC_REGKEY(bool, SToSProducesPositivePointer,   false, "This key is for StatelessToStateful optimization if the  user knows the pointer offset is postive to the kernel argument.", false)
 DECLARE_IGC_REGKEY(bool, EnableSupportBufferOffset,     false, "[debugging]For StatelessToStateful optimization [OCL], support implicit buffer offset argument (same as -cl-intel-has-buffer-offset-arg).", false)
 DECLARE_IGC_REGKEY(bool, EnableOptionalBufferOffset,    true,  "For StatelessToStateful optimization [OCL], if true, make buffer offset optional. Valid only if buffer offset is supported.", true)
+DECLARE_IGC_REGKEY(bool, UseSubDWAlignedPtrArg,         false, "[OCL]If set, for kernel pointer arg such as ptr to char or short, the arg is not necessarily DW aligned", false)
 DECLARE_IGC_REGKEY(bool, EnableTestIGCBuiltin,          false, "Enable testing igc builtin (precompiled kernels) using OCL.", false)
 DECLARE_IGC_REGKEY(bool, EnableCSSIMD32,                false, "Enable computer shader SIMD32 mode, and fall back to lower SIMD when spill", false)
 DECLARE_IGC_REGKEY(bool, ForceCSSIMD32,                 false, "Force computer shader SIMD32 mode", false)