Add pass checking if the address in load/store is valid.

This commit adds a new pass that iterate over all load/store
instructions and checks if the address used in the instruction
is greater of equal than the minimum valid address defined
by a user.

Author: mateuszchudyk

IGC/AdaptorOCL/UnifyIROCL.cpp

@@ -131,6 +131,7 @@ SPDX-License-Identifier: MIT
 #include "Compiler/Optimizer/IGCInstCombiner/IGCInstructionCombining.hpp"
 #include "Compiler/Optimizer/OpenCLPasses/BufferBoundsChecking/BufferBoundsChecking.hpp"
 #include "Compiler/Optimizer/OpenCLPasses/BufferBoundsChecking/BufferBoundsCheckingPatcher.hpp"
+#include "Compiler/Optimizer/OpenCLPasses/MinimumValidAddressChecking/MinimumValidAddressChecking.hpp"
 
 #include "common/debug/Debug.hpp"
 #include "common/igc_regkeys.hpp"
@@ -393,6 +394,19 @@ static void CommonOCLBasedPasses(OpenCLProgramContext* pContext)
         mpm.add(new BufferBoundsChecking());
     }
 
+    // Minimum valid address checking
+    {
+        uint64_t minimumValidAddress = IGC_GET_FLAG_VALUE(MinimumValidAddress);
+        if (!minimumValidAddress)
+        {
+            minimumValidAddress = pContext->getMinimumValidAddress();
+        }
+        if (minimumValidAddress)
+        {
+            mpm.add(new MinimumValidAddressChecking(minimumValidAddress));
+        }
+    }
+
     mpm.add(new NamedBarriersResolution(pContext->platform.getPlatformInfo().eRenderCoreFamily));
     mpm.add(new PreBIImportAnalysis());
     mpm.add(createTimeStatsCounterPass(pContext, TIME_Unify_BuiltinImport, STATS_COUNTER_START));

IGC/BiFModule/Implementation/assert.cl

@@ -111,3 +111,24 @@ void __bufferoutofbounds_assert_nodebug(long bufferAddress, long bufferOffsetInB
     header->flag = ERROR_TYPE_BUFFER_OUTOFBOUNDS;
     __builtin_IB_software_exception();
 }
+
+void __minimumvalidaddresschecking_assert(const char* file, int line, int column, long address) {
+    printf("Load/store uses the address less than the minimum valid address!\n"
+           "   Location:      %s:%d:%d\n"
+           "   Address:       0x%X\n",
+           file, line, column, address);
+
+    AssertBufferHeader* header = __builtin_IB_get_assert_buffer();
+    header->flag = ERROR_TYPE_ASSERT;
+    __builtin_IB_software_exception();
+}
+
+void __minimumvalidaddresschecking_assert_nodebug(long address) {
+    printf("Load/store uses the address less than the minimum valid address!\n"
+           "   Address:       0x%X\n",
+           address);
+
+    AssertBufferHeader* header = __builtin_IB_get_assert_buffer();
+    header->flag = ERROR_TYPE_ASSERT;
+    __builtin_IB_software_exception();
+}

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp

@@ -256,6 +256,11 @@ namespace IGC
         return platform.getSlmSizePerSsOrDss();
     }
 
+    uint64_t OpenCLProgramContext::getMinimumValidAddress() const
+    {
+        return m_InternalOptions.MinimumValidAddress;
+    }
+
     COpenCLKernel::COpenCLKernel(OpenCLProgramContext* ctx, Function* pFunc, CShaderProgram* pProgram) :
         CComputeShaderBase(pFunc, pProgram)
     {

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.hpp

@@ -107,6 +107,7 @@ namespace IGC
         unsigned GetSlmSizePerSubslice();
         float GetSpillThreshold(SIMDMode dispatchSize);
         bool isAutoGRFSelectionEnabled() const override;
+        uint64_t getMinimumValidAddress() const override;
 
         void clearBeforeRetry() {
             m_programOutput.clearBeforeRetry();

IGC/Compiler/CISACodeGen/OpenCLOptions.cpp

@@ -409,6 +409,20 @@ void InternalOptions::parseOptions(const char* internalOpts)
     {
         EnableBufferBoundsChecking = true;
     }
+
+    if (const llvm::opt::Arg* arg = internalOptions.getLastArg(OPT_minimum_valid_address_checking_common))
+    {
+        llvm::StringRef valStr = arg->getValue();
+        int val = 0;
+        if (valStr.getAsInteger(16, val) || val < 0)
+        {
+            IGC_ASSERT_MESSAGE(false, "-cl-minimum-valid-address-checking: invalid value, ignored!");
+        }
+        else
+        {
+            MinimumValidAddress = val;
+        }
+    }
 }
 
 void Options::parseOptions(const char* opts)

IGC/Compiler/CISACodeGen/OpenCLOptions.hpp

@@ -120,6 +120,9 @@ class InternalOptions
      // Compile only up to vISA stage.
      bool EmitVisaOnly                               = false;
 
+
+    uint64_t MinimumValidAddress              = 0;
+
 private:
      void parseOptions(const char* internalOpts);
      };

IGC/Compiler/CodeGenContext.cpp

@@ -981,6 +981,11 @@ namespace IGC
         return simdMode;
     }
 
+    uint64_t CodeGenContext::getMinimumValidAddress() const
+    {
+        return 0;
+    }
+
     // [used by shader dump] create unqiue id, starting from 1, for each
     // entry function.
     // Each entry function has 1-1 map b/w its name and its dump name.

IGC/Compiler/CodeGenPublic.h

@@ -1127,6 +1127,7 @@ namespace IGC
         virtual bool enableZEBinary() const;
         bool isPOSH() const;
         virtual bool isBufferBoundsChecking() const;
+        virtual uint64_t getMinimumValidAddress() const;
 
         UserAddrSpaceMD& getUserAddrSpaceMD() {
             IGC_ASSERT(llvmCtxWrapper);

IGC/Compiler/InitializePasses.h

@@ -261,3 +261,4 @@ void initializeBufferBoundsCheckingPass(llvm::PassRegistry&);
 void initializeBufferBoundsCheckingPatcherPass(llvm::PassRegistry&);
 void initializeBfloatFuncsResolutionPass(llvm::PassRegistry &);
 void initializeBarrierControlFlowOptimizationPass(llvm::PassRegistry&);
+void initializeMinimumValidAddressCheckingPass(llvm::PassRegistry&);

IGC/Compiler/Optimizer/OpenCLPasses/CMakeLists.txt

@@ -35,6 +35,7 @@ add_subdirectory(BufferBoundsChecking)
 add_subdirectory(LSCFuncs)
 add_subdirectory(Decompose2DBlockFuncs)
 add_subdirectory(LocalBuffers)
+add_subdirectory(MinimumValidAddressChecking)
 add_subdirectory(NamedBarriers)
 add_subdirectory(NontemporalLoadsAndStoresInAssert)
 add_subdirectory(OpenCLPrintf)
@@ -85,6 +86,7 @@ set(IGC_BUILD__SRC__Optimizer_OpenCLPasses_All
     ${IGC_BUILD__SRC__OpenCLPasses_BufferBoundsChecking}
     ${IGC_BUILD__SRC__OpenCLPasses_LSCFuncs}
     ${IGC_BUILD__SRC__OpenCLPasses_LocalBuffers}
+    ${IGC_BUILD__SRC__OpenCLPasses_MinimumValidAddressChecking}
     ${IGC_BUILD__SRC__OpenCLPasses_NamedBarriers}
     ${IGC_BUILD__SRC__OpenCLPasses_NontemporalLoadsAndStoresInAssert}
     ${IGC_BUILD__SRC__OpenCLPasses_OpenCLPrintf}
@@ -141,6 +143,7 @@ set(IGC_BUILD__HDR__Optimizer_OpenCLPasses_All
     ${IGC_BUILD__HDR__OpenCLPasses_LSCFuncs}
     ${IGC_BUILD__HDR__OpenCLPasses_IOBlock2DFuncs}
     ${IGC_BUILD__HDR__OpenCLPasses_LocalBuffers}
+    ${IGC_BUILD__HDR__OpenCLPasses_MinimumValidAddressChecking}
     ${IGC_BUILD__HDR__OpenCLPasses_NamedBarriers}
     ${IGC_BUILD__HDR__OpenCLPasses_NontemporalLoadsAndStoresInAssert}
     ${IGC_BUILD__HDR__OpenCLPasses_OpenCLPrintf}
@@ -197,6 +200,7 @@ set(IGC_BUILD_Compiler_OpenCLPasses_Groups
     Compiler__OpenCLPasses_LSCFuncs
     Compiler__OpenCLPasses_IOBlock2DFuncs
     Compiler__OpenCLPasses_LocalBuffers
+    Compiler__OpenCLPasses_MinimumValidAddressChecking
     Compiler__OpenCLPasses_NamedBarriers
     Compiler__OpenCLPasses_NontemporalLoadsAndStoresInAssert
     Compiler__OpenCLPasses_OpenCLPrintf

IGC/Compiler/Optimizer/OpenCLPasses/MinimumValidAddressChecking/CMakeLists.txt

@@ -0,0 +1,29 @@
+#=========================== begin_copyright_notice ============================
+#
+# Copyright (C) 2024 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+#============================ end_copyright_notice =============================
+
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
+
+
+set(IGC_BUILD__SRC__MinimumValidAddressChecking
+    "${CMAKE_CURRENT_SOURCE_DIR}/MinimumValidAddressChecking.cpp"
+  )
+set(IGC_BUILD__SRC__OpenCLPasses_MinimumValidAddressChecking ${IGC_BUILD__SRC__MinimumValidAddressChecking} PARENT_SCOPE)
+
+set(IGC_BUILD__HDR__MinimumValidAddressChecking
+    "${CMAKE_CURRENT_SOURCE_DIR}/MinimumValidAddressChecking.hpp"
+  )
+set(IGC_BUILD__HDR__OpenCLPasses_MinimumValidAddressChecking ${IGC_BUILD__HDR__MinimumValidAddressChecking} PARENT_SCOPE)
+
+
+igc_sg_register(
+    Compiler__OpenCLPasses_MinimumValidAddressChecking
+    "MinimumValidAddressChecking"
+    FILES
+      ${IGC_BUILD__SRC__MinimumValidAddressChecking}
+      ${IGC_BUILD__HDR__MinimumValidAddressChecking}
+  )