[LLVM16] Adding support for OpaquePointers in JointMatrixFuncsResolutionPass

This PR adds introduces handling of opaque pointers in LLVM 16.

While for the majority of the JointMatrix code such transition was relatively easy,
then for some specific cases we needed to put more effort.

e.g When argument to the function was provided as an opaque pointer, but it was actually TET/Matrix Type
Then we need to traverse up in order to figure out it's actual type, so we can resolve it correctly.

Such scenario occured when processing access chain.

Author: bokrzesi

IGC/Compiler/Optimizer/OpenCLPasses/JointMatrixFuncsResolutionPass/JointMatrixFuncsResolutionPass.cpp

@@ -738,6 +738,12 @@ static bool isSupprtedLargeSlice(const JointMatrixTypeDescription *desc, bool us
     return false;
 }
 
+bool JointMatrixFuncsResolutionPass::ValidateIntegerBitWidth(
+    unsigned int bitWidth) {
+  bool result = bitWidth == 8 || bitWidth == 16 || bitWidth == 32;
+  return result;
+}
+
 // TODO: Currently this function doesn't take into account large slices, when reporting
 // supported parameters. This should be fixed.
 bool JointMatrixFuncsResolutionPass::ValidateLoadStore
@@ -1023,12 +1029,9 @@ bool JointMatrixFuncsResolutionPass::parseMatrixTypeNameLegacy(const Type *opaqu
     offset += 1; /* Skip type specifier, [f|i] */
     outDescription->bitWidth = parseNumber(name, &offset);
 
-    bool supportedBitWidth =
-        (outDescription->bitWidth == 8 ||
-         outDescription->bitWidth == 16 ||
-         outDescription->bitWidth == 32);
-    IGC_ASSERT_MESSAGE(supportedBitWidth,
-                       "Unexpected matrix element size.");
+    bool isBitWidthSupported =
+        ValidateIntegerBitWidth(outDescription->bitWidth);
+    IGC_ASSERT_MESSAGE(isBitWidthSupported, "Unexpected matrix element size.");
 
     return true;
 }
@@ -1123,12 +1126,9 @@ bool IGC::JointMatrixFuncsResolutionPass::ParseMatrixTypeNameExtTypeDetails(Type
     if (typeParam->isIntegerTy()) {
       outDescription->bitWidth = typeParam->getIntegerBitWidth();
 
-      if (outDescription->bitWidth != 8 &&
-          outDescription->bitWidth != 16 &&
-          outDescription->bitWidth != 32)
-      {
-        std::string msg = "Unexpected Matrix integer size: '"
-          + std::to_string(outDescription->bitWidth) + "'. Only integers of size 8/16/32 are allowed.";
+      if (!ValidateIntegerBitWidth(outDescription->bitWidth)) {
+        std::string msg = "Unexpected Matrix integer size: '" +
+                          std::to_string(outDescription->bitWidth) + "'.";
         LLVM_DEBUG(dbgs() << msg << "\n");
         m_Ctx->EmitError(msg.c_str(), nullptr);
         return false;
@@ -1377,11 +1377,77 @@ static bool isAccumulator32x32(const JointMatrixTypeDescription &desc) {
     return (desc.layout == LayoutRowMajor && desc.rows == 32 && desc.columns == 32);
 }
 
+#if LLVM_VERSION_MAJOR >= 16
+// When we alloca target extension type, later it is "ptr".
+// We need to figure out the type of "ptr" by traversing up.
+// Example:
+// %0 = alloca target("spirv.CooperativeMatrixKHR", i16, 3, 8, 16, 0)
+// %ptr = call spir_func ptr
+// @_Z19__spirv_AccessChainPU3AS4PU3AS143__spirv_CooperativeMatrixKHR(ptr %0,
+// i64 4)
+Type *JointMatrixFuncsResolutionPass::TryFindTargetExtensionTypeOfOpaquePtr(
+    Value *V) {
+  if (!V)
+    return nullptr;
+
+  for (auto &use : V->uses()) {
+    if (auto *ai = dyn_cast<AllocaInst>(use)) {
+      auto aiTy = ai->getAllocatedType();
+      if (IGCLLVM::isTargetExtTy(aiTy))
+        return aiTy;
+    } else if (auto *ci = dyn_cast<CallInst>(use)) {
+      auto funcReturnType = ci->getFunction()->getReturnType();
+      if (IGCLLVM::isTargetExtTy(funcReturnType))
+        return funcReturnType;
+    } else if (auto *spaceCast = dyn_cast<AddrSpaceCastInst>(use)) {
+      return TryFindTargetExtensionTypeOfOpaquePtr(
+          spaceCast->getPointerOperand());
+    }
+  }
+
+  return nullptr;
+}
+// When resolving e.g prefetch we need to figure out type of ptr
+// We can do it by traversing up.
+// It is similar to approach TryFindTargetExtensionTypeOfOpaquePtr
+Type *JointMatrixFuncsResolutionPass::TryFindTypeOfOpaquePtr(Value *V) {
+  if (!V)
+    return nullptr;
+
+  for (auto &use : V->uses()) {
+    if (auto *ai = dyn_cast<AllocaInst>(use)) {
+      auto aiTy = ai->getAllocatedType();
+      return aiTy;
+    } else if (auto *ci = dyn_cast<CallInst>(use)) {
+      auto funcReturnType = ci->getFunction()->getReturnType();
+      return funcReturnType;
+    } else if (auto *spaceCast = dyn_cast<AddrSpaceCastInst>(use)) {
+      return TryFindTypeOfOpaquePtr(spaceCast->getPointerOperand());
+    } else if (auto *gep = dyn_cast<GetElementPtrInst>(use)) {
+      return gep->getResultElementType();
+    } else if (auto *bitcast = dyn_cast<BitCastInst>(use)) {
+      if (!IGCLLVM::isOpaquePointerTy(bitcast->getSrcTy()))
+        return bitcast->getSrcTy();
+
+      return TryFindTypeOfOpaquePtr(bitcast->getOperand(0));
+    }
+  }
+
+  return nullptr;
+}
+#endif
+
 Type *JointMatrixFuncsResolutionPass::ResolveType(Type *inputType, JointMatrixTypeDescription *outDesc)
 {
     IGC_ASSERT_EXIT_MESSAGE(inputType && (inputType->isPointerTy() || IGCLLVM::isTargetExtTy(inputType)),
         "Unexpected type in matrix function resolution.");
 
+#if LLVM_VERSION_MAJOR >= 16
+    IGC_ASSERT_EXIT_MESSAGE(
+        !IGCLLVM::isOpaquePointerTy(inputType),
+        "Unexpected opaque pointer. Expected TargetExtensionType instead.");
+#endif
+
     JointMatrixTypeDescription desc;
     bool parseResult = ParseMatrixTypeName(inputType, &desc);
     IGC_ASSERT_EXIT_MESSAGE(parseResult, "Failed to parse matrix type.");
@@ -1484,32 +1550,52 @@ Instruction *JointMatrixFuncsResolutionPass::ResolvePrefetch(CallInst *CI)
     desc.columns = (unsigned)constIntValue(numColsVal);
 
     // Pointer type resolution
+    Type *ptrElemType = nullptr;
+
+#if LLVM_VERSION_MAJOR >= 16
+    if (IGCLLVM::isOpaquePointerTy(ptrVal->getType()))
+      ptrElemType = TryFindTypeOfOpaquePtr(ptrVal);
+    else
+#endif
     {
-        PointerType *ptrType = cast<PointerType>(ptrVal->getType());
-        Type *ptrElemType = IGCLLVM::getNonOpaquePtrEltTy(ptrType);
-
-        if (StructType *structTy = dyn_cast<StructType>(ptrElemType)) {
-            if (structTy->getNumElements() == 1) {
-                ptrElemType = structTy->getElementType(0);
-                // we assume that only custom floating point types are wrapped into structs
-                desc.isFloating = true;
-            }
-        }
+      // To be removed after switch to LLVM 16 + full opaque pointers enablement
+      PointerType *ptrType = cast<PointerType>(ptrVal->getType());
+      ptrElemType = IGCLLVM::getNonOpaquePtrEltTy(ptrType);
+    }
 
-        if (ptrElemType->isHalfTy()) {
-            desc.bitWidth = 16;
-            desc.isFloating = true;
-        } else if (ptrElemType->isFloatTy()) {
-            desc.bitWidth = 32;
-            desc.isFloating = true;
-        } else if (ptrElemType->isDoubleTy()) {
-            desc.bitWidth = 64;
-            desc.isFloating = true;
-        } else if (ptrElemType->isIntegerTy()) {
-            desc.bitWidth = cast<IntegerType>(ptrElemType)->getBitWidth();
-        } else {
-            m_Ctx->EmitError("Failed to resolve matrix prefetch pointer type", ptrVal);
-        }
+    IGC_ASSERT_MESSAGE(ptrElemType, "Pointer type not found");
+
+    if (StructType *structTy = dyn_cast<StructType>(ptrElemType)) {
+      if (structTy->getNumElements() == 1) {
+        ptrElemType = structTy->getElementType(0);
+        // we assume that only custom floating point types are wrapped into
+        // structs
+        desc.isFloating = true;
+      }
+    }
+
+    if (ptrElemType->isHalfTy()) {
+      desc.bitWidth = 16;
+      desc.isFloating = true;
+    } else if (ptrElemType->isFloatTy()) {
+      desc.bitWidth = 32;
+      desc.isFloating = true;
+    } else if (ptrElemType->isDoubleTy()) {
+      desc.bitWidth = 64;
+      desc.isFloating = true;
+    } else if (ptrElemType->isIntegerTy()) {
+      desc.bitWidth = cast<IntegerType>(ptrElemType)->getBitWidth();
+
+      if (!ValidateIntegerBitWidth(desc.bitWidth)) {
+        std::string msg = "Unexpected Matrix integer size: '" +
+                          std::to_string(desc.bitWidth) + "'.";
+        LLVM_DEBUG(dbgs() << msg << "\n");
+        m_Ctx->EmitError(msg.c_str(), ptrVal);
+        return nullptr;
+      }
+    } else {
+      m_Ctx->EmitError("Failed to resolve matrix prefetch pointer type",
+                       ptrVal);
     }
 
     LLVMContext &ctx = CI->getContext();
@@ -2268,13 +2354,32 @@ bool JointMatrixFuncsResolutionPass::preprocessAccessChain(Function *F) {
             continue;
         }
 
+#if LLVM_VERSION_MAJOR < 16
         if(IGCLLVM::isOpaquePointerTy(CI->getArgOperand(0)->getType()))
             continue;
+#endif
 
         LLVM_DEBUG(dbgs() << " - PREPROCESS ACCESS CHAIN: " << *CI << "\n");
 
-        Type *chainBaseTy =
-            IGCLLVM::getNonOpaquePtrEltTy(CI->getArgOperand(0)->getType());
+        Type *chainBaseTy = nullptr;
+        auto operand0 = CI->getArgOperand(0);
+
+#if LLVM_VERSION_MAJOR >= 16
+        if (IGCLLVM::isOpaquePointerTy(operand0->getType())) {
+          chainBaseTy = TryFindTargetExtensionTypeOfOpaquePtr(operand0);
+          IGC_ASSERT_MESSAGE(chainBaseTy,
+                             "__spirv_AccessChain call 1st argument must be "
+                             "pointer to target extension type.");
+        } else
+#endif
+        {
+          // to be removed after we switch to LLVM 16 with opaque pointers by
+          // default
+          chainBaseTy = IGCLLVM::getNonOpaquePtrEltTy(operand0->getType());
+          IGC_ASSERT_MESSAGE(
+              chainBaseTy, "__spirv_AccessChain call 1st argument is invalid");
+        }
+
         IGC_ASSERT_MESSAGE(isMatrixType(chainBaseTy),
                            "__spirv_AccessChain call 1st argument must be cooperative matrix");
         Value *ptrToMatrix = CI->getArgOperand(0);
@@ -2755,8 +2860,10 @@ void JointMatrixFuncsResolutionPass::visitCallInst(CallInst& CI)
 
     StringRef funcName = func->getName();
 
+#if LLVM_VERSION_MAJOR < 16
     if(IGCLLVM::isOpaquePointerTy(CI.getType()) || isAnyOperand(CI, IGCLLVM::isOpaquePointerTy))
         return;
+#endif
 
     /* Resolve calls to JointMatrix BIs that haven't been resolved yet. In
      * future when returning and passing matrices by argument is

IGC/Compiler/Optimizer/OpenCLPasses/JointMatrixFuncsResolutionPass/JointMatrixFuncsResolutionPass.h

@@ -87,6 +87,8 @@ namespace IGC
           bool IsJointMatrix,
           JointMatrixTypeDescription* outDescription);
 #if LLVM_VERSION_MAJOR >= 16
+        llvm::Type *TryFindTargetExtensionTypeOfOpaquePtr(llvm::Value *V);
+        llvm::Type *TryFindTypeOfOpaquePtr(llvm::Value *V);
         bool ParseMatrixTypeNameExtTypeDetails(llvm::Type* opaqueType, bool IsJointMatrix, IGC::JointMatrixTypeDescription* outDescription);
 #endif
 
@@ -122,6 +124,7 @@ namespace IGC
                                       const JointMatrixTypeDescription *desc,
                                       const std::string& prefix);
 
+        bool ValidateIntegerBitWidth(unsigned int width);
         bool ValidateLoadStore
             (bool isLoad, unsigned operationLayout, const JointMatrixTypeDescription *desc, llvm::Value *ctx);
 

IGC/Compiler/tests/EmitVISAPass/vectorizer-vector-emission-exp2.ll

@@ -1,5 +1,5 @@
 ; UNSUPPORTED: system-windows
-; REQUIRES: regkeys
+; REQUIRES: pvc-supported, regkeys
 
 ; RUN: igc_opt -S -dce -platformpvc -rev-id B -has-emulated-64-bit-insts -igc-emit-visa --regkey=DumpVISAASMToConsole=1 -simd-mode 16 < %s | FileCheck %s
 

IGC/Compiler/tests/EmitVISAPass/vectorizer-vector-emission-fadd.ll

@@ -1,18 +1,18 @@
-; REQUIRES: regkeys
+; REQUIRES: pvc-supported, regkeys
 
 ; RUN: igc_opt -S -dce -platformpvc -rev-id B -has-emulated-64-bit-insts -igc-emit-visa --regkey=DumpVISAASMToConsole=1 -simd-mode 16 < %s | FileCheck %s
 
-; CHECK: .decl tmp15 v_type=G type=f num_elts=128 align=wordx32
-; CHECK: .decl tmp16 v_type=G type=f num_elts=8 align=dword
+; CHECK: .decl vectorized_phi v_type=G type=f num_elts=128 align=wordx32
+; CHECK: .decl vector v_type=G type=f num_elts=8 align=dword
 
-; CHECK: add (M1, 16) tmp15(0,0)<1> tmp16(0,0)<0;1,0> tmp15(0,0)<1;1,0>
-; CHECK: add (M1, 16) tmp15(1,0)<1> tmp16(0,1)<0;1,0> tmp15(1,0)<1;1,0>
-; CHECK: add (M1, 16) tmp15(2,0)<1> tmp16(0,2)<0;1,0> tmp15(2,0)<1;1,0>
-; CHECK: add (M1, 16) tmp15(3,0)<1> tmp16(0,3)<0;1,0> tmp15(3,0)<1;1,0>
-; CHECK: add (M1, 16) tmp15(4,0)<1> tmp16(0,4)<0;1,0> tmp15(4,0)<1;1,0>
-; CHECK: add (M1, 16) tmp15(5,0)<1> tmp16(0,5)<0;1,0> tmp15(5,0)<1;1,0>
-; CHECK: add (M1, 16) tmp15(6,0)<1> tmp16(0,6)<0;1,0> tmp15(6,0)<1;1,0>
-; CHECK: add (M1, 16) tmp15(7,0)<1> tmp16(0,7)<0;1,0> tmp15(7,0)<1;1,0>
+; CHECK: add (M1, 16) vectorized_phi(0,0)<1> vector(0,0)<0;1,0> vectorized_phi(0,0)<1;1,0>
+; CHECK: add (M1, 16) vectorized_phi(1,0)<1> vector(0,1)<0;1,0> vectorized_phi(1,0)<1;1,0>
+; CHECK: add (M1, 16) vectorized_phi(2,0)<1> vector(0,2)<0;1,0> vectorized_phi(2,0)<1;1,0>
+; CHECK: add (M1, 16) vectorized_phi(3,0)<1> vector(0,3)<0;1,0> vectorized_phi(3,0)<1;1,0>
+; CHECK: add (M1, 16) vectorized_phi(4,0)<1> vector(0,4)<0;1,0> vectorized_phi(4,0)<1;1,0>
+; CHECK: add (M1, 16) vectorized_phi(5,0)<1> vector(0,5)<0;1,0> vectorized_phi(5,0)<1;1,0>
+; CHECK: add (M1, 16) vectorized_phi(6,0)<1> vector(0,6)<0;1,0> vectorized_phi(6,0)<1;1,0>
+; CHECK: add (M1, 16) vectorized_phi(7,0)<1> vector(0,7)<0;1,0> vectorized_phi(7,0)<1;1,0>
 
 define spir_kernel void @blam(half addrspace(1)* %arg, half addrspace(1)* %arg1, half addrspace(1)* %arg2, float %arg3, i8 addrspace(1)* %arg4, float addrspace(1)* %arg5, <8 x i32> %arg6, <8 x i32> %arg7, i8* %arg8, i32 %arg9, i32 %arg10, i32 %arg11, i32 %arg12, i32 %arg13) {
 bb: