fix select instruction handling in ScalarArgAsPointer pass

Fixes select instruction handling in ScalarArgAsPointer pass.

(cherry picked from commit 71a219b)

Author: pkwasnie-intel

IGC/Compiler/Optimizer/OpenCLPasses/ScalarArgAsPointer/ScalarArgAsPointer.cpp

@@ -151,44 +151,71 @@ ScalarArgAsPointerAnalysis::findArgs(llvm::Instruction* inst)
         if (!findStoredArgs(*LI, *result))
             return nullptr; // (1) Found indirect access, fail search
     }
+    else if (SelectInst* SI = dyn_cast<SelectInst>(inst))
+    {
+        auto args1 = analyzeOperand(inst->getOperand(1));
+        auto args2 = analyzeOperand(inst->getOperand(2));
+
+        if (!args1 && !args2)
+            return nullptr; // propagate fail only if both paths fails
+
+        if (args1)
+            result->insert(args1->begin(), args1->end());
+
+        if (args2)
+            result->insert(args2->begin(), args2->end());
+    }
     else
     {
         // For any other type of instruction trace back operands.
         unsigned int numOperands = isa<GetElementPtrInst>(inst) ? 1 : inst->getNumOperands();
 
         for (unsigned int i = 0; i < numOperands; ++i)
         {
-            Value* op = inst->getOperand(i);
+            auto args = analyzeOperand(inst->getOperand(i));
 
-            if (Argument* arg = dyn_cast<Argument>(op))
-            {
-                // Consider only integer arguments
-                if (arg->getType()->getScalarType()->isIntegerTy())
-                {
-                    result->insert(arg);
-                }
-                else
-                {
-                    // (2) Found non-compatible argument, fail
-                    return nullptr;
-                }
-            }
-            else if (Instruction* opInst = dyn_cast<Instruction>(op))
-            {
-                auto args = findArgs(opInst);
-
-                if (!args)
-                    return nullptr; // propagate fail
+            if (!args)
+                return nullptr; // propagate fail
 
-                result->insert(args->begin(), args->end());
-            }
+            result->insert(args->begin(), args->end());
         }
     }
 
     m_visitedInst[inst] = result;
     return result;
 }
 
+const std::shared_ptr<ScalarArgAsPointerAnalysis::ArgSet>
+ScalarArgAsPointerAnalysis::analyzeOperand(llvm::Value* op)
+{
+    auto result = std::make_shared<ScalarArgAsPointerAnalysis::ArgSet>();
+
+    if (Argument* arg = dyn_cast<Argument>(op))
+    {
+        // Consider only integer arguments
+        if (arg->getType()->getScalarType()->isIntegerTy())
+        {
+            result->insert(arg);
+        }
+        else
+        {
+            // (2) Found non-compatible argument, fail
+            return nullptr;
+        }
+    }
+    else if (Instruction* opInst = dyn_cast<Instruction>(op))
+    {
+        auto args = findArgs(opInst);
+
+        if (!args)
+            return nullptr; // propagate fail
+
+        result->insert(args->begin(), args->end());
+    }
+
+    return result;
+}
+
 void ScalarArgAsPointerAnalysis::analyzeStoredArg(llvm::StoreInst& SI)
 {
     // Only track stores of kernel arguments.

IGC/Compiler/Optimizer/OpenCLPasses/ScalarArgAsPointer/ScalarArgAsPointer.hpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2022 Intel Corporation
+Copyright (C) 2022-2023 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -87,6 +87,13 @@ namespace IGC
         /// @returns  Set of matching kernel arguments.
         const std::shared_ptr<ArgSet> findArgs(llvm::Instruction* I);
 
+        /// @brief    Called by findArgs to analyzes instruction's operands. Returns null if load/store:
+        ///             (1) is indirect, or
+        ///             (2) uses pointer kernel argument
+        /// @param    op operand to trace back.
+        /// @returns  Set of matching kernel arguments.
+        const std::shared_ptr<ArgSet> analyzeOperand(llvm::Value* op);
+
         /// @brief  Checks if instruction stores kernel argument, and if true, traces back to
         ///         alloca instruction (with offset). This is required for decomposed structs
         ///         that are copied into private memory.

IGC/Compiler/tests/ScalarArgAsPointer/select_path_1.ll

@@ -0,0 +1,30 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2023 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; RUN: igc_opt --igc-scalar-arg-as-pointer-analysis --serialize-igc-metadata -S %s | FileCheck %s
+;
+; Tests "select" instruction, when first path leads to scalar as pointer.
+;
+; CHECK-NOT: !{!"m_OpenCLArgScalarAsPointersSet{{[[][0-9][]]}}", i32 0}
+; CHECK:     !{!"m_OpenCLArgScalarAsPointersSet{{[[][0-9][]]}}", i32 1}
+; CHECK-NOT: !{!"m_OpenCLArgScalarAsPointersSet{{[[][0-9][]]}}", i32 2}
+
+define spir_kernel void @test(i1 %s, i64 %a, i32 addrspace(1)* %b) #0 {
+entry:
+  %0 = inttoptr i64 %a to i32 addrspace(1)*
+  %1 = select i1 %s, i32 addrspace(1)* %0, i32 addrspace(1)* %b
+  %add.ptr = getelementptr inbounds i32, i32 addrspace(1)* %1, i64 0
+  store i32 39, i32 addrspace(1)* %add.ptr, align 4
+  ret void
+}
+
+!igc.functions = !{!0}
+
+!0 = !{void (i1, i64, i32 addrspace(1)*)* @test, !1}
+!1 = !{!2}
+!2 = !{!"function_type", i32 0}

IGC/Compiler/tests/ScalarArgAsPointer/select_path_2.ll

@@ -0,0 +1,30 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2023 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; RUN: igc_opt --igc-scalar-arg-as-pointer-analysis --serialize-igc-metadata -S %s | FileCheck %s
+;
+; Tests "select" instruction, when second path leads to scalar as pointer.
+;
+; CHECK-NOT: !{!"m_OpenCLArgScalarAsPointersSet{{[[][0-9][]]}}", i32 0}
+; CHECK-NOT: !{!"m_OpenCLArgScalarAsPointersSet{{[[][0-9][]]}}", i32 1}
+; CHECK:     !{!"m_OpenCLArgScalarAsPointersSet{{[[][0-9][]]}}", i32 2}
+
+define spir_kernel void @test(i1 %s, i32 addrspace(1)* %a, i64 %b) #0 {
+entry:
+  %0 = inttoptr i64 %b to i32 addrspace(1)*
+  %1 = select i1 %s, i32 addrspace(1)* %a, i32 addrspace(1)* %0
+  %add.ptr = getelementptr inbounds i32, i32 addrspace(1)* %1, i64 0
+  store i32 39, i32 addrspace(1)* %add.ptr, align 4
+  ret void
+}
+
+!igc.functions = !{!0}
+
+!0 = !{void (i1, i32 addrspace(1)*, i64)* @test, !1}
+!1 = !{!2}
+!2 = !{!"function_type", i32 0}

IGC/Compiler/tests/ScalarArgAsPointer/select_path_none.ll

@@ -0,0 +1,29 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2023 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; RUN: igc_opt --igc-scalar-arg-as-pointer-analysis --serialize-igc-metadata -S %s | FileCheck %s
+;
+; Tests "select" instruction, when no path leads to scalar as pointer.
+;
+; CHECK-NOT: !{!"m_OpenCLArgScalarAsPointersSet{{[[][0-9][]]}}", i32 0}
+; CHECK-NOT: !{!"m_OpenCLArgScalarAsPointersSet{{[[][0-9][]]}}", i32 1}
+; CHECK-NOT  !{!"m_OpenCLArgScalarAsPointersSet{{[[][0-9][]]}}", i32 2}
+
+define spir_kernel void @test(i1 %s, i32 addrspace(1)* %a, i32 addrspace(1)* %b) #0 {
+entry:
+  %0 = select i1 %s, i32 addrspace(1)* %a, i32 addrspace(1)* %b
+  %add.ptr = getelementptr inbounds i32, i32 addrspace(1)* %0, i64 0
+  store i32 39, i32 addrspace(1)* %add.ptr, align 4
+  ret void
+}
+
+!igc.functions = !{!0}
+
+!0 = !{void (i1, i32 addrspace(1)*, i32 addrspace(1)*)* @test, !1}
+!1 = !{!2}
+!2 = !{!"function_type", i32 0}