Use getShuffleMaskForBitcode() from IGCLLVM wrapper

Rationale: this is llvm-agnostic implementation for obtaining
shuffle mask as llvm::Constant*.

Author: MaciejKalinski

IGC/Compiler/LegalizationPass.cpp

@@ -22,6 +22,7 @@ SPDX-License-Identifier: MIT
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvmWrapper/IR/InstrTypes.h"
+#include "llvmWrapper/IR/Instructions.h"
 #include "llvmWrapper/Transforms/Utils/Cloning.h"
 #include "common/LLVMWarningsPop.hpp"
 #include "GenISAIntrinsics/GenIntrinsicInst.h"
@@ -1652,11 +1653,7 @@ void Legalization::visitShuffleVectorInst(ShuffleVectorInst& I)
     Value* src0 = I.getOperand(0);
     Value* src1 = I.getOperand(1);
     // The mask is guaranteed by the LLVM IR spec to be constant
-#if LLVM_VERSION_MAJOR < 11
-    Constant* mask = cast<Constant>(I.getOperand(2));
-#else
-    Constant* mask = I.getShuffleMaskForBitcode();
-#endif
+    Constant* mask = IGCLLVM::getShuffleMaskForBitcode(&I);
     // The two inputs are guaranteed to be of the same type
     IGCLLVM::FixedVectorType* inType = cast<IGCLLVM::FixedVectorType>(src0->getType());
     int inCount = int_cast<int>(inType->getNumElements());

IGC/Compiler/Legalizer/InstLegalChecker.cpp

@@ -12,6 +12,7 @@ SPDX-License-Identifier: MIT
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvmWrapper/IR/Instructions.h"
 #include "common/LLVMWarningsPop.hpp"
 #include "Probe/Assertion.h"
 
@@ -250,13 +251,7 @@ LegalizeAction InstLegalChecker::visitShuffleVectorInst(ShuffleVectorInst& I) {
     if ((Act = TL->getTypeLegalizeAction(I.getOperand(0)->getType())) != Legal)
         return Act;
     // Check the constant mask.
-    return TL->getTypeLegalizeAction(I.
-#if LLVM_VERSION_MAJOR <= 10
-        getMask
-#else
-        getShuffleMaskForBitcode
-#endif
-        ()->getType());
+    return TL->getTypeLegalizeAction(IGCLLVM::getShuffleMaskForBitcode(&I)->getType());
 }
 
 LegalizeAction InstLegalChecker::visitExtractValueInst(ExtractValueInst& I) {

IGC/WrapperLLVM/include/llvmWrapper/IR/Instructions.h

@@ -19,78 +19,78 @@ SPDX-License-Identifier: MIT
 namespace IGCLLVM
 {
 
-    inline llvm::Value* getCalledValue(llvm::CallInst& CI)
-    {
+inline llvm::Value* getCalledValue(llvm::CallInst& CI)
+{
 #if LLVM_VERSION_MAJOR <= 10
-        return CI.getCalledValue();
+    return CI.getCalledValue();
 #else
-        return CI.getCalledOperand();
+    return CI.getCalledOperand();
 #endif
-    }
+}
 
-    inline llvm::Value* getCalledValue(llvm::CallInst* CI)
-    {
+inline llvm::Value* getCalledValue(llvm::CallInst* CI)
+{
 #if LLVM_VERSION_MAJOR <= 10
-        return CI->getCalledValue();
+    return CI->getCalledValue();
 #else
-        return CI->getCalledOperand();
+    return CI->getCalledOperand();
 #endif
-    }
+}
 
-    inline const llvm::Value* getCalledValue(const llvm::CallInst* CI)
-    {
+inline const llvm::Value* getCalledValue(const llvm::CallInst* CI)
+{
 #if LLVM_VERSION_MAJOR <= 10
-        return CI->getCalledValue();
+    return CI->getCalledValue();
 #else
-        return CI->getCalledOperand();
+    return CI->getCalledOperand();
 #endif
-    }
+}
 
-    inline unsigned getNumArgOperands(const llvm::CallInst* CI)
-    {
+inline unsigned getNumArgOperands(const llvm::CallInst* CI)
+{
 #if LLVM_VERSION_MAJOR < 14
-       return CI->getNumArgOperands();
+    return CI->getNumArgOperands();
 #else
-       return CI->arg_size();
+    return CI->arg_size();
 #endif
-    }
+}
 
-    inline unsigned getArgOperandNo(llvm::CallInst &CI, const llvm::Use *U) {
+inline unsigned getArgOperandNo(llvm::CallInst &CI, const llvm::Use *U) {
 #if LLVM_VERSION_MAJOR < 10
-      IGC_ASSERT_MESSAGE(CI.isArgOperand(U), "Arg operand # out of range!");
-      return (unsigned)(U - CI.arg_begin());
+    IGC_ASSERT_MESSAGE(CI.isArgOperand(U), "Arg operand # out of range!");
+    return (unsigned)(U - CI.arg_begin());
 #else
-      return CI.getArgOperandNo(U);
+    return CI.getArgOperandNo(U);
 #endif
-    }
+}
 
-    inline llvm::Constant* getShuffleMaskForBitcode(llvm::ShuffleVectorInst* SVI)
-    {
+inline llvm::Constant* getShuffleMaskForBitcode(llvm::ShuffleVectorInst* SVI)
+{
 #if LLVM_VERSION_MAJOR < 11
-        return SVI->getMask();
+    return SVI->getMask();
 #else
-        return SVI->getShuffleMaskForBitcode();
+    return llvm::ShuffleVectorInst::convertShuffleMaskForBitcode(SVI->getShuffleMask(), SVI->getType());
 #endif
-    }
+}
 
-    inline bool isFreezeInst(llvm::Instruction* I)
-    {
+inline bool isFreezeInst(llvm::Instruction* I)
+{
 #if LLVM_VERSION_MAJOR < 10
-        (void)I;
-        return false;
+    (void)I;
+    return false;
 #else
-        return llvm::isa<llvm::FreezeInst>(I);
+    return llvm::isa<llvm::FreezeInst>(I);
 #endif
-    }
+}
 
-    inline bool isDebugOrPseudoInst(llvm::Instruction& I)
-    {
+inline bool isDebugOrPseudoInst(llvm::Instruction& I)
+{
 #if LLVM_VERSION_MAJOR < 14
-        return llvm::isa<llvm::DbgInfoIntrinsic>(&I);
+    return llvm::isa<llvm::DbgInfoIntrinsic>(&I);
 #else
-        return I.isDebugOrPseudoInst();
+    return I.isDebugOrPseudoInst();
 #endif
-    }
+}
 }
 
 #endif