From a766df8081f6ffaae9a0d028f99ff3faa1313aec Mon Sep 17 00:00:00 2001 From: Naveen Saini Date: Fri, 26 Mar 2021 18:39:15 +0800 Subject: intel-graphics-compiler: upgrade 1.0.6083 -> 1.0.6410 Patches applied from Open PR#171, in order to build with llvm-12. https://github.com/intel/intel-graphics-compiler/pull/171 Error logs: (1) | /build/tmp/work/corei7-64-poky-linux/intel-graphics-compiler/1.0.6410-r0/git/IGC/Compiler/CISACodeGen/VariableReuseAnalysis.hpp:83:56: error: 'unsigned int llvm::VectorType::getNumElements() const' is deprecated: Calling this function via a base VectorType is deprecated. Either call getElementCount() and handle the case where Scalable is true or cast to FixedVectorType. [-Werror=deprecated-declarations] | 83 | NumElts = VTy ? (short)VTy->getNumElements() : 1; Ref:https://github.com/llvm/llvm-project/commit/867de151a52b6d0750485ac1cf9b3bc012ee51fd (2) | /build/tmp/work/corei7-64-poky-linux/intel-graphics-compiler/1.0.6410-r0/git/IGC/common/igc_resourceDimTypes.h:69:23: error: 'const class llvm::Module' has no member named 'getTypeByName' | 69 | return module.getTypeByName(ResourceDimensionTypeName[resourceDimTypeId]); Ref: https://github.com/llvm/llvm-project/commit/fe431683484a3041e024ab2373bb707b1ca8d1cf Update copyright year in headers in IGC Compiler and some format updates. Signed-off-by: Naveen Saini Signed-off-by: Anuj Mittal --- .../igc/files/0001-Fix-build-with-LLVM-12.patch | 2433 ++++++++++++++++++++ .../0002-Review-fixes-for-LLVM-12-phase-1.patch | 318 +++ .../0003-Review-fixes-for-LLVM-12-phase-2.patch | 123 + .../igc/intel-graphics-compiler_1.0.6083.bb | 43 - .../igc/intel-graphics-compiler_1.0.6646.bb | 45 + 5 files changed, 2919 insertions(+), 43 deletions(-) create mode 100644 dynamic-layers/clang-layer/recipes-opencl/igc/files/0001-Fix-build-with-LLVM-12.patch create mode 100644 dynamic-layers/clang-layer/recipes-opencl/igc/files/0002-Review-fixes-for-LLVM-12-phase-1.patch create mode 100644 dynamic-layers/clang-layer/recipes-opencl/igc/files/0003-Review-fixes-for-LLVM-12-phase-2.patch delete mode 100644 dynamic-layers/clang-layer/recipes-opencl/igc/intel-graphics-compiler_1.0.6083.bb create mode 100644 dynamic-layers/clang-layer/recipes-opencl/igc/intel-graphics-compiler_1.0.6646.bb (limited to 'dynamic-layers/clang-layer/recipes-opencl/igc') diff --git a/dynamic-layers/clang-layer/recipes-opencl/igc/files/0001-Fix-build-with-LLVM-12.patch b/dynamic-layers/clang-layer/recipes-opencl/igc/files/0001-Fix-build-with-LLVM-12.patch new file mode 100644 index 00000000..1d2c5767 --- /dev/null +++ b/dynamic-layers/clang-layer/recipes-opencl/igc/files/0001-Fix-build-with-LLVM-12.patch @@ -0,0 +1,2433 @@ +From 869cdb784aa062bd08bd26465bf0b5651e8f112e Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Zolt=C3=A1n=20B=C3=B6sz=C3=B6rm=C3=A9nyi?= +Date: Thu, 25 Feb 2021 10:39:27 +0100 +Subject: [PATCH 1/3] Fix build with LLVM 12 +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Upstream-Status: Pending + +Signed-off-by: Zoltán Böszörményi +Signed-off-by: Naveen Saini +--- + .../LegalizeFunctionSignatures.cpp | 2 +- + IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp | 26 +++++++++----- + IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp | 6 +++- + IGC/Compiler/CISACodeGen/AdvMemOpt.cpp | 4 +++ + IGC/Compiler/CISACodeGen/CShader.cpp | 14 ++++---- + .../CISACodeGen/ConstantCoalescing.cpp | 14 ++++---- + IGC/Compiler/CISACodeGen/DeSSA.cpp | 3 +- + IGC/Compiler/CISACodeGen/EmitVISAPass.cpp | 35 +++++++++--------- + IGC/Compiler/CISACodeGen/Emu64OpsPass.cpp | 4 +-- + IGC/Compiler/CISACodeGen/GenIRLowering.cpp | 4 +-- + .../CISACodeGen/GenSimplification.cpp | 5 +-- + .../CISACodeGen/GeometryShaderLowering.cpp | 3 +- + IGC/Compiler/CISACodeGen/LdShrink.cpp | 10 ++++-- + .../CISACodeGen/LowerGEPForPrivMem.cpp | 8 ++--- + IGC/Compiler/CISACodeGen/MemOpt.cpp | 8 ++--- + IGC/Compiler/CISACodeGen/MemOpt2.cpp | 5 +-- + .../CISACodeGen/OpenCLKernelCodeGen.cpp | 2 +- + IGC/Compiler/CISACodeGen/PatternMatchPass.cpp | 4 +-- + IGC/Compiler/CISACodeGen/PushAnalysis.cpp | 4 +-- + .../CISACodeGen/RegisterEstimator.cpp | 3 +- + .../CISACodeGen/RegisterPressureEstimate.hpp | 3 +- + IGC/Compiler/CISACodeGen/SLMConstProp.cpp | 3 +- + .../CISACodeGen/ScalarizerCodeGen.cpp | 4 +-- + IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp | 4 +++ + .../CISACodeGen/Simd32Profitability.cpp | 11 ++++-- + IGC/Compiler/CISACodeGen/SimplifyConstant.cpp | 12 +++---- + IGC/Compiler/CISACodeGen/TypeDemote.cpp | 3 +- + .../CISACodeGen/VariableReuseAnalysis.cpp | 5 +-- + .../CISACodeGen/VariableReuseAnalysis.hpp | 3 +- + IGC/Compiler/CISACodeGen/VectorPreProcess.cpp | 24 ++++++------- + IGC/Compiler/CISACodeGen/VectorProcess.cpp | 4 +-- + IGC/Compiler/CISACodeGen/helper.cpp | 10 +++--- + IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp | 15 ++++++-- + IGC/Compiler/CustomSafeOptPass.cpp | 26 +++++++------- + IGC/Compiler/DebugInfo/ScalarVISAModule.cpp | 3 +- + IGC/Compiler/GenTTI.cpp | 8 ++++- + IGC/Compiler/GenUpdateCB.cpp | 3 +- + IGC/Compiler/HandleFRemInstructions.cpp | 3 +- + IGC/Compiler/HandleLoadStoreInstructions.cpp | 4 +-- + IGC/Compiler/LegalizationPass.cpp | 28 +++++++-------- + IGC/Compiler/Legalizer/InstPromoter.cpp | 11 ++++-- + IGC/Compiler/Legalizer/InstScalarizer.cpp | 6 ++-- + .../Legalizer/PeepholeTypeLegalizer.cpp | 6 ++-- + IGC/Compiler/Legalizer/TypeLegalizer.cpp | 3 +- + IGC/Compiler/Legalizer/TypeLegalizer.h | 3 +- + IGC/Compiler/LowPrecisionOptPass.cpp | 2 +- + .../AddressSpaceAliasAnalysis.cpp | 9 ++--- + .../AggregateArguments/AggregateArguments.cpp | 3 +- + .../CorrectlyRoundedDivSqrt.cpp | 3 +- + .../DeviceEnqueueFuncs/TransformBlocks.cpp | 6 +++- + .../Optimizer/OpenCLPasses/KernelArgs.cpp | 3 +- + .../OpenCLPrintf/OpenCLPrintfResolution.cpp | 4 +-- + .../PrivateMemory/PrivateMemoryResolution.cpp | 11 ++++-- + .../ReplaceUnsupportedIntrinsics.cpp | 4 +-- + .../OpenCLPasses/WIFuncs/WIFuncResolution.cpp | 4 +++ + .../Optimizer/PreCompiledFuncImport.cpp | 4 +-- + IGC/Compiler/Optimizer/Scalarizer.cpp | 36 +++++++++---------- + IGC/Compiler/Optimizer/ValueTracker.cpp | 2 +- + IGC/Compiler/VerificationPass.cpp | 2 +- + IGC/DebugInfo/DebugInfoUtils.hpp | 4 +++ + IGC/DebugInfo/DwarfDebug.cpp | 8 +++++ + IGC/GenISAIntrinsics/GenIntrinsics.cpp | 6 ++-- + .../BuiltinsFrontendDefinitions.hpp | 2 +- + .../include/llvmWrapper/Support/TypeSize.h | 8 ++++- + .../include/llvmWrapper/Transforms/Scalar.h | 4 +-- + IGC/common/igc_resourceDimTypes.h | 5 +++ + 66 files changed, 303 insertions(+), 196 deletions(-) + +diff --git a/IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp b/IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp +index 4046b4a6..8ed36089 100644 +--- a/IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp ++++ b/IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp +@@ -156,7 +156,7 @@ inline Type* LegalizedIntVectorType(Module& M, const Type* const oldTy) + else if (size <= 64) newSize = 64; + else IGC_ASSERT_MESSAGE(0, "Currently don't support upscaling int sizes > 64 bits"); + +- return IGCLLVM::FixedVectorType::get(IntegerType::get(M.getContext(), newSize), (unsigned)cast(oldTy)->getNumElements()); ++ return IGCLLVM::FixedVectorType::get(IntegerType::get(M.getContext(), newSize), (unsigned)cast(oldTy)->getNumElements()); + } + + void LegalizeFunctionSignatures::FixFunctionSignatures() +diff --git a/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp b/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp +index 41d1f2ea..725a1512 100644 +--- a/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp ++++ b/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp +@@ -1576,7 +1576,11 @@ void SPIRVToLLVMDbgTran::transDbgInfo(SPIRVValue *SV, Value *V) { + Line->getColumn(), scope, iat); + + if(scope && !isa(scope)) ++#if LLVM_VERSION_MAJOR >= 12 ++ I->setDebugLoc(DILocation::get(scope->getContext(), Line->getLine(), Line->getColumn(), ++#else + I->setDebugLoc(DebugLoc::get(Line->getLine(), Line->getColumn(), ++#endif + scope, iat)); + } + } +@@ -1925,7 +1929,11 @@ SPIRVToLLVM::transType(SPIRVType *T) { + auto name = isSubgroupAvcINTELTypeOpCode(OC) ? + OCLSubgroupINTELTypeOpCodeMap::rmap(OC) : + BuiltinOpaqueGenericTypeOpCodeMap::rmap(OC); ++#if LLVM_VERSION_MAJOR >= 12 ++ auto *pST = llvm::StructType::getTypeByName(M->getContext(), name); ++#else + auto *pST = M->getTypeByName(name); ++#endif + pST = pST ? pST : StructType::create(*Context, name); + + return mapType(T, PointerType::get(pST, getOCLOpaqueTypeAddrSpace(OC))); +@@ -2403,7 +2411,7 @@ Value *SPIRVToLLVM::promoteBool(Value *pVal, BasicBlock *BB) + + auto *PromoType = isa(pVal->getType()) ? + cast(IGCLLVM::FixedVectorType::get(Type::getInt8Ty(pVal->getContext()), +- (unsigned)cast(pVal->getType())->getNumElements())) : ++ (unsigned)cast(pVal->getType())->getNumElements())) : + Type::getInt8Ty(pVal->getContext()); + + if (auto *C = dyn_cast(pVal)) +@@ -2445,7 +2453,7 @@ Value *SPIRVToLLVM::truncBool(Value *pVal, BasicBlock *BB) + + auto *TruncType = isa(pVal->getType()) ? + cast(IGCLLVM::FixedVectorType::get(Type::getInt1Ty(pVal->getContext()), +- (unsigned)cast(pVal->getType())->getNumElements())) : ++ (unsigned)cast(pVal->getType())->getNumElements())) : + Type::getInt1Ty(pVal->getContext()); + + if (auto *C = dyn_cast(pVal)) +@@ -2491,7 +2499,7 @@ Type *SPIRVToLLVM::truncBoolType(SPIRVType *SPVType, Type *LLType) + + return isa(LLType) ? + cast(IGCLLVM::FixedVectorType::get(Type::getInt1Ty(LLType->getContext()), +- (unsigned)cast(LLType)->getNumElements())) : ++ (unsigned)cast(LLType)->getNumElements())) : + Type::getInt1Ty(LLType->getContext()); + } + +@@ -2648,7 +2656,7 @@ SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F, + { + if(CV[i]->getType()->isVectorTy()) + { +- for(uint32_t j = 0; j < cast(CV[i]->getType())->getNumElements(); j++) ++ for(uint32_t j = 0; j < cast(CV[i]->getType())->getNumElements(); j++) + { + Value *v = ExtractElementInst::Create( CV[i],ConstantInt::get( *Context,APInt( 32,j ) ),BCC->getName(),BB ); + elm1 = CreateCompositeConstruct( elm1,v,pos++ ); +@@ -3336,7 +3344,7 @@ SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F, + auto Vector = transValue(BI->getOperand(0), F, BB); + auto Scalar = transValue(BI->getOperand(1), F, BB); + +- auto VecType = cast(Vector->getType()); ++ auto VecType = cast(Vector->getType()); + auto Undef = UndefValue::get(VecType); + + auto ScalarVec = InsertElementInst::Create(Undef, Scalar, +@@ -3361,7 +3369,7 @@ SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F, + a->getType()->getScalarSizeInBits() - 1); + auto *ShiftOp = isa(a->getType()) ? + ConstantVector::getSplat( +- IGCLLVM::getElementCount((unsigned)cast(a->getType())->getNumElements()), ShiftAmt) : ++ IGCLLVM::getElementCount((unsigned)cast(a->getType())->getNumElements()), ShiftAmt) : + ShiftAmt; + + // OCL C: +@@ -3705,15 +3713,15 @@ SPIRVToLLVM::transSPIRVBuiltinFromInst(SPIRVInstruction *BI, BasicBlock *BB) { + "", + BB); + } +- else if (cast(coordType)->getNumElements() != 4) ++ else if (cast(coordType)->getNumElements() != 4) + { + Value *undef = UndefValue::get(coordType); + + SmallVector shuffleIdx; +- for (unsigned i = 0; i < cast(coordType)->getNumElements(); i++) ++ for (unsigned i = 0; i < cast(coordType)->getNumElements(); i++) + shuffleIdx.push_back(ConstantInt::get(Type::getInt32Ty(*Context), i)); + +- for (uint64_t i = (unsigned)cast(coordType)->getNumElements(); i < 4; i++) ++ for (uint64_t i = (unsigned)cast(coordType)->getNumElements(); i < 4; i++) + shuffleIdx.push_back(ConstantInt::get(Type::getInt32Ty(*Context), 0)); + + imageCoordinateWiden = new ShuffleVectorInst( +diff --git a/IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp b/IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp +index 57821556..91b4623c 100644 +--- a/IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp ++++ b/IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp +@@ -93,7 +93,11 @@ saveLLVMModule(Module *M, const std::string &OutputFile) { + PointerType* + getOrCreateOpaquePtrType(Module *M, const std::string &Name, + unsigned AddrSpace) { ++#if LLVM_VERSION_MAJOR >= 12 ++ auto OpaqueType = llvm::StructType::getTypeByName(M->getContext(), Name); ++#else + auto OpaqueType = M->getTypeByName(Name); ++#endif + if (!OpaqueType) + OpaqueType = StructType::create(M->getContext(), Name); + return PointerType::get(OpaqueType, AddrSpace); +@@ -159,7 +163,7 @@ std::string recursive_mangle(const Type* pType) + return "i" + utostr(pType->getIntegerBitWidth()); + case IGCLLVM::VectorTyID: + { +- unsigned vecLen = (unsigned)cast(pType)->getNumElements(); ++ unsigned vecLen = (unsigned)cast(pType)->getNumElements(); + Type* pEltType = cast(pType)->getElementType(); + return "v" + utostr(vecLen) + recursive_mangle(pEltType); + } +diff --git a/IGC/Compiler/CISACodeGen/AdvMemOpt.cpp b/IGC/Compiler/CISACodeGen/AdvMemOpt.cpp +index 81acc6ce..fc45a510 100644 +--- a/IGC/Compiler/CISACodeGen/AdvMemOpt.cpp ++++ b/IGC/Compiler/CISACodeGen/AdvMemOpt.cpp +@@ -134,7 +134,11 @@ bool AdvMemOpt::runOnFunction(Function& F) { + for (auto I = LI->begin(), E = LI->end(); I != E; ++I) + for (auto DFI = df_begin(*I), DFE = df_end(*I); DFI != DFE; ++DFI) { + Loop* L = *DFI; ++#if LLVM_VERSION_MAJOR >= 12 ++ if (L->isInnermost()) ++#else + if (L->empty()) ++#endif + InnermostLoops.push_back(L); + } + +diff --git a/IGC/Compiler/CISACodeGen/CShader.cpp b/IGC/Compiler/CISACodeGen/CShader.cpp +index e3cb8153..ebc99615 100644 +--- a/IGC/Compiler/CISACodeGen/CShader.cpp ++++ b/IGC/Compiler/CISACodeGen/CShader.cpp +@@ -430,7 +430,7 @@ void CShader::CreateAliasVars() + continue; + + Type* Ty = V->getType(); +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + Type* BTy = VTy ? VTy->getElementType() : Ty; + int nelts = (VTy ? (int)VTy->getNumElements() : 1); + +@@ -961,7 +961,7 @@ bool CShader::InsideDivergentCF(llvm::Instruction* inst) + uint CShader::GetNbVectorElementAndMask(llvm::Value* val, uint32_t& mask) + { + llvm::Type* type = val->getType(); +- uint nbElement = int_cast(cast(type)->getNumElements()); ++ uint nbElement = int_cast(cast(type)->getNumElements()); + mask = 0; + // we don't process vector bigger than 31 elements as the mask has only 32bits + // If we want to support longer vectors we need to extend the mask size +@@ -1166,7 +1166,7 @@ uint32_t CShader::GetExtractMask(llvm::Value* vecVal) + { + return it->second; + } +- const unsigned int numChannels = vecVal->getType()->isVectorTy() ? (unsigned)cast(vecVal->getType())->getNumElements() : 1; ++ const unsigned int numChannels = vecVal->getType()->isVectorTy() ? (unsigned)cast(vecVal->getType())->getNumElements() : 1; + IGC_ASSERT_MESSAGE(numChannels <= 32, "Mask has 32 bits maximally!"); + return (1ULL << numChannels) - 1; + } +@@ -1174,7 +1174,7 @@ uint32_t CShader::GetExtractMask(llvm::Value* vecVal) + uint16_t CShader::AdjustExtractIndex(llvm::Value* vecVal, uint16_t index) + { + uint16_t result = index; +- if (cast(vecVal->getType())->getNumElements() < 32) ++ if (cast(vecVal->getType())->getNumElements() < 32) + { + uint32_t mask = GetExtractMask(vecVal); + for (uint i = 0; i < index; ++i) +@@ -1591,7 +1591,7 @@ auto sizeToSIMDMode = [](uint32_t size) + + CVariable* CShader::GetConstant(llvm::Constant* C, CVariable* dstVar) + { +- llvm::VectorType* VTy = llvm::dyn_cast(C->getType()); ++ IGCLLVM::FixedVectorType* VTy = llvm::dyn_cast(C->getType()); + if (C && VTy) + { // Vector constant + llvm::Type* eTy = VTy->getElementType(); +@@ -1816,7 +1816,7 @@ uint32_t CShader::GetNumElts(llvm::Type* type, bool isUniform) + { + IGC_ASSERT(type->getContainedType(0)->isIntegerTy() || type->getContainedType(0)->isFloatingPointTy()); + +- auto VT = cast(type); ++ auto VT = cast(type); + numElts *= (uint16_t)VT->getNumElements(); + } + return numElts; +@@ -2516,7 +2516,7 @@ CVariable* CShader::GetSymbol(llvm::Value* value, bool fromConstantPool) + if (isVecType) + { + // Map the entire vector value to the CVar +- unsigned numElements = (unsigned)cast(value->getType())->getNumElements(); ++ unsigned numElements = (unsigned)cast(value->getType())->getNumElements(); + var = GetNewVariable(numElements, ISA_TYPE_UQ, (GetContext()->platform.getGRFSize() == 64) ? EALIGN_32WORD : EALIGN_HWORD, true, 1, valName); + symbolMapping.insert(std::pair(value, var)); + +diff --git a/IGC/Compiler/CISACodeGen/ConstantCoalescing.cpp b/IGC/Compiler/CISACodeGen/ConstantCoalescing.cpp +index 1efe116f..47b7c6c0 100644 +--- a/IGC/Compiler/CISACodeGen/ConstantCoalescing.cpp ++++ b/IGC/Compiler/CISACodeGen/ConstantCoalescing.cpp +@@ -224,7 +224,7 @@ static void checkInsertExtractMatch(InsertElementInst* insertInst, Value* base, + + static bool canReplaceInsert(InsertElementInst* insertElt) + { +- VectorType* VTy = cast(insertElt->getOperand(0)->getType()); ++ IGCLLVM::FixedVectorType* VTy = cast(insertElt->getOperand(0)->getType()); + ConstantInt* index = dyn_cast(insertElt->getOperand(2)); + if (!index || index->getZExtValue() != VTy->getNumElements() - 1) + { +@@ -312,7 +312,7 @@ void ConstantCoalescing::VectorizePrep(llvm::BasicBlock* bb) + { + if (load->getType()->isVectorTy() && wiAns->isUniform(load)) + { +- srcNElts = (uint32_t)cast(load->getType())->getNumElements(); ++ srcNElts = (uint32_t)cast(load->getType())->getNumElements(); + DenseMap extractElementMap; + + for (auto iter = load->user_begin(); iter != load->user_end(); iter++) +@@ -396,7 +396,7 @@ bool ConstantCoalescing::isProfitableLoad( + (isa(I) && wiAns->isUniform(I)) ? + 16 : 4; + +- if (cast(LoadTy)->getNumElements() > MaxVectorInput) ++ if (cast(LoadTy)->getNumElements() > MaxVectorInput) + return false; + + MaxEltPlus = CheckVectorElementUses(I); +@@ -1787,7 +1787,7 @@ void ConstantCoalescing::AdjustChunk(BufChunk* cov_chunk, uint start_adj, uint s + WIAnalysis::WIDependancy loadDep = wiAns->whichDepend(cov_chunk->chunkIO); + irBuilder->SetInsertPoint(cov_chunk->chunkIO->getNextNode()); + Value* vec = UndefValue::get(originalType); +- for (unsigned i = 0; i < cast(originalType)->getNumElements(); i++) ++ for (unsigned i = 0; i < cast(originalType)->getNumElements(); i++) + { + Value* channel = irBuilder->CreateExtractElement( + cov_chunk->chunkIO, irBuilder->getInt32(i + start_adj)); +@@ -1851,7 +1851,7 @@ void ConstantCoalescing::MoveExtracts(BufChunk* cov_chunk, Instruction* load, ui + irBuilder->SetInsertPoint(load->getNextNode()); + Type* vecType = load->getType(); + Value* vec = UndefValue::get(vecType); +- for (unsigned i = 0; i < cast(vecType)->getNumElements(); i++) ++ for (unsigned i = 0; i < cast(vecType)->getNumElements(); i++) + { + Value* channel = irBuilder->CreateExtractElement( + cov_chunk->chunkIO, irBuilder->getInt32(i + start_adj)); +@@ -1915,7 +1915,7 @@ void ConstantCoalescing::EnlargeChunk(BufChunk* cov_chunk, uint size_adj) + WIAnalysis::WIDependancy loadDep = wiAns->whichDepend(cov_chunk->chunkIO); + irBuilder->SetInsertPoint(cov_chunk->chunkIO->getNextNode()); + Value* vec = UndefValue::get(originalType); +- for (unsigned i = 0; i < cast(originalType)->getNumElements(); i++) ++ for (unsigned i = 0; i < cast(originalType)->getNumElements(); i++) + { + Value* channel = irBuilder->CreateExtractElement( + cov_chunk->chunkIO, irBuilder->getInt32(i)); +@@ -2343,7 +2343,7 @@ void ConstantCoalescing::ReplaceLoadWithSamplerLoad( + if (dstTy->isVectorTy()) + { + result = UndefValue::get(dstTy); +- for (uint i = 0; i < cast(dstTy)->getNumElements(); i++) ++ for (uint i = 0; i < cast(dstTy)->getNumElements(); i++) + { + Value* tmpData = ExtractFromSamplerData(cast(dstTy)->getElementType(), i); + result = irBuilder->CreateInsertElement(result, tmpData, irBuilder->getInt32(i)); +diff --git a/IGC/Compiler/CISACodeGen/DeSSA.cpp b/IGC/Compiler/CISACodeGen/DeSSA.cpp +index f540dc11..6fab0246 100644 +--- a/IGC/Compiler/CISACodeGen/DeSSA.cpp ++++ b/IGC/Compiler/CISACodeGen/DeSSA.cpp +@@ -83,6 +83,7 @@ IN THE SOFTWARE. + #include "Compiler/IGCPassSupport.h" + #include "common/LLVMWarningsPush.hpp" + #include ++#include + #include "common/LLVMWarningsPop.hpp" + #include + #include "Probe/Assertion.h" +@@ -1284,7 +1285,7 @@ int DeSSA::checkInsertElementAlias( + // + // If found, return the actual vector size; + // otherwise, return 0. +- VectorType* VTy = cast(IEI->getType()); ++ IGCLLVM::FixedVectorType* VTy = cast(IEI->getType()); + IGC_ASSERT(nullptr != VTy); + int nelts = (int)VTy->getNumElements(); + AllIEIs.resize(nelts, nullptr); +diff --git a/IGC/Compiler/CISACodeGen/EmitVISAPass.cpp b/IGC/Compiler/CISACodeGen/EmitVISAPass.cpp +index 3ab1cc5f..4502ef62 100644 +--- a/IGC/Compiler/CISACodeGen/EmitVISAPass.cpp ++++ b/IGC/Compiler/CISACodeGen/EmitVISAPass.cpp +@@ -53,6 +53,7 @@ IN THE SOFTWARE. + #include "Compiler/IGCPassSupport.h" + #include "common/LLVMWarningsPush.hpp" + #include "llvmWrapper/IR/Instructions.h" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "llvm/Support/Path.h" + #include "llvmWrapper/IR/Intrinsics.h" + #include "common/LLVMWarningsPop.hpp" +@@ -1165,7 +1166,7 @@ bool EmitPass::canRelocatePhiMov( + if (dst != src) + { + int numElt = 1; +- if (VectorType * vTy = dyn_cast(PN->getType())) ++ if (IGCLLVM::FixedVectorType * vTy = dyn_cast(PN->getType())) + { + numElt = int_cast(vTy->getNumElements()); + } +@@ -1302,7 +1303,7 @@ void EmitPass::MovPhiSources(llvm::BasicBlock* aBB) + phiSrcDstList.push_back(phiInfo); + + int numElt = 0; +- if (VectorType * vTy = dyn_cast(PN->getType())) ++ if (IGCLLVM::FixedVectorType * vTy = dyn_cast(PN->getType())) + { + numElt = int_cast(vTy->getNumElements()); + } +@@ -5375,7 +5376,7 @@ void EmitPass::emitLegacySimdBlockWrite(llvm::Instruction* inst, llvm::Value* pt + bool useA64 = isA64Ptr(ptrType, m_currShader->GetContext()); + + Type* Ty = dataPtr->getType(); +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + uint32_t nbElements = VTy ? int_cast(VTy->getNumElements()) : 1; + + uint32_t typeSizeInBytes = Ty->getScalarSizeInBits() / 8; +@@ -5621,7 +5622,7 @@ void EmitPass::emitLegacySimdBlockRead(llvm::Instruction* inst, llvm::Value* ptr + bool useA64 = isA64Ptr(ptrType, m_currShader->GetContext()); + + Type* Ty = inst->getType(); +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + uint32_t nbElements = VTy ? int_cast(VTy->getNumElements()) : 1; + + uint32_t typeSizeInBytes = Ty->getScalarSizeInBits() / 8; +@@ -5913,7 +5914,7 @@ void EmitPass::emitMediaBlockIO(const llvm::GenIntrinsicInst* inst, bool isRead) + }; + + uint nElts = isa(pDataType) ? +- (uint)cast(pDataType)->getNumElements() : ++ (uint)cast(pDataType)->getNumElements() : + 1; + + // Now, do the copies. +@@ -6003,7 +6004,7 @@ void EmitPass::emitSimdMediaBlockRead(llvm::Instruction* inst) + uint32_t nbElements = 1; + if (inst->getType()->isVectorTy()) + { +- nbElements = (uint32_t)cast(inst->getType())->getNumElements(); ++ nbElements = (uint32_t)cast(inst->getType())->getNumElements(); + } + IGC_ASSERT_MESSAGE(nbElements <= 8, "InValid Vector Size"); + +@@ -6247,7 +6248,7 @@ void EmitPass::emitSimdMediaBlockWrite(llvm::Instruction* inst) + uint32_t nbElements = 1; + if (dataPtr->getType()->isVectorTy()) + { +- nbElements = (uint32_t)cast(dataPtr->getType())->getNumElements(); ++ nbElements = (uint32_t)cast(dataPtr->getType())->getNumElements(); + } + IGC_ASSERT_MESSAGE(nbElements <= 8, "InValid Vector Size"); + +@@ -8993,8 +8994,8 @@ void EmitPass::emitBitCast(llvm::BitCastInst* btCst) + { + Type* srcType = btCst->getOperand(0)->getType(); + Type* dstType = btCst->getType(); +- unsigned int numSrcElement = srcType->isVectorTy() ? (unsigned)cast(srcType)->getNumElements() : 1; +- unsigned int numDstElement = dstType->isVectorTy() ? (unsigned)cast(dstType)->getNumElements() : 1; ++ unsigned int numSrcElement = srcType->isVectorTy() ? (unsigned)cast(srcType)->getNumElements() : 1; ++ unsigned int numDstElement = dstType->isVectorTy() ? (unsigned)cast(dstType)->getNumElements() : 1; + + if (srcType->isPointerTy()) + { +@@ -9468,7 +9469,7 @@ void EmitPass::emitLoad3DInner(LdRawIntrinsic* inst, ResourceDescriptor& resourc + { + IGC_ASSERT_MESSAGE(predDefSurface != ESURFACE_STATELESS, "scratch cannot be uniform"); + Type* loadType = inst->getType(); +- uint numElement = loadType->isVectorTy() ? (uint)cast(loadType)->getNumElements() : 1; ++ uint numElement = loadType->isVectorTy() ? (uint)cast(loadType)->getNumElements() : 1; + if (predDefSurface == ESURFACE_SLM) + { + IGC_ASSERT(numElement <= 4); +@@ -10795,7 +10796,7 @@ void EmitPass::emitInsert(llvm::Instruction* inst) + pVecVar = GetSymbol(pVec); + if (pVecVar != pInstVar) + { +- emitVectorCopy(pInstVar, pVecVar, int_cast(dyn_cast(pVecType)->getNumElements())); ++ emitVectorCopy(pInstVar, pVecVar, int_cast(dyn_cast(pVecType)->getNumElements())); + } + } + } +@@ -14596,7 +14597,7 @@ bool EmitPass::isUniformStoreOCL(llvm::StoreInst* SI) + + Value* storeVal = SI->getValueOperand(); + Type* Ty = storeVal->getType(); +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + uint32_t elts = VTy ? int_cast(VTy->getNumElements()) : 1; + Type* eltTy = VTy ? VTy->getElementType() : Ty; + +@@ -14626,7 +14627,7 @@ void EmitPass::emitVectorBitCast(llvm::BitCastInst* BCI) + if (srcTy->isVectorTy()) + { + srcEltTy = cast(srcTy)->getElementType(); +- srcNElts = (uint32_t)cast(srcTy)->getNumElements(); ++ srcNElts = (uint32_t)cast(srcTy)->getNumElements(); + } + else + { +@@ -14636,7 +14637,7 @@ void EmitPass::emitVectorBitCast(llvm::BitCastInst* BCI) + if (dstTy->isVectorTy()) + { + dstEltTy = cast(dstTy)->getElementType(); +- dstNElts = (uint32_t)cast(dstTy)->getNumElements(); ++ dstNElts = (uint32_t)cast(dstTy)->getNumElements(); + } + else + { +@@ -15215,7 +15216,7 @@ void EmitPass::emitVectorLoad(LoadInst* inst, Value* offset, ConstantInt* immOff + } + + Type* Ty = inst->getType(); +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + Type* eltTy = VTy ? VTy->getElementType() : Ty; + uint32_t eltBytes = GetScalarTypeSizeInRegister(eltTy); + IGC_ASSERT_MESSAGE((eltBytes == 1) || (eltBytes == 2) || (eltBytes == 4) || (eltBytes == 8), +@@ -15667,7 +15668,7 @@ void EmitPass::emitVectorStore(StoreInst* inst, Value* offset, ConstantInt* immO + + Value* storedVal = inst->getValueOperand(); + Type* Ty = storedVal->getType(); +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + Type* eltTy = VTy ? VTy->getElementType() : Ty; + uint32_t eltBytes = GetScalarTypeSizeInRegister(eltTy); + +@@ -16471,7 +16472,7 @@ void EmitPass::emitCopyAll(CVariable* Dst, CVariable* Src, llvm::Type* Ty) + } + else if (Ty->isVectorTy()) + { +- unsigned NElts = (unsigned)cast(Ty)->getNumElements(); ++ unsigned NElts = (unsigned)cast(Ty)->getNumElements(); + emitVectorCopy(Dst, Src, NElts); + } + else +diff --git a/IGC/Compiler/CISACodeGen/Emu64OpsPass.cpp b/IGC/Compiler/CISACodeGen/Emu64OpsPass.cpp +index 28248f30..767b477a 100644 +--- a/IGC/Compiler/CISACodeGen/Emu64OpsPass.cpp ++++ b/IGC/Compiler/CISACodeGen/Emu64OpsPass.cpp +@@ -1961,7 +1961,7 @@ bool InstExpander::visitExtractElement(ExtractElementInst& EEI) { + // later. + + Value* V = EEI.getVectorOperand(); +- unsigned NumElts = (unsigned)cast(V->getType())->getNumElements(); ++ unsigned NumElts = (unsigned)cast(V->getType())->getNumElements(); + V = IRB->CreateBitCast(V, Emu->getV2Int32Ty(NumElts)); + // Re-calculate indices to Lo and Hi parts. + Value* Idx = EEI.getIndexOperand(); +@@ -1998,7 +1998,7 @@ bool InstExpander::visitInsertElement(InsertElementInst& IEI) { + + // Create the emulated vector. + Value* NewVal = IEI.getOperand(0); +- unsigned NumElts = (unsigned)cast(NewVal->getType())->getNumElements(); ++ unsigned NumElts = (unsigned)cast(NewVal->getType())->getNumElements(); + NewVal = IRB->CreateBitCast(NewVal, Emu->getV2Int32Ty(NumElts)); + // Re-calculate indices to Lo and Hi parts. + Value* Idx = IEI.getOperand(2); +diff --git a/IGC/Compiler/CISACodeGen/GenIRLowering.cpp b/IGC/Compiler/CISACodeGen/GenIRLowering.cpp +index c74a2ac6..78e8a4aa 100644 +--- a/IGC/Compiler/CISACodeGen/GenIRLowering.cpp ++++ b/IGC/Compiler/CISACodeGen/GenIRLowering.cpp +@@ -453,7 +453,7 @@ Value* GEPLowering::getSExtOrTrunc(Value* Val, Type* NewTy) const { + + IGC_ASSERT_MESSAGE(OldTy->isIntOrIntVectorTy(), "Index should be Integer or vector of Integer!"); + +- if (auto OldVecTy = dyn_cast(OldTy)) { ++ if (auto OldVecTy = dyn_cast(OldTy)) { + OldWidth = (unsigned)OldVecTy->getNumElements() * OldVecTy->getElementType()->getIntegerBitWidth(); + NewWidth = (unsigned)OldVecTy->getNumElements() * NewTy->getIntegerBitWidth(); + } +@@ -805,7 +805,7 @@ bool GEPLowering::lowerGetElementPtrInst(GetElementPtrInst* GEP) const + } + else + { +- if (auto NewIdxVT = dyn_cast(NewIdx->getType())) { ++ if (auto NewIdxVT = dyn_cast(NewIdx->getType())) { + Value* result = llvm::UndefValue::get(FixedVectorType::get(PtrMathTy, (unsigned)NewIdxVT->getNumElements())); + for (uint32_t j = 0; j < (uint32_t)NewIdxVT->getNumElements(); j++) { + result = Builder->CreateInsertElement(result, PointerValue, Builder->getInt32(j)); +diff --git a/IGC/Compiler/CISACodeGen/GenSimplification.cpp b/IGC/Compiler/CISACodeGen/GenSimplification.cpp +index 8c38f229..f432061e 100644 +--- a/IGC/Compiler/CISACodeGen/GenSimplification.cpp ++++ b/IGC/Compiler/CISACodeGen/GenSimplification.cpp +@@ -35,6 +35,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include + #include "common/LLVMWarningsPop.hpp" + #include "Probe/Assertion.h" + +@@ -164,7 +165,7 @@ bool GenSimplification::simplifyVectorPHINodeCase2(PHINode& PN) const { + + Type* Ty = PN.getType(); + Type* EltTy = Ty->getScalarType(); +- unsigned NumElts = (unsigned)cast(Ty)->getNumElements(); ++ unsigned NumElts = (unsigned)cast(Ty)->getNumElements(); + + SmallVector Lanes; + SmallVector, 4> Values; +@@ -238,7 +239,7 @@ void GenSimplification::visitPHINode(PHINode& PN) { + void GenSimplification::visitExtractElement(ExtractElementInst& EEI) { + // Skip non-2-element vector. + Value* Vec = EEI.getVectorOperand(); +- VectorType* VTy = cast(Vec->getType()); ++ IGCLLVM::FixedVectorType* VTy = cast(Vec->getType()); + if (VTy->getNumElements() != 2) + return; + +diff --git a/IGC/Compiler/CISACodeGen/GeometryShaderLowering.cpp b/IGC/Compiler/CISACodeGen/GeometryShaderLowering.cpp +index e00e8469..a60b9892 100644 +--- a/IGC/Compiler/CISACodeGen/GeometryShaderLowering.cpp ++++ b/IGC/Compiler/CISACodeGen/GeometryShaderLowering.cpp +@@ -33,6 +33,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include + #include "common/LLVMWarningsPop.hpp" + #include "Compiler/InitializePasses.h" + #include "Probe/Assertion.h" +@@ -507,7 +508,7 @@ void GeometryShaderLowering::AddURBRead( + { + Value* vec = UndefValue::get(inst->getType()); + IRBuilder<> builder(inst); +- for (unsigned int i = 0; i < cast(inst->getType())->getNumElements(); i++) ++ for (unsigned int i = 0; i < cast(inst->getType())->getNumElements(); i++) + { + Value* vecElement = builder.CreateExtractElement(urbRead, builder.getInt32(i)); + vec = builder.CreateInsertElement(vec, vecElement, builder.getInt32(i)); +diff --git a/IGC/Compiler/CISACodeGen/LdShrink.cpp b/IGC/Compiler/CISACodeGen/LdShrink.cpp +index d89fbd0e..2df06df2 100644 +--- a/IGC/Compiler/CISACodeGen/LdShrink.cpp ++++ b/IGC/Compiler/CISACodeGen/LdShrink.cpp +@@ -30,6 +30,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include + #include "common/LLVMWarningsPop.hpp" + #include "Compiler/CISACodeGen/ShaderCodeGen.hpp" + #include "Compiler/IGCPassSupport.h" +@@ -79,7 +80,7 @@ IGC_INITIALIZE_PASS_BEGIN(LdShrink, PASS_FLAG, PASS_DESC, PASS_CFG_ONLY, PASS_AN + IGC_INITIALIZE_PASS_END(LdShrink, PASS_FLAG, PASS_DESC, PASS_CFG_ONLY, PASS_ANALYSIS) + + unsigned LdShrink::getExtractIndexMask(LoadInst* LI) const { +- VectorType* VTy = dyn_cast(LI->getType()); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(LI->getType()); + // Skip non-vector loads. + if (!VTy) + return 0; +@@ -91,9 +92,12 @@ unsigned LdShrink::getExtractIndexMask(LoadInst* LI) const { + Type* Ty = VTy->getScalarType(); + // Skip non-BYTE addressable data types. So far, check integer types + // only. +- if (IntegerType * ITy = dyn_cast(Ty)) +- if (!ITy->isPowerOf2ByteWidth()) ++ if (IntegerType * ITy = dyn_cast(Ty)) { ++ // Unroll isPowerOf2ByteWidth, it was removed in LLVM 12. ++ unsigned BitWidth = ITy->getBitWidth(); ++ if (!((BitWidth > 7) && isPowerOf2_32(BitWidth))) + return 0; ++ } + + unsigned Mask = 0; // Maxmimally 32 elements. + +diff --git a/IGC/Compiler/CISACodeGen/LowerGEPForPrivMem.cpp b/IGC/Compiler/CISACodeGen/LowerGEPForPrivMem.cpp +index c12b20d5..5245117d 100644 +--- a/IGC/Compiler/CISACodeGen/LowerGEPForPrivMem.cpp ++++ b/IGC/Compiler/CISACodeGen/LowerGEPForPrivMem.cpp +@@ -634,7 +634,7 @@ void TransposeHelper::handleGEPInst( + } + else + { +- arr_sz = (unsigned)cast(T)->getNumElements(); ++ arr_sz = (unsigned)cast(T)->getNumElements(); + } + T = cast(T)->getElementType(); + } +@@ -656,7 +656,7 @@ void TransposeHelper::handleGEPInst( + } + else if (T->isVectorTy()) + { +- arr_sz = (unsigned)cast(T)->getNumElements(); ++ arr_sz = (unsigned)cast(T)->getNumElements(); + T = cast(T)->getElementType(); + } + else +@@ -716,7 +716,7 @@ void TransposeHelperPromote::handleLoadInst( + IRBuilder<> IRB(pLoad); + IGC_ASSERT(nullptr != pLoad->getType()); + unsigned N = pLoad->getType()->isVectorTy() +- ? (unsigned)cast(pLoad->getType())->getNumElements() ++ ? (unsigned)cast(pLoad->getType())->getNumElements() + : 1; + Value* Val = loadEltsFromVecAlloca(N, pVecAlloca, pScalarizedIdx, IRB, pLoad->getType()->getScalarType()); + pLoad->replaceAllUsesWith(Val); +@@ -748,7 +748,7 @@ void TransposeHelperPromote::handleStoreInst( + // %v1 = extractelement <2 x float> %v, i32 1 + // %w1 = insertelement <32 x float> %w0, float %v1, i32 %idx+1 + // store <32 x float> %w1, <32 x float>* %ptr1 +- for (unsigned i = 0, e = (unsigned)cast(pStoreVal->getType())->getNumElements(); i < e; ++i) ++ for (unsigned i = 0, e = (unsigned)cast(pStoreVal->getType())->getNumElements(); i < e; ++i) + { + Value* VectorIdx = ConstantInt::get(pScalarizedIdx->getType(), i); + auto Val = IRB.CreateExtractElement(pStoreVal, VectorIdx); +diff --git a/IGC/Compiler/CISACodeGen/MemOpt.cpp b/IGC/Compiler/CISACodeGen/MemOpt.cpp +index e4279cca..aa788b11 100644 +--- a/IGC/Compiler/CISACodeGen/MemOpt.cpp ++++ b/IGC/Compiler/CISACodeGen/MemOpt.cpp +@@ -125,7 +125,7 @@ namespace { + MemRefListTy& MemRefs, TrivialMemRefListTy& ToOpt); + + unsigned getNumElements(Type* Ty) const { +- return Ty->isVectorTy() ? (unsigned)cast(Ty)->getNumElements() : 1; ++ return Ty->isVectorTy() ? (unsigned)cast(Ty)->getNumElements() : 1; + } + + MemoryLocation getLocation(Instruction* I) const { +@@ -797,7 +797,7 @@ bool MemOpt::mergeLoad(LoadInst* LeadingLoad, + Pos = unsigned((std::get<1>(I) - FirstOffset) / LdScalarSize); + + if (Ty->isVectorTy()) { +- if (Pos + cast(Ty)->getNumElements() > NumElts) { ++ if (Pos + cast(Ty)->getNumElements() > NumElts) { + // This implies we're trying to extract an element from our new load + // with an index > the size of the new load. If this happens, + // we'll generate correct code if it does since we don't remove the +@@ -805,7 +805,7 @@ bool MemOpt::mergeLoad(LoadInst* LeadingLoad, + continue; + } + Value* Val = UndefValue::get(Ty); +- for (unsigned i = 0, e = (unsigned)cast(Ty)->getNumElements(); i != e; ++i) { ++ for (unsigned i = 0, e = (unsigned)cast(Ty)->getNumElements(); i != e; ++i) { + Value* Ex = Builder.CreateExtractElement(NewLoad, Builder.getInt32(Pos + i)); + Ex = createBitOrPointerCast(Ex, ScalarTy, Builder); + Val = Builder.CreateInsertElement(Val, Ex, Builder.getInt32(i)); +@@ -1083,7 +1083,7 @@ bool MemOpt::mergeStore(StoreInst* LeadingStore, + IGC_ASSERT(hasSameSize(ScalarTy, LeadingStoreScalarType)); + + if (Ty->isVectorTy()) { +- for (unsigned i = 0, e = (unsigned)cast(Ty)->getNumElements(); i != e; ++i) { ++ for (unsigned i = 0, e = (unsigned)cast(Ty)->getNumElements(); i != e; ++i) { + Value* Ex = Builder.CreateExtractElement(Val, Builder.getInt32(i)); + Ex = createBitOrPointerCast(Ex, LeadingStoreScalarType, Builder); + NewStoreVal = Builder.CreateInsertElement(NewStoreVal, Ex, +diff --git a/IGC/Compiler/CISACodeGen/MemOpt2.cpp b/IGC/Compiler/CISACodeGen/MemOpt2.cpp +index 4b2628d2..20115c73 100644 +--- a/IGC/Compiler/CISACodeGen/MemOpt2.cpp ++++ b/IGC/Compiler/CISACodeGen/MemOpt2.cpp +@@ -32,6 +32,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include + #include "common/LLVMWarningsPop.hpp" + #include "GenISAIntrinsics/GenIntrinsics.h" + +@@ -124,7 +125,7 @@ namespace { + if (!Ty->isSingleValueType()) + return UINT_MAX; + // Simply return 1 so far for scalar types. +- VectorType* VecTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VecTy = dyn_cast(Ty); + if (!VecTy) + return 1; + // Check how that vector is used. +@@ -153,7 +154,7 @@ namespace { + return UINT_MAX; + unsigned EltByte = (Ty->getScalarSizeInBits() + 7) / 8; + // Simply return 1 so far for scalar types. +- VectorType* VecTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VecTy = dyn_cast(Ty); + if (!VecTy) + return EltByte; + // Check how that vector is used. +diff --git a/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp b/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp +index 5baff64f..032d127a 100644 +--- a/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp ++++ b/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp +@@ -410,7 +410,7 @@ namespace IGC + unsigned int numElements = 1; + if (baseType->isVectorTy()) + { +- numElements = (unsigned)cast(baseType)->getNumElements(); ++ numElements = (unsigned)cast(baseType)->getNumElements(); + baseType = cast(baseType)->getElementType(); + } + +diff --git a/IGC/Compiler/CISACodeGen/PatternMatchPass.cpp b/IGC/Compiler/CISACodeGen/PatternMatchPass.cpp +index 356f1141..52396304 100644 +--- a/IGC/Compiler/CISACodeGen/PatternMatchPass.cpp ++++ b/IGC/Compiler/CISACodeGen/PatternMatchPass.cpp +@@ -2916,8 +2916,8 @@ namespace IGC + llvm::Type* srcTy = bTInst->getOperand(0)->getType(); + llvm::Type* dstTy = bTInst->getType(); + +- srcNElts = (srcTy->isVectorTy()) ? (uint32_t)cast(srcTy)->getNumElements() : 1; +- dstNElts = (dstTy->isVectorTy()) ? (uint32_t)cast(dstTy)->getNumElements() : 1; ++ srcNElts = (srcTy->isVectorTy()) ? (uint32_t)cast(srcTy)->getNumElements() : 1; ++ dstNElts = (dstTy->isVectorTy()) ? (uint32_t)cast(dstTy)->getNumElements() : 1; + + if (srcNElts < dstNElts && srcTy->getScalarSizeInBits() < 64) + { +diff --git a/IGC/Compiler/CISACodeGen/PushAnalysis.cpp b/IGC/Compiler/CISACodeGen/PushAnalysis.cpp +index ba8c2770..8da82db0 100644 +--- a/IGC/Compiler/CISACodeGen/PushAnalysis.cpp ++++ b/IGC/Compiler/CISACodeGen/PushAnalysis.cpp +@@ -899,7 +899,7 @@ namespace IGC + + if (pTypeToPush->isVectorTy()) + { +- num_elms = (unsigned)cast(pTypeToPush)->getNumElements(); ++ num_elms = (unsigned)cast(pTypeToPush)->getNumElements(); + pTypeToPush = cast(pTypeToPush)->getElementType(); + llvm::Type* pVecTy = IGCLLVM::FixedVectorType::get(pTypeToPush, num_elms); + pReplacedInst = llvm::UndefValue::get(pVecTy); +@@ -1102,7 +1102,7 @@ namespace IGC + } + + unsigned num_elms = +- inst->getType()->isVectorTy() ? (unsigned)cast(inst->getType())->getNumElements() : 1; ++ inst->getType()->isVectorTy() ? (unsigned)cast(inst->getType())->getNumElements() : 1; + llvm::Type* pTypeToPush = inst->getType(); + llvm::Value* replaceVector = nullptr; + unsigned int numberChannelReplaced = 0; +diff --git a/IGC/Compiler/CISACodeGen/RegisterEstimator.cpp b/IGC/Compiler/CISACodeGen/RegisterEstimator.cpp +index 95b937e7..1c6544a4 100644 +--- a/IGC/Compiler/CISACodeGen/RegisterEstimator.cpp ++++ b/IGC/Compiler/CISACodeGen/RegisterEstimator.cpp +@@ -41,6 +41,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include + #include "common/LLVMWarningsPop.hpp" + #include "Probe/Assertion.h" + +@@ -146,7 +147,7 @@ RegUse RegisterEstimator::estimateNumOfRegs(Value* V) const + Type* Ty = V->getType(); + if (!Ty->isVoidTy()) + { +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + Type* eltTy = VTy ? VTy->getElementType() : Ty; + uint32_t nelts = VTy ? int_cast(VTy->getNumElements()) : 1; + uint32_t eltBits = (uint32_t)m_DL->getTypeSizeInBits(eltTy); +diff --git a/IGC/Compiler/CISACodeGen/RegisterPressureEstimate.hpp b/IGC/Compiler/CISACodeGen/RegisterPressureEstimate.hpp +index beac138d..ceeafa48 100644 +--- a/IGC/Compiler/CISACodeGen/RegisterPressureEstimate.hpp ++++ b/IGC/Compiler/CISACodeGen/RegisterPressureEstimate.hpp +@@ -42,6 +42,7 @@ See LRCENSE.TXT for details. + #include "llvm/Pass.h" + #include + #include "llvm/Analysis/LoopInfo.h" ++#include + #include "common/LLVMWarningsPop.hpp" + #include "Compiler/IGCPassSupport.h" + #include "Compiler/CISACodeGen/WIAnalysis.hpp" +@@ -240,7 +241,7 @@ namespace IGC + auto Ty = V->getType(); + if (Ty->isVoidTy()) + return 0; +- auto VTy = llvm::dyn_cast(Ty); ++ auto VTy = llvm::dyn_cast(Ty); + auto eltTy = VTy ? VTy->getElementType() : Ty; + uint32_t nelts = VTy ? int_cast(VTy->getNumElements()) : 1; + uint32_t eltBits = (uint32_t)m_DL->getTypeSizeInBits(eltTy); +diff --git a/IGC/Compiler/CISACodeGen/SLMConstProp.cpp b/IGC/Compiler/CISACodeGen/SLMConstProp.cpp +index 962083f4..26a7b8be 100644 +--- a/IGC/Compiler/CISACodeGen/SLMConstProp.cpp ++++ b/IGC/Compiler/CISACodeGen/SLMConstProp.cpp +@@ -39,6 +39,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "common/LLVMWarningsPop.hpp" + #include + #include "Probe/Assertion.h" +@@ -629,7 +630,7 @@ bool SLMConstProp::isEqual(Constant* C0, Constant* C1) + + bool SLMConstProp::isFloatType(Type* Ty) + { +- if (VectorType * vTy = dyn_cast(Ty)) ++ if (IGCLLVM::FixedVectorType * vTy = dyn_cast(Ty)) + { + if (vTy->getNumElements() > 1) + { +diff --git a/IGC/Compiler/CISACodeGen/ScalarizerCodeGen.cpp b/IGC/Compiler/CISACodeGen/ScalarizerCodeGen.cpp +index ce816416..32ab79c1 100644 +--- a/IGC/Compiler/CISACodeGen/ScalarizerCodeGen.cpp ++++ b/IGC/Compiler/CISACodeGen/ScalarizerCodeGen.cpp +@@ -66,7 +66,7 @@ void ScalarizerCodeGen::visitBinaryOperator(llvm::BinaryOperator& I) + { + bool isNewTypeVector = false; + +- VectorType* instType = cast(I.getType()); ++ IGCLLVM::FixedVectorType* instType = cast(I.getType()); + unsigned numElements = int_cast(instType->getNumElements()); + unsigned scalarSize = instType->getScalarSizeInBits(); + unsigned newScalarBits = numElements * scalarSize; +@@ -111,7 +111,7 @@ void ScalarizerCodeGen::visitBinaryOperator(llvm::BinaryOperator& I) + } + else + { +- VectorType* newVecType = cast(newType); ++ IGCLLVM::FixedVectorType* newVecType = cast(newType); + unsigned newVecTypeNumEle = int_cast(newVecType->getNumElements()); + Value* ieLogicOp = UndefValue::get(newType); + for (unsigned i = 0; i < newVecTypeNumEle; i++) +diff --git a/IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp b/IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp +index d7baf806..e6fbdf23 100644 +--- a/IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp ++++ b/IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp +@@ -589,12 +589,14 @@ static void AddLegalizationPasses(CodeGenContext& ctx, IGCPassManager& mpm, PSSi + { + mpm.add(createPruneUnusedArgumentsPass()); + ++#if LLVM_VERSION_MAJOR < 12 + if (IGC_GET_FLAG_VALUE(FunctionControl) == FLAG_FCALL_DEFAULT) + { + // Don't run IPConstantProp when debugging function calls, to avoid folding function arg/ret constants + mpm.add(createIPConstantPropagationPass()); + } + mpm.add(createConstantPropagationPass()); ++#endif + mpm.add(createDeadCodeEliminationPass()); + mpm.add(createCFGSimplificationPass()); + } +@@ -1475,8 +1477,10 @@ void OptimizeIR(CodeGenContext* const pContext) + // possible which potentially allows late stage code sinking of + // those calls by the instruction combiner. + mpm.add(createPostOrderFunctionAttrsLegacyPass()); ++#if LLVM_VERSION_MAJOR < 12 + mpm.add(createConstantPropagationPass()); + mpm.add(createIPConstantPropagationPass()); ++#endif + } + + // enable this only when Pooled EU is not supported +diff --git a/IGC/Compiler/CISACodeGen/Simd32Profitability.cpp b/IGC/Compiler/CISACodeGen/Simd32Profitability.cpp +index 87ba2751..c1f4a419 100644 +--- a/IGC/Compiler/CISACodeGen/Simd32Profitability.cpp ++++ b/IGC/Compiler/CISACodeGen/Simd32Profitability.cpp +@@ -30,6 +30,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include + #include "common/LLVMWarningsPop.hpp" + #include "GenISAIntrinsics/GenIntrinsics.h" + #include "GenISAIntrinsics/GenIntrinsicInst.h" +@@ -577,7 +578,7 @@ static bool isPayloadHeader(Value* V) { + Argument* Arg = dyn_cast(V); + if (!Arg || !Arg->hasName()) + return false; +- VectorType* VTy = dyn_cast(Arg->getType()); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Arg->getType()); + if (!VTy || VTy->getNumElements() != 8 || + !VTy->getElementType()->isIntegerTy(32)) + return false; +@@ -588,7 +589,7 @@ static bool isR0(Value* V) { + Argument* Arg = dyn_cast(V); + if (!Arg || !Arg->hasName()) + return false; +- VectorType* VTy = dyn_cast(Arg->getType()); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Arg->getType()); + if (!VTy || VTy->getNumElements() != 8 || + !VTy->getElementType()->isIntegerTy(32)) + return false; +@@ -599,7 +600,7 @@ static bool isEnqueuedLocalSize(Value* V) { + Argument* Arg = dyn_cast(V); + if (!Arg || !Arg->hasName()) + return false; +- VectorType* VTy = dyn_cast(Arg->getType()); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Arg->getType()); + if (!VTy || VTy->getNumElements() != 3 || + !VTy->getElementType()->isIntegerTy(32)) + return false; +@@ -994,7 +995,11 @@ static bool hasLongStridedLdStInLoop(Function* F, LoopInfo* LI, WIAnalysis* WI) + // Collect innermost simple loop. + for (auto I = LI->begin(), E = LI->end(); I != E; ++I) { + auto L = *I; ++#if LLVM_VERSION_MAJOR >= 12 ++ if (!L->isInnermost()) ++#else + if (!L->empty()) ++#endif + continue; + if (L->getNumBlocks() != 2) + continue; +diff --git a/IGC/Compiler/CISACodeGen/SimplifyConstant.cpp b/IGC/Compiler/CISACodeGen/SimplifyConstant.cpp +index 73f472b5..0069c4b1 100644 +--- a/IGC/Compiler/CISACodeGen/SimplifyConstant.cpp ++++ b/IGC/Compiler/CISACodeGen/SimplifyConstant.cpp +@@ -352,7 +352,7 @@ static unsigned getLegalVectorSize(unsigned N) { + // Check vector size. We may demote the data type if all values can fit into + // smaller data type. + // +-static bool checkSize(GlobalVariable* GV, VectorType*& DataType, ++static bool checkSize(GlobalVariable* GV, IGCLLVM::FixedVectorType*& DataType, + bool& IsSigned) { + Constant* Init = GV->getInitializer(); + IGC_ASSERT(isa(Init->getType())); +@@ -360,7 +360,7 @@ static bool checkSize(GlobalVariable* GV, VectorType*& DataType, + unsigned N = (unsigned)ArrayTy->getArrayNumElements(); + Type* BaseTy = ArrayTy->getArrayElementType(); + unsigned VectorSize = 1; +- if (auto VT = dyn_cast(BaseTy)) { ++ if (auto VT = dyn_cast(BaseTy)) { + BaseTy = VT->getElementType(); + VectorSize = int_cast(VT->getNumElements()); + N *= VectorSize; +@@ -483,7 +483,7 @@ static Constant* getConstantVal(Type* VEltTy, Constant* V, bool IsSigned) { + return ConstantInt::get(VEltTy, IVal, IsSigned); + } + +-static void promote(GlobalVariable* GV, VectorType* AllocaType, bool IsSigned, ++static void promote(GlobalVariable* GV, IGCLLVM::FixedVectorType* AllocaType, bool IsSigned, + Function* F) { + // Build the constant vector from constant array. + unsigned VS = int_cast(AllocaType->getNumElements()); +@@ -507,7 +507,7 @@ static void promote(GlobalVariable* GV, VectorType* AllocaType, bool IsSigned, + Constant* const Elt = CA->getAggregateElement(i); + IGC_ASSERT_MESSAGE(nullptr != Elt, "Null AggregateElement"); + if (auto EltTy = dyn_cast(Elt->getType())) { +- unsigned VectorSize = (unsigned)cast(EltTy)->getNumElements(); ++ unsigned VectorSize = (unsigned)cast(EltTy)->getNumElements(); + for (unsigned j = 0; j < VectorSize; ++j) { + Constant* V = Elt->getAggregateElement(j); + Vals[i * VectorSize + j] = getConstantVal(VEltTy, V, IsSigned); +@@ -549,7 +549,7 @@ static void promote(GlobalVariable* GV, VectorType* AllocaType, bool IsSigned, + unsigned N = 1; + Value* Offset = Index; + if (Ty->isVectorTy()) { +- N = (unsigned)cast(Ty)->getNumElements(); ++ N = (unsigned)cast(Ty)->getNumElements(); + Offset = Builder.CreateMul(Offset, ConstantInt::get(Offset->getType(), N)); + } + Value* Val = extractNElts(N, VectorData, Offset, Builder); +@@ -684,7 +684,7 @@ bool PromoteConstant::runOnFunction(Function& F) { + + // If possible demote the data into smaller type. Uses of value will be + // promoted back with ZExt or SExt. +- VectorType* AllocaType = nullptr; ++ IGCLLVM::FixedVectorType* AllocaType = nullptr; + bool IsSigned = false; + if (!checkSize(GV, AllocaType, IsSigned)) + continue; +diff --git a/IGC/Compiler/CISACodeGen/TypeDemote.cpp b/IGC/Compiler/CISACodeGen/TypeDemote.cpp +index eb7a7b64..b04a0f6e 100644 +--- a/IGC/Compiler/CISACodeGen/TypeDemote.cpp ++++ b/IGC/Compiler/CISACodeGen/TypeDemote.cpp +@@ -32,6 +32,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include + #include "common/LLVMWarningsPop.hpp" + #include "GenISAIntrinsics/GenIntrinsics.h" + #include "Probe/Assertion.h" +@@ -288,7 +289,7 @@ bool TypeDemote::demoteOnBasicBlock(BasicBlock* BB) const { + CastInst* CI = dyn_cast(Index); + if (CI && (CI->getOpcode() == Instruction::ZExt || + CI->getOpcode() == Instruction::SExt)) { +- unsigned VS = (unsigned)cast(EEI->getVectorOperandType())->getNumElements(); ++ unsigned VS = (unsigned)cast(EEI->getVectorOperandType())->getNumElements(); + unsigned N = (unsigned int)CI->getSrcTy()->getPrimitiveSizeInBits(); + unsigned Bound = (N < 32) ? (1U << N) : UINT32_MAX; + if (VS <= Bound) { +diff --git a/IGC/Compiler/CISACodeGen/VariableReuseAnalysis.cpp b/IGC/Compiler/CISACodeGen/VariableReuseAnalysis.cpp +index 1cac7b12..12c4734e 100644 +--- a/IGC/Compiler/CISACodeGen/VariableReuseAnalysis.cpp ++++ b/IGC/Compiler/CISACodeGen/VariableReuseAnalysis.cpp +@@ -28,6 +28,7 @@ IN THE SOFTWARE. + #include "Compiler/CodeGenPublic.h" + #include "common/LLVMWarningsPush.hpp" + #include ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "common/LLVMWarningsPop.hpp" + #include + #include "Probe/Assertion.h" +@@ -40,13 +41,13 @@ namespace + // If V is scalar, return 1. + // if V is vector, return the number of elements. + inline int getNumElts(Value* V) { +- VectorType* VTy = dyn_cast(V->getType()); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(V->getType()); + return VTy ? (int)VTy->getNumElements() : 1; + } + + inline int getTypeSizeInBits(Type* Ty) { + int scalarBits = Ty->getScalarSizeInBits(); +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + return scalarBits * (VTy ? (int)VTy->getNumElements() : 1); + } + } +diff --git a/IGC/Compiler/CISACodeGen/VariableReuseAnalysis.hpp b/IGC/Compiler/CISACodeGen/VariableReuseAnalysis.hpp +index 56dac17e..42081dca 100644 +--- a/IGC/Compiler/CISACodeGen/VariableReuseAnalysis.hpp ++++ b/IGC/Compiler/CISACodeGen/VariableReuseAnalysis.hpp +@@ -37,6 +37,7 @@ IN THE SOFTWARE. + #include + #include + #include "llvm/Pass.h" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "llvm/Support/raw_ostream.h" + #include "common/LLVMWarningsPop.hpp" + #include "Compiler/CISACodeGen/RegisterEstimator.hpp" +@@ -79,7 +80,7 @@ namespace IGC { + SSubVecDesc(llvm::Value* V) + : Aliaser(V), BaseVector(V), StartElementOffset(0) + { +- llvm::VectorType* VTy = llvm::dyn_cast(V->getType()); ++ IGCLLVM::FixedVectorType* VTy = llvm::dyn_cast(V->getType()); + NumElts = VTy ? (short)VTy->getNumElements() : 1; + } + +diff --git a/IGC/Compiler/CISACodeGen/VectorPreProcess.cpp b/IGC/Compiler/CISACodeGen/VectorPreProcess.cpp +index 4c2b0644..4cd6a2db 100644 +--- a/IGC/Compiler/CISACodeGen/VectorPreProcess.cpp ++++ b/IGC/Compiler/CISACodeGen/VectorPreProcess.cpp +@@ -500,7 +500,7 @@ void VectorPreProcess::replaceAllVectorUsesWithScalars(Instruction* VI, ValVecto + I = VI->getParent()->getFirstNonPHI(); + } + IRBuilder<> Builder(I); +- VectorType* VTy = cast(VI->getType()); ++ IGCLLVM::FixedVectorType* VTy = cast(VI->getType()); + Value* newVec = UndefValue::get(VTy); + for (uint32_t i = 0, e = int_cast(VTy->getNumElements()); i < e; ++i) + { +@@ -619,7 +619,7 @@ bool VectorPreProcess::splitStore( + { + Instruction* SI = ASI.getInst(); + Value* StoredVal = ASI.getValueOperand(); +- VectorType* VTy = cast(StoredVal->getType()); ++ IGCLLVM::FixedVectorType* VTy = cast(StoredVal->getType()); + Type* ETy = VTy->getElementType(); + uint32_t nelts = int_cast(VTy->getNumElements()); + +@@ -705,7 +705,7 @@ bool VectorPreProcess::splitStore( + { + Type* Ty1 = splitInfo[i].first; + uint32_t len1 = splitInfo[i].second; +- VectorType* VTy1 = dyn_cast(Ty1); ++ IGCLLVM::FixedVectorType* VTy1 = dyn_cast(Ty1); + for (uint32_t j = 0; j < len1; ++j) + { + Value* subVec; +@@ -742,7 +742,7 @@ bool VectorPreProcess::splitStore( + { + Type* Ty1 = splitInfo[i].first; + uint32_t len1 = splitInfo[i].second; +- VectorType* VTy1 = dyn_cast(Ty1); ++ IGCLLVM::FixedVectorType* VTy1 = dyn_cast(Ty1); + for (uint32_t j = 0; j < len1; ++j) + { + uint32_t vAlign = (uint32_t)MinAlign(Align, (uint32_t)eOffset * EBytes); +@@ -786,7 +786,7 @@ bool VectorPreProcess::splitLoad( + { + Instruction* LI = ALI.getInst(); + bool isLdRaw = isa(LI); +- VectorType* VTy = cast(LI->getType()); ++ IGCLLVM::FixedVectorType* VTy = cast(LI->getType()); + Type* ETy = VTy->getElementType(); + uint32_t nelts = int_cast(VTy->getNumElements()); + +@@ -848,7 +848,7 @@ bool VectorPreProcess::splitLoad( + { + Type* Ty1 = splitInfo[i].first; + uint32_t len1 = splitInfo[i].second; +- VectorType* VTy1 = dyn_cast(Ty1); ++ IGCLLVM::FixedVectorType* VTy1 = dyn_cast(Ty1); + for (uint32_t j = 0; j < len1; ++j) + { + uint32_t vAlign = (uint32_t)MinAlign(Align, eOffset * EBytes); +@@ -916,7 +916,7 @@ bool VectorPreProcess::splitLoadStore( + Optional ASI = AbstractStoreInst::get(Inst); + IGC_ASSERT_MESSAGE((ALI || ASI), "Inst should be either load or store"); + Type* Ty = ALI ? ALI->getInst()->getType() : ASI->getValueOperand()->getType(); +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + if (!VTy) + { + return false; +@@ -1147,7 +1147,7 @@ void VectorPreProcess::getOrGenScalarValues( + { + availBeforeInst = nullptr; + +- VectorType* VTy = cast(VecVal->getType()); ++ IGCLLVM::FixedVectorType* VTy = cast(VecVal->getType()); + if (!VTy) + { + scalars[0] = VecVal; +@@ -1298,7 +1298,7 @@ Instruction* VectorPreProcess::simplifyLoadStore(Instruction* Inst) + // + // TODO: further optimize this load into a message with channel masks + // for cases in which use indices are sparse like {0, 2}. +- unsigned N = (unsigned)cast(Inst->getType())->getNumElements(); ++ unsigned N = (unsigned)cast(Inst->getType())->getNumElements(); + if (N == MaxIndex + 1) + return Inst; + +@@ -1355,7 +1355,7 @@ Instruction* VectorPreProcess::simplifyLoadStore(Instruction* Inst) + if (NBits < 32) + return Inst; + +- unsigned N = (unsigned)cast(Val->getType())->getNumElements(); ++ unsigned N = (unsigned)cast(Val->getType())->getNumElements(); + if (auto CV = dyn_cast(Val)) + { + unsigned MaxIndex = 0; +@@ -1524,7 +1524,7 @@ bool VectorPreProcess::runOnFunction(Function& F) + for (uint32_t j = 0; j < svals.size(); ++j) + { + Type* Ty1 = svals[j]->getType(); +- VectorType* VTy1 = dyn_cast(Ty1); ++ IGCLLVM::FixedVectorType* VTy1 = dyn_cast(Ty1); + if (VTy1) { + for (uint32_t k = 0; k < VTy1->getNumElements(); ++k) + { +@@ -1573,7 +1573,7 @@ bool VectorPreProcess::runOnFunction(Function& F) + // If this is a 3-element vector load, remove it + // from m_Vector3List as well. + if (isAbstractLoadInst(tInst) && tInst->getType()->isVectorTy() && +- cast(tInst->getType())->getNumElements() == 3) ++ cast(tInst->getType())->getNumElements() == 3) + { + InstWorkVector::iterator + tI = m_Vector3List.begin(), +diff --git a/IGC/Compiler/CISACodeGen/VectorProcess.cpp b/IGC/Compiler/CISACodeGen/VectorProcess.cpp +index 9f39cdc0..cfe45321 100644 +--- a/IGC/Compiler/CISACodeGen/VectorProcess.cpp ++++ b/IGC/Compiler/CISACodeGen/VectorProcess.cpp +@@ -240,7 +240,7 @@ bool VectorProcess::reLayoutLoadStore(Instruction* Inst) + IGC_ASSERT(nullptr != Ptr); + IGC_ASSERT(nullptr != Ty); + +- VectorType* const VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* const VTy = dyn_cast(Ty); + + // Treat a scalar as 1-element vector + uint32_t nelts = VTy ? int_cast(VTy->getNumElements()) : 1; +@@ -654,7 +654,7 @@ void VectorMessage::getInfo(Type* Ty, uint32_t Align, bool useA32, + VectorType* VTy = dyn_cast(Ty); + Type* eTy = VTy ? cast(VTy)->getElementType() : Ty; + unsigned eltSize = m_emitter->GetScalarTypeSizeInRegister(eTy); +- unsigned nElts = VTy ? (unsigned)cast(VTy)->getNumElements() : 1; ++ unsigned nElts = VTy ? (unsigned)cast(VTy)->getNumElements() : 1; + // total bytes + const unsigned TBytes = nElts * eltSize; + +diff --git a/IGC/Compiler/CISACodeGen/helper.cpp b/IGC/Compiler/CISACodeGen/helper.cpp +index 784affaa..e5507283 100644 +--- a/IGC/Compiler/CISACodeGen/helper.cpp ++++ b/IGC/Compiler/CISACodeGen/helper.cpp +@@ -1634,7 +1634,7 @@ namespace IGC + { + instList[i] = builder.CreateExtractElement(val, static_cast(0)); + size_t iOld = i; +- for (unsigned j = 1; j < cast(val->getType())->getNumElements(); j++) ++ for (unsigned j = 1; j < cast(val->getType())->getNumElements(); j++) + { + instList.insert(instList.begin()+ iOld +j, builder.CreateExtractElement(val, j)); + i++; +@@ -1667,7 +1667,7 @@ namespace IGC + } + break; + case IGCLLVM::VectorTyID: +- num = (unsigned)cast(type)->getNumElements(); ++ num = (unsigned)cast(type)->getNumElements(); + for (unsigned i = 0; i < num; i++) + { + ScalarizeAggregateMembers(builder, builder.CreateExtractElement(val, i), instList); +@@ -1707,7 +1707,7 @@ namespace IGC + } + break; + case IGCLLVM::VectorTyID: +- num = (unsigned)cast(type)->getNumElements(); ++ num = (unsigned)cast(type)->getNumElements(); + for (unsigned i = 0; i < num; i++) + { + indices.push_back(builder.getInt32(i)); +@@ -1972,8 +1972,8 @@ namespace IGC + return false; + } + +- VectorType* dVTy = dyn_cast(dTy); +- VectorType* sVTy = dyn_cast(sTy); ++ IGCLLVM::FixedVectorType* dVTy = dyn_cast(dTy); ++ IGCLLVM::FixedVectorType* sVTy = dyn_cast(sTy); + int d_nelts = dVTy ? (int)dVTy->getNumElements() : 1; + int s_nelts = sVTy ? (int)sVTy->getNumElements() : 1; + if (d_nelts != s_nelts) { +diff --git a/IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp b/IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp +index cd7fc66e..adf992cb 100644 +--- a/IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp ++++ b/IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp +@@ -153,15 +153,24 @@ void ConvertMSAAPayloadTo16Bit::visitCallInst(CallInst& I) + // In OGL there are uses of ldmcs other then ldms, using vec4float type. + // Fix them to use newly created 16bit ldmcs. + if (ldmcs->getType()->isVectorTy() && ++#if LLVM_VERSION_MAJOR >= 12 ++ ldmcs->getType()->getScalarType()->isFloatTy()) ++#else + ldmcs->getType()->getVectorElementType()->isFloatTy()) ++#endif + { + m_builder->SetInsertPoint(ldmcs); + ++#if LLVM_VERSION_MAJOR >= 12 ++ uint ldmcsNumOfElements = cast(ldmcs->getType())->getNumElements(); ++ uint new_mcs_callNumOfElements = cast(new_mcs_call->getType())->getNumElements(); ++#else + uint ldmcsNumOfElements = ldmcs->getType()->getVectorNumElements(); + uint new_mcs_callNumOfElements = new_mcs_call->getType()->getVectorNumElements(); ++#endif + + // vec of 16bit ints to vec of 32bit ints +- Type* new_mcs_callVecType = VectorType::get(m_builder->getInt32Ty(), new_mcs_callNumOfElements); ++ Type* new_mcs_callVecType = IGCLLVM::FixedVectorType::get(m_builder->getInt32Ty(), new_mcs_callNumOfElements); + Value* ldmcsExtendedToInt32 = m_builder->CreateSExt(new_mcs_call, new_mcs_callVecType); + + // if new ldmcs has fewer elements than ldmcs, extend vector +@@ -175,7 +184,7 @@ void ConvertMSAAPayloadTo16Bit::visitCallInst(CallInst& I) + } + auto* pMask = ConstantDataVector::get(I.getContext(), maskVals); + +- newLdmcsSizedVector = m_builder->CreateShuffleVector(ldmcsExtendedToInt32, UndefValue::get(VectorType::get(m_builder->getInt32Ty(), ldmcsNumOfElements)), pMask); ++ newLdmcsSizedVector = m_builder->CreateShuffleVector(ldmcsExtendedToInt32, UndefValue::get(IGCLLVM::FixedVectorType::get(m_builder->getInt32Ty(), ldmcsNumOfElements)), pMask); + } + else + { +@@ -183,7 +192,7 @@ void ConvertMSAAPayloadTo16Bit::visitCallInst(CallInst& I) + } + IGC_ASSERT(newLdmcsSizedVector); + +- Type* ldmcsFloatVecType = VectorType::get(m_builder->getFloatTy(), ldmcsNumOfElements); ++ Type* ldmcsFloatVecType = IGCLLVM::FixedVectorType::get(m_builder->getFloatTy(), ldmcsNumOfElements); + Value* ldmcsBitcastedToFloat = m_builder->CreateBitCast(ldmcsExtendedToInt32, ldmcsFloatVecType); + ldmcs->replaceAllUsesWith(ldmcsBitcastedToFloat); + } +diff --git a/IGC/Compiler/CustomSafeOptPass.cpp b/IGC/Compiler/CustomSafeOptPass.cpp +index 707bbfbe..72859a91 100644 +--- a/IGC/Compiler/CustomSafeOptPass.cpp ++++ b/IGC/Compiler/CustomSafeOptPass.cpp +@@ -1372,7 +1372,7 @@ void IGC::CustomSafeOptPass::visitSampleBptr(llvm::SampleIntrinsic* sampleInst) + bool CustomSafeOptPass::isIdentityMatrix(ExtractElementInst& I) + { + bool found = false; +- auto extractType = cast(I.getVectorOperandType()); ++ auto extractType = cast(I.getVectorOperandType()); + auto extractTypeVecSize = (uint32_t)extractType->getNumElements(); + if (extractTypeVecSize == 20 || + extractTypeVecSize == 16) +@@ -1601,7 +1601,7 @@ void CustomSafeOptPass::visitExtractElementInst(ExtractElementInst& I) + int elOffset = (int)(bitShift / eltSize); + elOffset = rightShift ? elOffset : -elOffset; + unsigned int newIndex = (unsigned int)((int)cstIndex->getZExtValue() + elOffset); +- if (newIndex < cast(vecType)->getNumElements()) ++ if (newIndex < cast(vecType)->getNumElements()) + { + IRBuilder<> builder(&I); + Value* newBitCast = builder.CreateBitCast(binOp->getOperand(0), vecType); +@@ -2001,7 +2001,7 @@ void GenSpecificPattern::createBitcastExtractInsertPattern(BinaryOperator& I, Va + else if (auto IEIInst = dyn_cast(Op)) + { + auto opType = IEIInst->getType(); +- if (opType->isVectorTy() && cast(opType)->getElementType()->isIntegerTy(32) && cast(opType)->getNumElements() == 2) ++ if (opType->isVectorTy() && cast(opType)->getElementType()->isIntegerTy(32) && cast(opType)->getNumElements() == 2) + { + elem = IEIInst->getOperand(1); + } +@@ -2064,7 +2064,7 @@ void GenSpecificPattern::visitBinaryOperator(BinaryOperator& I) + else if (match(&I, pattern2) && AndOp2->getType()->isIntegerTy(64)) + { + ConstantVector* cVec = dyn_cast(VecOp); +- VectorType* vector_type = dyn_cast(VecOp->getType()); ++ IGCLLVM::FixedVectorType* vector_type = dyn_cast(VecOp->getType()); + if (cVec && vector_type && + isa(cVec->getOperand(0)) && + cast(cVec->getOperand(0))->isZero() && +@@ -2210,7 +2210,7 @@ void GenSpecificPattern::visitBinaryOperator(BinaryOperator& I) + BitCastInst* opBC = cast(op); + + auto opType = opBC->getType(); +- if (!(opType->isVectorTy() && cast(opType)->getElementType()->isIntegerTy(32) && cast(opType)->getNumElements() == 2)) ++ if (!(opType->isVectorTy() && cast(opType)->getElementType()->isIntegerTy(32) && cast(opType)->getNumElements() == 2)) + return nullptr; + + if (opBC->getSrcTy()->isDoubleTy()) +@@ -2630,8 +2630,8 @@ void GenSpecificPattern::visitBitCastInst(BitCastInst& I) + if (zExtInst->getOperand(0)->getType()->isIntegerTy(32) && + isa(bitCastInst->getOperand(0)) && + bitCastInst->getOperand(0)->getType()->isVectorTy() && +- cast(bitCastInst->getOperand(0)->getType())->getElementType()->isIntegerTy(32) && +- cast(bitCastInst->getOperand(0)->getType())->getNumElements() == 2) ++ cast(bitCastInst->getOperand(0)->getType())->getElementType()->isIntegerTy(32) && ++ cast(bitCastInst->getOperand(0)->getType())->getNumElements() == 2) + { + InsertElementInst* insertElementInst = cast(bitCastInst->getOperand(0)); + +@@ -2731,7 +2731,7 @@ void GenSpecificPattern::visitFNeg(llvm::UnaryOperator& I) + } + else + { +- uint32_t vectorSize = cast(I.getType())->getNumElements(); ++ uint32_t vectorSize = cast(I.getType())->getNumElements(); + fsub = llvm::UndefValue::get(I.getType()); + + for (uint32_t i = 0; i < vectorSize; ++i) +@@ -2845,7 +2845,7 @@ Constant* IGCConstProp::replaceShaderConstant(LoadInst* inst) + if (inst->getType()->isVectorTy()) + { + Type* srcEltTy = cast(inst->getType())->getElementType(); +- uint32_t srcNElts = (uint32_t)cast(inst->getType())->getNumElements(); ++ uint32_t srcNElts = (uint32_t)cast(inst->getType())->getNumElements(); + uint32_t eltSize_in_bytes = (unsigned int)srcEltTy->getPrimitiveSizeInBits() / 8; + IRBuilder<> builder(inst); + Value* vectorValue = UndefValue::get(inst->getType()); +@@ -3122,7 +3122,7 @@ Constant* IGCConstProp::ConstantFoldCmpInst(CmpInst* CI) + { + bool AllTrue = true, AllFalse = true; + auto VecOpnd = cast(EEI->getVectorOperand()); +- unsigned N = (unsigned)cast(VecOpnd->getType())->getNumElements(); ++ unsigned N = (unsigned)cast(VecOpnd->getType())->getNumElements(); + for (unsigned i = 0; i < N; ++i) + { + Constant* const Opnd = VecOpnd->getAggregateElement(i); +@@ -3918,8 +3918,8 @@ namespace IGC + BitCastInst* BC = dyn_cast(&*BI++); + if (!BC) continue; + // Skip non-element-wise bitcast. +- VectorType* DstVTy = dyn_cast(BC->getType()); +- VectorType* SrcVTy = dyn_cast(BC->getOperand(0)->getType()); ++ IGCLLVM::FixedVectorType* DstVTy = dyn_cast(BC->getType()); ++ IGCLLVM::FixedVectorType* SrcVTy = dyn_cast(BC->getOperand(0)->getType()); + if (!DstVTy || !SrcVTy || DstVTy->getNumElements() != SrcVTy->getNumElements()) + continue; + // Skip if it's not used only all extractelement. +@@ -4689,7 +4689,7 @@ void SplitIndirectEEtoSel::visitExtractElementInst(llvm::ExtractElementInst& I) + { + using namespace llvm::PatternMatch; + +- VectorType* vecTy = I.getVectorOperandType(); ++ IGCLLVM::FixedVectorType* vecTy = dyn_cast(I.getVectorOperandType()); + uint64_t num = vecTy->getNumElements(); + Type* eleType = vecTy->getElementType(); + +diff --git a/IGC/Compiler/DebugInfo/ScalarVISAModule.cpp b/IGC/Compiler/DebugInfo/ScalarVISAModule.cpp +index 885ad65a..923f296e 100644 +--- a/IGC/Compiler/DebugInfo/ScalarVISAModule.cpp ++++ b/IGC/Compiler/DebugInfo/ScalarVISAModule.cpp +@@ -32,6 +32,7 @@ IN THE SOFTWARE. + #include "DebugInfo/DebugInfoUtils.hpp" + + #include "common/LLVMWarningsPush.hpp" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "llvm/IR/Function.h" + #include "llvm/IR/Module.h" + #include "common/LLVMWarningsPop.hpp" +@@ -581,7 +582,7 @@ ScalarVisaModule::GetVariableLocation(const llvm::Instruction* pInst) const + + if (pType->isVectorTy()) + { +- vectorNumElements = (unsigned)cast(pType)->getNumElements(); ++ vectorNumElements = (unsigned)cast(pType)->getNumElements(); + } + else if (!pVar->IsUniform()) + { +diff --git a/IGC/Compiler/GenTTI.cpp b/IGC/Compiler/GenTTI.cpp +index 34b21c73..9e4d2f26 100644 +--- a/IGC/Compiler/GenTTI.cpp ++++ b/IGC/Compiler/GenTTI.cpp +@@ -216,7 +216,13 @@ namespace llvm { + + // Skip non-simple loop. + if (L->getNumBlocks() != 1) { +- if (IGC_IS_FLAG_ENABLED(EnableAdvRuntimeUnroll) && L->empty()) { ++ if (IGC_IS_FLAG_ENABLED(EnableAdvRuntimeUnroll) && ++#if LLVM_VERSION_MAJOR >= 12 ++ L->isInnermost() ++#else ++ L->empty() ++#endif ++ ) { + auto countNonPHI = [](BasicBlock* BB) { + unsigned Total = BB->size(); + unsigned PHIs = 0; +diff --git a/IGC/Compiler/GenUpdateCB.cpp b/IGC/Compiler/GenUpdateCB.cpp +index 89b414b6..9034066c 100644 +--- a/IGC/Compiler/GenUpdateCB.cpp ++++ b/IGC/Compiler/GenUpdateCB.cpp +@@ -24,6 +24,7 @@ IN THE SOFTWARE. + + #include "common/LLVMWarningsPush.hpp" + #include "llvmWrapper/Bitcode/BitcodeWriter.h" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include + #include + #include "llvm/IR/DebugInfo.h" +@@ -384,7 +385,7 @@ bool GenUpdateCB::runOnFunction(Function& F) + isResInfo(dyn_cast(inst, + GenISAIntrinsic::GenISA_resinfoptr), texId, lod, isUAV)) + { +- unsigned nelems = (unsigned)cast(inst->getType())->getNumElements(); ++ unsigned nelems = (unsigned)cast(inst->getType())->getNumElements(); + SmallVector< SmallVector, 4> extracts(nelems); + if (VectorUsedByConstExtractOnly(inst, extracts)) + { +diff --git a/IGC/Compiler/HandleFRemInstructions.cpp b/IGC/Compiler/HandleFRemInstructions.cpp +index 94995a56..4523f3f0 100644 +--- a/IGC/Compiler/HandleFRemInstructions.cpp ++++ b/IGC/Compiler/HandleFRemInstructions.cpp +@@ -28,6 +28,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "common/LLVMWarningsPop.hpp" + #include "Compiler/IGCPassSupport.h" + #include "Probe/Assertion.h" +@@ -77,7 +78,7 @@ void HandleFRemInstructions::visitFRem(llvm::BinaryOperator& I) + + if (ValType->isVectorTy()) + { +- auto VecCount = cast(ValType)->getNumElements(); ++ auto VecCount = cast(ValType)->getNumElements(); + if (VecCount == 2 || VecCount == 3 || VecCount == 4 || VecCount == 8 || VecCount == 16) + { + VecStr = "v" + std::to_string(VecCount); +diff --git a/IGC/Compiler/HandleLoadStoreInstructions.cpp b/IGC/Compiler/HandleLoadStoreInstructions.cpp +index d18eec73..c5535701 100644 +--- a/IGC/Compiler/HandleLoadStoreInstructions.cpp ++++ b/IGC/Compiler/HandleLoadStoreInstructions.cpp +@@ -77,7 +77,7 @@ void HandleLoadStoreInstructions::visitLoadInst(llvm::LoadInst& I) + + if (I.getType()->isVectorTy()) + { +- numVectorElements = (uint32_t)cast(I.getType())->getNumElements(); ++ numVectorElements = (uint32_t)cast(I.getType())->getNumElements(); + doubleDstType = IGCLLVM::FixedVectorType::get(builder.getDoubleTy(), numVectorElements); + } + uint as = ptrv->getType()->getPointerAddressSpace(); +@@ -163,7 +163,7 @@ void HandleLoadStoreInstructions::visitStoreInst(llvm::StoreInst& I) + + if (I.getValueOperand()->getType()->isVectorTy()) + { +- numVectorElements = (uint32_t)cast(I.getValueOperand()->getType())->getNumElements(); ++ numVectorElements = (uint32_t)cast(I.getValueOperand()->getType())->getNumElements(); + } + + +diff --git a/IGC/Compiler/LegalizationPass.cpp b/IGC/Compiler/LegalizationPass.cpp +index b651350b..9524a495 100644 +--- a/IGC/Compiler/LegalizationPass.cpp ++++ b/IGC/Compiler/LegalizationPass.cpp +@@ -670,7 +670,7 @@ void Legalization::visitBitCastInst(llvm::BitCastInst& I) + if (!isa(pZ->getOperand(0))) + return; + +- auto* pVecTy = cast(pZ->getDestTy()); ++ auto* pVecTy = cast(pZ->getDestTy()); + if (pVecTy->getNumElements() != 3) + return; + +@@ -765,7 +765,7 @@ void Legalization::visitSelectInst(SelectInst& I) + } + else if (I.getType()->isVectorTy()) + { +- unsigned int vecSize = (unsigned)cast(I.getType())->getNumElements(); ++ unsigned int vecSize = (unsigned)cast(I.getType())->getNumElements(); + Value* newVec = UndefValue::get(I.getType()); + m_builder->SetInsertPoint(&I); + for (unsigned int i = 0; i < vecSize; i++) +@@ -1147,7 +1147,7 @@ void Legalization::visitStoreInst(StoreInst& I) + if (ConstantDataVector * vec = dyn_cast(I.getOperand(0))) + { + Value* newVec = UndefValue::get(vec->getType()); +- unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); ++ unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); + for (unsigned int i = 0; i < nbElement; i++) + { + Constant* cst = vec->getElementAsConstant(i); +@@ -1168,7 +1168,7 @@ void Legalization::visitStoreInst(StoreInst& I) + else if (ConstantVector * vec = dyn_cast(I.getOperand(0))) + { + Value* newVec = UndefValue::get(vec->getType()); +- unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); ++ unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); + for (unsigned int i = 0; i < nbElement; i++) + { + Constant* cst = vec->getOperand(i); +@@ -1189,7 +1189,7 @@ void Legalization::visitStoreInst(StoreInst& I) + else if (ConstantAggregateZero * vec = dyn_cast(I.getOperand(0))) + { + Value* newVec = UndefValue::get(vec->getType()); +- unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); ++ unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); + for (unsigned int i = 0; i < nbElement; i++) + { + Constant* cst = vec->getElementValue(i); +@@ -1340,7 +1340,7 @@ void Legalization::visitInsertElementInst(InsertElementInst& I) + if (ConstantDataVector * vec = dyn_cast(I.getOperand(0))) + { + Value* newVec = UndefValue::get(vec->getType()); +- unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); ++ unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); + for (unsigned int i = 0; i < nbElement; i++) + { + Constant* cst = vec->getElementAsConstant(i); +@@ -1360,7 +1360,7 @@ void Legalization::visitInsertElementInst(InsertElementInst& I) + else if (ConstantVector * vec = dyn_cast(I.getOperand(0))) + { + Value* newVec = UndefValue::get(I.getType()); +- unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); ++ unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); + for (unsigned int i = 0; i < nbElement; i++) + { + Constant* cst = vec->getOperand(i); +@@ -1380,7 +1380,7 @@ void Legalization::visitInsertElementInst(InsertElementInst& I) + else if (ConstantAggregateZero * vec = dyn_cast(I.getOperand(0))) + { + Value* newVec = UndefValue::get(I.getType()); +- unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); ++ unsigned int nbElement = (unsigned)cast(vec->getType())->getNumElements(); + for (unsigned int i = 0; i < nbElement; i++) + { + Constant* cst = vec->getElementValue(i); +@@ -1397,7 +1397,7 @@ void Legalization::visitInsertElementInst(InsertElementInst& I) + else if (I.getOperand(1)->getType()->isIntegerTy(1)) + { + // This promotes i1 insertelement to i32 +- unsigned int nbElement = (unsigned)cast(I.getOperand(0)->getType())->getNumElements(); ++ unsigned int nbElement = (unsigned)cast(I.getOperand(0)->getType())->getNumElements(); + Value* newVec = UndefValue::get(IGCLLVM::FixedVectorType::get(m_builder->getInt32Ty(), nbElement)); + PromoteInsertElement(&I, newVec); + } +@@ -1410,7 +1410,7 @@ void Legalization::visitShuffleVectorInst(ShuffleVectorInst& I) + // If the original vector is a constant, just use the scalar constant, + // otherwise extract from the original vector. + +- VectorType* resType = cast(I.getType()); ++ IGCLLVM::FixedVectorType* resType = cast(I.getType()); + Value* newVec = UndefValue::get(resType); + Value* src0 = I.getOperand(0); + Value* src1 = I.getOperand(1); +@@ -1421,7 +1421,7 @@ void Legalization::visitShuffleVectorInst(ShuffleVectorInst& I) + Constant* mask = I.getShuffleMaskForBitcode(); + #endif + // The two inputs are guaranteed to be of the same type +- VectorType* inType = cast(src0->getType()); ++ IGCLLVM::FixedVectorType* inType = cast(src0->getType()); + int inCount = int_cast(inType->getNumElements()); + int inBase = 2; // 2 means using undef + // if inType == resType, use src0/src1 as the input +@@ -1637,7 +1637,7 @@ Type* Legalization::LegalAllocaType(Type* type) const + #endif + legalType = IGCLLVM::FixedVectorType::get( + LegalAllocaType(cast(type)->getElementType()), +- (unsigned)cast(type)->getNumElements()); ++ (unsigned)cast(type)->getNumElements()); + break; + case Type::StructTyID: + return LegalStructAllocaType(type); +@@ -1937,7 +1937,7 @@ void Legalization::visitIntrinsicInst(llvm::IntrinsicInst& I) + Value* newValue = nullptr; + if (srcType->isVectorTy()) + { +- auto sourceVT = cast(srcType); ++ auto sourceVT = cast(srcType); + const unsigned int numElements = (uint32_t)sourceVT->getNumElements(); + Value* dstVec = UndefValue::get(srcType); + for (unsigned int i = 0; i < numElements; ++i) +@@ -2081,7 +2081,7 @@ void Legalization::visitTruncInst(llvm::TruncInst& I) { + } + + Src = BC->getOperand(0); +- VectorType* VTy = dyn_cast(Src->getType()); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Src->getType()); + // Bail out if it's not bitcasted from <3 x i16> + if (!VTy || VTy->getNumElements() != 3 || !VTy->getElementType()->isIntegerTy(16)) + return; +diff --git a/IGC/Compiler/Legalizer/InstPromoter.cpp b/IGC/Compiler/Legalizer/InstPromoter.cpp +index bba1d96d..8fadf89f 100644 +--- a/IGC/Compiler/Legalizer/InstPromoter.cpp ++++ b/IGC/Compiler/Legalizer/InstPromoter.cpp +@@ -25,6 +25,7 @@ IN THE SOFTWARE. + #define DEBUG_TYPE "type-legalizer" + #include "TypeLegalizer.h" + #include "InstPromoter.h" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "common/LLVMWarningsPush.hpp" + #include "llvm/Support/Debug.h" + #include "llvm/Support/MathExtras.h" +@@ -394,10 +395,16 @@ bool InstPromoter::visitBitCastInst(BitCastInst& I) { + unsigned N = + Val->getType()->getScalarSizeInBits() / DestTy->getScalarSizeInBits(); + Value* BC = +- IRB->CreateBitCast(Val, VectorType::get(DestTy->getScalarType(), N)); ++ IRB->CreateBitCast(Val, IGCLLVM::FixedVectorType::get(DestTy->getScalarType(), N)); + + std::vector Vals; +- for (unsigned i = 0; i < DestTy->getVectorNumElements(); i++) ++ for (unsigned i = 0; ++#if LLVM_VERSION_MAJOR >= 12 ++ i < cast(DestTy)->getNumElements(); ++#else ++ i < DestTy->getVectorNumElements(); ++#endif ++ i++) + Vals.push_back(IRB->getInt32(i)); + + Value* Mask = ConstantVector::get(Vals); +diff --git a/IGC/Compiler/Legalizer/InstScalarizer.cpp b/IGC/Compiler/Legalizer/InstScalarizer.cpp +index 3902f740..c8e18cc5 100644 +--- a/IGC/Compiler/Legalizer/InstScalarizer.cpp ++++ b/IGC/Compiler/Legalizer/InstScalarizer.cpp +@@ -130,7 +130,7 @@ bool InstScalarizer::visitLoadInst(LoadInst& I) { + // otherwise, it's broken. + IGC_ASSERT(TL->getTypeSizeInBits(EltTy) == TL->getTypeStoreSizeInBits(EltTy)); + +- unsigned NumElts = (unsigned)cast(OrigTy)->getNumElements(); ++ unsigned NumElts = (unsigned)cast(OrigTy)->getNumElements(); + unsigned Elt = 0; + + Type* NewPtrTy = PointerType::get(EltTy, AS); +@@ -268,7 +268,7 @@ bool InstScalarizer::visitStoreInst(StoreInst& I) { + // otherwise, it's broken. + IGC_ASSERT(TL->getTypeSizeInBits(EltTy) == TL->getTypeStoreSizeInBits(EltTy)); + +- unsigned NumElts = (unsigned)cast(OrigTy)->getNumElements(); ++ unsigned NumElts = (unsigned)cast(OrigTy)->getNumElements(); + unsigned Elt = 0; + + Type* NewPtrTy = PointerType::get(EltTy, AS); +@@ -498,7 +498,7 @@ bool InstScalarizer::visitInsertElementInst(InsertElementInst& I) { + IGC_ASSERT(EltSeq->size()); + IGC_ASSERT(VecSeqCopy.size() % EltSeq->size() == 0); + +- unsigned NumElts = (unsigned)cast(I.getOperand(0)->getType())->getNumElements(); ++ unsigned NumElts = (unsigned)cast(I.getOperand(0)->getType())->getNumElements(); + unsigned i = 0; + for (unsigned Elt = 0; Elt != NumElts; ++Elt) { + if (Elt == Idx) { +diff --git a/IGC/Compiler/Legalizer/PeepholeTypeLegalizer.cpp b/IGC/Compiler/Legalizer/PeepholeTypeLegalizer.cpp +index 28f8ce84..778132c4 100644 +--- a/IGC/Compiler/Legalizer/PeepholeTypeLegalizer.cpp ++++ b/IGC/Compiler/Legalizer/PeepholeTypeLegalizer.cpp +@@ -162,7 +162,7 @@ void PeepholeTypeLegalizer::legalizePhiInstruction(Instruction& I) + + if (quotient > 1) + { +- unsigned numElements = I.getType()->isVectorTy() ? (unsigned)cast(I.getType())->getNumElements() : 1; ++ unsigned numElements = I.getType()->isVectorTy() ? (unsigned)cast(I.getType())->getNumElements() : 1; + Type* newType = IGCLLVM::FixedVectorType::get(Type::getIntNTy(I.getContext(), promoteToInt), quotient * numElements); + + PHINode* newPhi = m_builder->CreatePHI(newType, oldPhi->getNumIncomingValues()); +@@ -223,7 +223,7 @@ void PeepholeTypeLegalizer::legalizeExtractElement(Instruction& I) + unsigned elementWidth = extract->getType()->getScalarSizeInBits(); + if (!isLegalInteger(elementWidth) && extract->getType()->isIntOrIntVectorTy()) + { +- unsigned numElements = (unsigned)cast(extract->getOperand(0)->getType())->getNumElements(); ++ unsigned numElements = (unsigned)cast(extract->getOperand(0)->getType())->getNumElements(); + unsigned quotient, promoteToInt; + promoteInt(elementWidth, quotient, promoteToInt, DL->getLargestLegalIntTypeSizeInBits()); + +@@ -850,7 +850,7 @@ void PeepholeTypeLegalizer::cleanupZExtInst(Instruction& I) { + } + + unsigned ipElmtSize = prevInst->getOperand(0)->getType()->getScalarSizeInBits(); +- unsigned ipVecSize = (unsigned)cast(prevInst->getOperand(0)->getType())->getNumElements(); ++ unsigned ipVecSize = (unsigned)cast(prevInst->getOperand(0)->getType())->getNumElements(); + unsigned convFactor = promoteToInt / ipElmtSize; + + Value* vecRes = UndefValue::get(IGCLLVM::FixedVectorType::get(llvm::Type::getIntNTy(I.getContext(), promoteToInt), quotient)); +diff --git a/IGC/Compiler/Legalizer/TypeLegalizer.cpp b/IGC/Compiler/Legalizer/TypeLegalizer.cpp +index f8f71d71..a46f42bd 100644 +--- a/IGC/Compiler/Legalizer/TypeLegalizer.cpp ++++ b/IGC/Compiler/Legalizer/TypeLegalizer.cpp +@@ -32,6 +32,7 @@ IN THE SOFTWARE. + #include "InstScalarizer.h" + #include "InstElementizer.h" + #include "common/LLVMWarningsPush.hpp" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "llvm/ADT/PostOrderIterator.h" + #include "llvm/IR/CFG.h" + #include "llvm/Support/Debug.h" +@@ -290,7 +291,7 @@ TypeSeq* TypeLegalizer::getScalarizedTypeSeq(Type* Ty) { + } + + Type* EltTy = cast(Ty)->getElementType(); +- for (unsigned i = 0, e = (unsigned)cast(Ty)->getNumElements(); i != e; ++i) ++ for (unsigned i = 0, e = (unsigned)cast(Ty)->getNumElements(); i != e; ++i) + TMI->second.push_back(EltTy); + + return &TMI->second; +diff --git a/IGC/Compiler/Legalizer/TypeLegalizer.h b/IGC/Compiler/Legalizer/TypeLegalizer.h +index f3ce264c..a6910d08 100644 +--- a/IGC/Compiler/Legalizer/TypeLegalizer.h ++++ b/IGC/Compiler/Legalizer/TypeLegalizer.h +@@ -28,6 +28,7 @@ IN THE SOFTWARE. + #include "llvmWrapper/IR/Instructions.h" + #include "llvmWrapper/Analysis/InlineCost.h" + #include "llvmWrapper/IR/InstrTypes.h" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "llvmWrapper/Support/Alignment.h" + #include "llvm/ADT/ArrayRef.h" + #include "llvm/ADT/DenseMap.h" +@@ -287,7 +288,7 @@ namespace IGC { + if (!Ty->isVectorTy()) + return false; + +- unsigned NumElts = (unsigned)cast(Ty)->getNumElements(); ++ unsigned NumElts = (unsigned)cast(Ty)->getNumElements(); + Type* EltTy = cast(Ty)->getElementType(); + const auto& ProfitLengths = getProfitLoadVectorLength(EltTy); + +diff --git a/IGC/Compiler/LowPrecisionOptPass.cpp b/IGC/Compiler/LowPrecisionOptPass.cpp +index 64912719..1d1db949 100644 +--- a/IGC/Compiler/LowPrecisionOptPass.cpp ++++ b/IGC/Compiler/LowPrecisionOptPass.cpp +@@ -252,7 +252,7 @@ bool LowPrecisionOpt::propagateSamplerType(llvm::GenIntrinsicInst& I) + return false; + } + +- VectorType* oldTy = cast(I.getType()); ++ IGCLLVM::FixedVectorType* oldTy = cast(I.getType()); + llvm::SmallVector overloadTys; + auto retTy = IGCLLVM::FixedVectorType::get(newDstType, int_cast(oldTy->getNumElements())); + overloadTys.push_back(retTy); +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.cpp +index 393b4b0a..e9c07b34 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.cpp +@@ -23,6 +23,8 @@ IN THE SOFTWARE. + ============================= end_copyright_notice ===========================*/ + + #include "llvm/Config/llvm-config.h" ++#include "llvmWrapper/IR/DerivedTypes.h" ++#include "llvmWrapper/Analysis/TargetLibraryInfo.h" + #include "Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.h" + #include "Compiler/CodeGenPublic.h" + #include "Compiler/IGCPassSupport.h" +@@ -178,12 +180,11 @@ namespace { + bool doInitialization(Module& M) override { + if(M.size() > 0) + { +- Result.reset(new AddressSpaceAAResult( +- getAnalysis().getTLI( + #if LLVM_VERSION_MAJOR >= 10 +- *M.begin() ++ Function &F = *M.begin(); + #endif +- ), ++ Result.reset(new AddressSpaceAAResult( ++ getAnalysis().getTLI(), + *getAnalysis().getCodeGenContext())); + } + return false; +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/AggregateArguments/AggregateArguments.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/AggregateArguments/AggregateArguments.cpp +index 67535cfc..3cdd2975 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/AggregateArguments/AggregateArguments.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/AggregateArguments/AggregateArguments.cpp +@@ -24,6 +24,7 @@ IN THE SOFTWARE. + + #include "Compiler/Optimizer/OpenCLPasses/AggregateArguments/AggregateArguments.hpp" + #include "Compiler/IGCPassSupport.h" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "common/LLVMWarningsPush.hpp" + #include "llvm/IR/Function.h" + #include "common/LLVMWarningsPop.hpp" +@@ -130,7 +131,7 @@ static uint64_t getNumElements(Type* type) + { + return arrayType->getNumElements(); + } +- if (VectorType * vectorType = dyn_cast(type)) ++ if (IGCLLVM::FixedVectorType * vectorType = dyn_cast(type)) + { + return vectorType->getNumElements(); + } +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/CorrectlyRoundedDivSqrt/CorrectlyRoundedDivSqrt.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/CorrectlyRoundedDivSqrt/CorrectlyRoundedDivSqrt.cpp +index 2a9d7499..79ed0948 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/CorrectlyRoundedDivSqrt/CorrectlyRoundedDivSqrt.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/CorrectlyRoundedDivSqrt/CorrectlyRoundedDivSqrt.cpp +@@ -27,6 +27,7 @@ IN THE SOFTWARE. + #include "Compiler/IGCPassSupport.h" + #include "GenISAIntrinsics/GenIntrinsicInst.h" + ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "common/LLVMWarningsPush.hpp" + #include + #include +@@ -133,7 +134,7 @@ Value* CorrectlyRoundedDivSqrt::emitIEEEDivide(BinaryOperator* I, Value* Op0, Va + } + else + { +- auto vType = dyn_cast(Ty); ++ auto vType = dyn_cast(Ty); + unsigned VecLen = (uint32_t)vType->getNumElements(); + Divide = UndefValue::get(Ty); + for (unsigned i = 0; i < VecLen; i++) +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp +index c5ff3ac0..119520ed 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp +@@ -952,7 +952,11 @@ namespace //Anonymous + { + auto ndrangeStructName = "struct.ndrange_t"; + auto module = _deviceExecCall->getModule(); ++#if LLVM_VERSION_MAJOR >= 12 ++ auto ndrangeTy = llvm::StructType::getTypeByName(module->getContext(), ndrangeStructName); ++#else + auto ndrangeTy = module->getTypeByName(ndrangeStructName); ++#endif + if (ndrangeTy == nullptr) + { + //create struct type +@@ -1697,7 +1701,7 @@ namespace //Anonymous + // this generates string. Ie for char2 element_type is char and num_elements is 2 + // that is done by callin BaseTypeName on vector element type, this recursive call has only a depth of one since + // there are no compound vectors in OpenCL. +- auto vType = llvm::dyn_cast(type); ++ auto vType = llvm::dyn_cast(type); + return BaseTypeName(type->getContainedType(0), os) << vType->getNumElements(); + } + default: +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/KernelArgs.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/KernelArgs.cpp +index 6448463d..7df71079 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/KernelArgs.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/KernelArgs.cpp +@@ -24,6 +24,7 @@ IN THE SOFTWARE. + + #include "Compiler/Optimizer/OpenCLPasses/KernelArgs.hpp" + #include "AdaptorCommon/ImplicitArgs.hpp" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "common/LLVMWarningsPush.hpp" + #include + #include +@@ -388,7 +389,7 @@ unsigned int KernelArg::calcAssociatedArgNo(const ImplicitArg& implicitArg, cons + + unsigned int KernelArg::getNumComponents() const + { +- if (VectorType * vecType = dyn_cast(m_arg->getType())) ++ if (IGCLLVM::FixedVectorType * vecType = dyn_cast(m_arg->getType())) + { + // Vector + return int_cast(vecType->getNumElements()); +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfResolution.cpp +index c7414b8e..74964510 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfResolution.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfResolution.cpp +@@ -719,7 +719,7 @@ Value* OpenCLPrintfResolution::fixupPrintfArg(CallInst& printfCall, Value* arg, + } + + Type* newType = Type::getFloatTy(arg->getContext()); +- if (auto argVT = dyn_cast(arg->getType())) ++ if (auto argVT = dyn_cast(arg->getType())) + { + newType = IGCLLVM::FixedVectorType::get(newType, (unsigned)argVT->getNumElements()); + } +@@ -749,7 +749,7 @@ void OpenCLPrintfResolution::preprocessPrintfArgs(CallInst& printfCall) + IGC::SHADER_PRINTF_TYPE argDataType = getPrintfArgDataType(arg); + arg = fixupPrintfArg(printfCall, arg, argDataType); + uint vecSize = 0; +- if (auto argVType = dyn_cast(argType)) { ++ if (auto argVType = dyn_cast(argType)) { + vecSize = (uint)argVType->getNumElements(); + } + m_argDescriptors.push_back(SPrintfArgDescriptor(argDataType, arg, vecSize)); +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp +index 2ed5a2b6..07f85f4c 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp +@@ -29,6 +29,7 @@ IN THE SOFTWARE. + #include "Compiler/IGCPassSupport.h" + #include "Compiler/CISACodeGen/GenCodeGenModule.h" + #include "Compiler/CISACodeGen/LowerGEPForPrivMem.hpp" ++#include "llvmWrapper/IR/DerivedTypes.h" + #include "common/LLVMWarningsPush.hpp" + #include "llvm/Transforms/Utils/Local.h" + #include "llvm/IR/DataLayout.h" +@@ -604,7 +605,7 @@ public: + Type* scalarptrTy = PointerType::get(scalarType, pLoad->getPointerAddressSpace()); + IGC_ASSERT(scalarType->getPrimitiveSizeInBits() / 8 == elementSize); + Value* vec = UndefValue::get(pLoad->getType()); +- auto pLoadVT = cast(pLoad->getType()); ++ auto pLoadVT = cast(pLoad->getType()); + for (unsigned i = 0, e = (unsigned)pLoadVT->getNumElements(); i < e; ++i) + { + Value* ptr = IRB.CreateIntToPtr(address, scalarptrTy); +@@ -643,7 +644,7 @@ public: + IGC_ASSERT(scalarType->getPrimitiveSizeInBits() / 8 == elementSize); + Value* vec = pStore->getValueOperand(); + +- unsigned vecNumElts = (unsigned)cast(vec->getType())->getNumElements(); ++ unsigned vecNumElts = (unsigned)cast(vec->getType())->getNumElements(); + for (unsigned i = 0; i < vecNumElts; ++i) + { + Value* ptr = IRB.CreateIntToPtr(address, scalarptrTy); +@@ -707,7 +708,7 @@ bool PrivateMemoryResolution::testTransposedMemory(const Type* pTmpType, const T + } + else if(pTmpType->isVectorTy()) + { +- auto pTmpVType = cast(pTmpType); ++ auto pTmpVType = cast(pTmpType); + tmpAllocaSize *= pTmpVType->getNumElements(); + pTmpType = pTmpType->getContainedType(0); + ok = (nullptr != pTmpType); +@@ -815,7 +816,11 @@ bool PrivateMemoryResolution::resolveAllocaInstructions(bool privateOnStack) + // Construct an empty DebugLoc. + IF_DEBUG_INFO(DebugLoc entryDebugLoc); + // Assign with the function location if available. ++#if LLVM_VERSION_MAJOR >= 12 ++ IF_DEBUG_INFO_IF(DISubprogram *subprogram = m_currFunction->getSubprogram(), entryDebugLoc = DILocation::get(subprogram->getContext(), subprogram->getLine(), 0, subprogram);); ++#else + IF_DEBUG_INFO_IF(DISubprogram *subprogram = m_currFunction->getSubprogram(), entryDebugLoc = DebugLoc::get(subprogram->getLine(), 0, subprogram);); ++#endif + IF_DEBUG_INFO(entryBuilder.SetCurrentDebugLocation(entryDebugLoc)); + + if (privateOnStack) +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/ReplaceUnsupportedIntrinsics/ReplaceUnsupportedIntrinsics.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/ReplaceUnsupportedIntrinsics/ReplaceUnsupportedIntrinsics.cpp +index c8414efa..68491d48 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/ReplaceUnsupportedIntrinsics/ReplaceUnsupportedIntrinsics.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/ReplaceUnsupportedIntrinsics/ReplaceUnsupportedIntrinsics.cpp +@@ -254,7 +254,7 @@ Instruction* ReplaceUnsupportedIntrinsics::insertLoop(Instruction* Loc, Value* L + Value* ReplaceUnsupportedIntrinsics::replicateScalar( + Value* ScalarVal, Type* Ty, Instruction* InsertBefore) + { +- VectorType* VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType* VTy = dyn_cast(Ty); + Type* ETy = VTy ? VTy->getElementType() : Ty; + uint32_t sBits = (unsigned int)ScalarVal->getType()->getPrimitiveSizeInBits(); + uint32_t nBits = (unsigned int)ETy->getPrimitiveSizeInBits(); +@@ -868,7 +868,7 @@ void ReplaceUnsupportedIntrinsics::replaceFunnelShift(IntrinsicInst* I) { + } + + Value* numBits = Builder.getIntN(sizeInBits, sizeInBits); +- if (auto IVT = dyn_cast(I->getType())) { ++ if (auto IVT = dyn_cast(I->getType())) { + numBits = ConstantVector::getSplat(IGCLLVM::getElementCount((uint32_t)IVT->getNumElements()), cast(numBits)); + } + auto shiftModulo = Builder.CreateURem(I->getArgOperand(2), numBits); +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncResolution.cpp +index 7188cc50..535d6268 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncResolution.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncResolution.cpp +@@ -303,7 +303,11 @@ static Value* BuildLoadInst(CallInst& CI, unsigned int Offset, Type* DataType) + auto Size = ElemByteSize; + if (DataType->isVectorTy()) + { ++#if LLVM_VERSION_MAJOR >= 12 ++ Size *= cast(DataType)->getNumElements(); ++#else + Size *= DataType->getVectorNumElements(); ++#endif + } + unsigned int AlignedOffset = (Offset / ElemByteSize) * ElemByteSize; + unsigned int LoadByteSize = (Offset == AlignedOffset) ? Size : Size * 2; +diff --git a/IGC/Compiler/Optimizer/PreCompiledFuncImport.cpp b/IGC/Compiler/Optimizer/PreCompiledFuncImport.cpp +index 1fda21d5..63a22864 100644 +--- a/IGC/Compiler/Optimizer/PreCompiledFuncImport.cpp ++++ b/IGC/Compiler/Optimizer/PreCompiledFuncImport.cpp +@@ -340,7 +340,7 @@ bool PreCompiledFuncImport::preProcessDouble() + } + else + { +- uint32_t vectorSize = cast(Inst->getType())->getNumElements(); ++ uint32_t vectorSize = cast(Inst->getType())->getNumElements(); + fsub = llvm::UndefValue::get(Inst->getType()); + + for (uint32_t i = 0; i < vectorSize; ++i) +@@ -936,7 +936,7 @@ void PreCompiledFuncImport::processDivide(BinaryOperator& inst, EmulatedFunction + + Type* argumentType = inst.getOperand(0)->getType(); + +- if (auto argumentVType = dyn_cast(argumentType)) ++ if (auto argumentVType = dyn_cast(argumentType)) + { + numElements = (unsigned)argumentVType->getNumElements(); + } +diff --git a/IGC/Compiler/Optimizer/Scalarizer.cpp b/IGC/Compiler/Optimizer/Scalarizer.cpp +index 4f59eaf9..a4e73a6d 100644 +--- a/IGC/Compiler/Optimizer/Scalarizer.cpp ++++ b/IGC/Compiler/Optimizer/Scalarizer.cpp +@@ -289,7 +289,7 @@ void ScalarizeFunction::scalarizeInstruction(BinaryOperator* BI) + { + V_PRINT(scalarizer, "\t\tBinary instruction\n"); + IGC_ASSERT_MESSAGE(BI, "instruction type dynamic cast failed"); +- VectorType* instType = dyn_cast(BI->getType()); ++ IGCLLVM::FixedVectorType* instType = dyn_cast(BI->getType()); + // Only need handling for vector binary ops + if (!instType) return; + +@@ -349,7 +349,7 @@ void ScalarizeFunction::scalarizeInstruction(CmpInst* CI) + { + V_PRINT(scalarizer, "\t\tCompare instruction\n"); + IGC_ASSERT_MESSAGE(CI, "instruction type dynamic cast failed"); +- VectorType* instType = dyn_cast(CI->getType()); ++ IGCLLVM::FixedVectorType* instType = dyn_cast(CI->getType()); + // Only need handling for vector compares + if (!instType) return; + +@@ -397,13 +397,13 @@ void ScalarizeFunction::scalarizeInstruction(CastInst* CI) + { + V_PRINT(scalarizer, "\t\tCast instruction\n"); + IGC_ASSERT_MESSAGE(CI, "instruction type dynamic cast failed"); +- VectorType* instType = dyn_cast(CI->getType()); ++ IGCLLVM::FixedVectorType* instType = dyn_cast(CI->getType()); + + // For BitCast - we only scalarize if src and dst types have same vector length + if (isa(CI)) + { + if (!instType) return recoverNonScalarizableInst(CI); +- VectorType* srcType = dyn_cast(CI->getOperand(0)->getType()); ++ IGCLLVM::FixedVectorType* srcType = dyn_cast(CI->getOperand(0)->getType()); + if (!srcType || (instType->getNumElements() != srcType->getNumElements())) + { + return recoverNonScalarizableInst(CI); +@@ -458,7 +458,7 @@ void ScalarizeFunction::scalarizeInstruction(PHINode* PI) + { + V_PRINT(scalarizer, "\t\tPHI instruction\n"); + IGC_ASSERT_MESSAGE(PI, "instruction type dynamic cast failed"); +- VectorType* instType = dyn_cast(PI->getType()); ++ IGCLLVM::FixedVectorType* instType = dyn_cast(PI->getType()); + // Only need handling for vector PHI + if (!instType) return; + +@@ -569,7 +569,7 @@ void ScalarizeFunction::scalarizeInstruction(SelectInst* SI) + { + V_PRINT(scalarizer, "\t\tSelect instruction\n"); + IGC_ASSERT_MESSAGE(SI, "instruction type dynamic cast failed"); +- VectorType* instType = dyn_cast(SI->getType()); ++ IGCLLVM::FixedVectorType* instType = dyn_cast(SI->getType()); + // Only need handling for vector select + if (!instType) return; + +@@ -651,7 +651,7 @@ void ScalarizeFunction::scalarizeInstruction(ExtractElementInst* EI) + + // Connect the "extracted" value to all its consumers + uint64_t scalarIndex = cast(scalarIndexVal)->getZExtValue(); +- auto valueVType = cast(vectorValue->getType()); ++ auto valueVType = cast(vectorValue->getType()); + if (static_cast(scalarIndex) < (unsigned)valueVType->getNumElements()) + { + IGC_ASSERT_MESSAGE(NULL != operand[static_cast(scalarIndex)], "SCM error"); +@@ -715,7 +715,7 @@ void ScalarizeFunction::scalarizeInstruction(InsertElementInst* II) + if (isa(sourceVectorValue)) + { + // Scalarize the undef value (generate a scalar undef) +- VectorType* inputVectorType = dyn_cast(sourceVectorValue->getType()); ++ IGCLLVM::FixedVectorType* inputVectorType = dyn_cast(sourceVectorValue->getType()); + IGC_ASSERT_MESSAGE(inputVectorType, "expected vector argument"); + + UndefValue* undefVal = UndefValue::get(inputVectorType->getElementType()); +@@ -756,7 +756,7 @@ void ScalarizeFunction::scalarizeInstruction(ShuffleVectorInst* SI) + IGC_ASSERT(nullptr != sourceVector0Value); + Value* sourceVector1Value = SI->getOperand(1); + IGC_ASSERT(nullptr != sourceVector1Value); +- VectorType* const inputType = dyn_cast(sourceVector0Value->getType()); ++ IGCLLVM::FixedVectorType* const inputType = dyn_cast(sourceVector0Value->getType()); + IGC_ASSERT_MESSAGE(nullptr != inputType, "vector input error"); + IGC_ASSERT_MESSAGE(inputType == sourceVector1Value->getType(), "vector input error"); + unsigned sourceVectorWidth = int_cast(inputType->getNumElements()); +@@ -778,7 +778,7 @@ void ScalarizeFunction::scalarizeInstruction(ShuffleVectorInst* SI) + + // Generate array for shuffled scalar values + SmallVectornewVector; +- unsigned width = int_cast(SI->getType()->getNumElements()); ++ unsigned width = int_cast(dyn_cast(SI->getType())->getNumElements()); + + // Generate undef value, which may be needed as some scalar elements + UndefValue* undef = UndefValue::get(inputType->getElementType()); +@@ -847,7 +847,7 @@ void ScalarizeFunction::scalarizeInstruction(GetElementPtrInst* GI) + + if (baseValue->getType()->isVectorTy()) + { +- width = int_cast(dyn_cast(baseValue->getType())->getNumElements()); ++ width = int_cast(dyn_cast(baseValue->getType())->getNumElements()); + // Obtain the scalarized operands + obtainScalarizedValues(operand1, NULL, baseValue, GI); + ptrTy = dyn_cast(baseValue->getType())->getElementType(); +@@ -858,7 +858,7 @@ void ScalarizeFunction::scalarizeInstruction(GetElementPtrInst* GI) + } + if (indexValue->getType()->isVectorTy()) + { +- width = int_cast(dyn_cast(indexValue->getType())->getNumElements()); ++ width = int_cast(dyn_cast(indexValue->getType())->getNumElements()); + // Obtain the scalarized operands + obtainScalarizedValues(operand2, NULL, indexValue, GI); + } +@@ -897,7 +897,7 @@ void ScalarizeFunction::scalarizeInstruction(LoadInst* LI) + V_PRINT(scalarizer, "\t\tLoad instruction\n"); + IGC_ASSERT_MESSAGE(LI, "instruction type dynamic cast failed"); + +- VectorType* dataType = dyn_cast(LI->getType()); ++ IGCLLVM::FixedVectorType* dataType = dyn_cast(LI->getType()); + if (isScalarizableLoadStoreType(dataType) && m_pDL) + { + // Prepare empty SCM entry for the instruction +@@ -969,7 +969,7 @@ void ScalarizeFunction::scalarizeInstruction(StoreInst* SI) + + int indexPtr = SI->getPointerOperandIndex(); + int indexData = 1 - indexPtr; +- VectorType* dataType = dyn_cast(SI->getOperand(indexData)->getType()); ++ IGCLLVM::FixedVectorType* dataType = dyn_cast(SI->getOperand(indexData)->getType()); + if (isScalarizableLoadStoreType(dataType) && m_pDL) + { + // Get additional info from instruction +@@ -1040,7 +1040,7 @@ void ScalarizeFunction::obtainScalarizedValues(SmallVectorImpl& retValue + { + V_PRINT(scalarizer, "\t\t\tObtaining scalar value... " << *origValue << "\n"); + +- VectorType* origType = dyn_cast(origValue->getType()); ++ IGCLLVM::FixedVectorType* origType = dyn_cast(origValue->getType()); + IGC_ASSERT_MESSAGE(origType, "Value must have a vector type!"); + unsigned width = int_cast(origType->getNumElements()); + +@@ -1202,7 +1202,7 @@ void ScalarizeFunction::obtainVectorValueWhichMightBeScalarizedImpl(Value* vecto + } + + Value* assembledVector = UndefValue::get(vectorVal->getType()); +- unsigned width = int_cast(dyn_cast(vectorVal->getType())->getNumElements()); ++ unsigned width = int_cast(dyn_cast(vectorVal->getType())->getNumElements()); + for (unsigned i = 0; i < width; i++) + { + IGC_ASSERT_MESSAGE(NULL != valueEntry->scalarValues[i], "SCM entry has NULL value"); +@@ -1262,7 +1262,7 @@ void ScalarizeFunction::updateSCMEntryWithValues(ScalarizeFunction::SCMEntry* en + bool matchDbgLoc) + { + IGC_ASSERT_MESSAGE((origValue->getType()->isArrayTy() || origValue->getType()->isVectorTy()), "only Vector values are supported"); +- unsigned width = int_cast(dyn_cast(origValue->getType())->getNumElements()); ++ unsigned width = int_cast(dyn_cast(origValue->getType())->getNumElements()); + + entry->isOriginalVectorRemoved = isOrigValueRemoved; + +@@ -1326,7 +1326,7 @@ void ScalarizeFunction::resolveDeferredInstructions() + Instruction* vectorInst = dyn_cast(current.unresolvedInst); + IGC_ASSERT_MESSAGE(vectorInst, "DRL only handles unresolved instructions"); + +- VectorType* currType = dyn_cast(vectorInst->getType()); ++ IGCLLVM::FixedVectorType* currType = dyn_cast(vectorInst->getType()); + IGC_ASSERT_MESSAGE(currType, "Cannot have DRL of non-vector value"); + unsigned width = int_cast(currType->getNumElements()); + +diff --git a/IGC/Compiler/Optimizer/ValueTracker.cpp b/IGC/Compiler/Optimizer/ValueTracker.cpp +index c06f7312..d8f0d385 100644 +--- a/IGC/Compiler/Optimizer/ValueTracker.cpp ++++ b/IGC/Compiler/Optimizer/ValueTracker.cpp +@@ -178,7 +178,7 @@ Value* ValueTracker::handleExtractElement(ExtractElementInst* E) + { + auto mask = I->getShuffleMask(); + uint shuffleidx = int_cast(mask[(uint)idx]); +- auto vType = dyn_cast(I->getOperand(0)->getType()); ++ auto vType = dyn_cast(I->getOperand(0)->getType()); + baseValue = (shuffleidx < vType->getNumElements()) ? + I->getOperand(0) : I->getOperand(1); + } +diff --git a/IGC/Compiler/VerificationPass.cpp b/IGC/Compiler/VerificationPass.cpp +index 98437d79..40d50f5a 100644 +--- a/IGC/Compiler/VerificationPass.cpp ++++ b/IGC/Compiler/VerificationPass.cpp +@@ -302,7 +302,7 @@ bool VerificationPass::verifyType(Type* type, Value* val) + + case IGCLLVM::VectorTyID: + { +- auto VType = cast(type); ++ auto VType = cast(type); + unsigned typeSize = (unsigned)VType->getNumElements(); + if (!m_IGC_IR_spec.vectorTypeSizes.count(typeSize)) + { +diff --git a/IGC/DebugInfo/DebugInfoUtils.hpp b/IGC/DebugInfo/DebugInfoUtils.hpp +index 7f2e288a..b77a550d 100644 +--- a/IGC/DebugInfo/DebugInfoUtils.hpp ++++ b/IGC/DebugInfo/DebugInfoUtils.hpp +@@ -108,7 +108,11 @@ namespace IGC + IGCLLVM::DIBuilder Builder(M); + llvm::DIGlobalVariable* GV = GVs[j]->getVariable(); + llvm::DIScope* scopeToUse = GV->getScope(); ++#if LLVM_VERSION_MAJOR >= 12 ++ llvm::DILocation* locToUse = llvm::DILocation::get(scopeToUse->getContext(), GV->getLine(), 0, scopeToUse, loc); ++#else + llvm::DILocation* locToUse = llvm::DebugLoc::get(GV->getLine(), 0, scopeToUse, loc); ++#endif + if (llvm::isa(GV->getScope())) + { + // Function has no DebugLoc so it is either internal +diff --git a/IGC/DebugInfo/DwarfDebug.cpp b/IGC/DebugInfo/DwarfDebug.cpp +index 683b83f7..bd9f17b7 100644 +--- a/IGC/DebugInfo/DwarfDebug.cpp ++++ b/IGC/DebugInfo/DwarfDebug.cpp +@@ -2102,9 +2102,17 @@ static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext& Ctx) + // Check for number of operands since the compatibility is cheap here. + if (SP->getNumOperands() > 19) + { ++#if LLVM_VERSION_MAJOR >= 12 ++ return DILocation::get(SP->getContext(), SP->getScopeLine(), 0, SP); ++#else + return DebugLoc::get(SP->getScopeLine(), 0, SP); ++#endif + } ++#if LLVM_VERSION_MAJOR >= 12 ++ return DILocation::get(SP->getContext(), SP->getLine(), 0, SP); ++#else + return DebugLoc::get(SP->getLine(), 0, SP); ++#endif + } + + return DebugLoc(); +diff --git a/IGC/GenISAIntrinsics/GenIntrinsics.cpp b/IGC/GenISAIntrinsics/GenIntrinsics.cpp +index 708cfdaa..772155b2 100644 +--- a/IGC/GenISAIntrinsics/GenIntrinsics.cpp ++++ b/IGC/GenISAIntrinsics/GenIntrinsics.cpp +@@ -204,7 +204,7 @@ static Type *DecodeFixedType(ArrayRef &Infos, + case IITDescriptor::SameVecWidthArgument: { + Type *EltTy = DecodeFixedType(Infos, Tys, Context); + Type *Ty = Tys[D.getArgumentNumber()]; +- if (VectorType *VTy = dyn_cast(Ty)) { ++ if (IGCLLVM::FixedVectorType *VTy = dyn_cast(Ty)) { + return IGCLLVM::FixedVectorType::get(EltTy, int_cast(VTy->getNumElements())); + } + IGC_ASSERT_EXIT_MESSAGE(0, "unhandled"); +@@ -215,7 +215,7 @@ static Type *DecodeFixedType(ArrayRef &Infos, + } + case IITDescriptor::VecOfPtrsToElt: { + Type *Ty = Tys[D.getArgumentNumber()]; +- VectorType *VTy = dyn_cast(Ty); ++ IGCLLVM::FixedVectorType *VTy = dyn_cast(Ty); + if (!VTy) + IGC_ASSERT_EXIT_MESSAGE(0, "Expected an argument of Vector Type"); + Type *EltTy = cast(VTy)->getElementType(); +@@ -434,7 +434,7 @@ static std::string getMangledTypeStr(Type* Ty) { + Result += "f"; + } + else if (isa(Ty)) +- Result += "v" + utostr(cast(Ty)->getNumElements()) + ++ Result += "v" + utostr(cast(Ty)->getNumElements()) + + getMangledTypeStr(cast(Ty)->getElementType()); + else if (Ty) + Result += EVT::getEVT(Ty).getEVTString(); +diff --git a/IGC/LLVM3DBuilder/BuiltinsFrontendDefinitions.hpp b/IGC/LLVM3DBuilder/BuiltinsFrontendDefinitions.hpp +index a89d63b9..a1bc5d2c 100644 +--- a/IGC/LLVM3DBuilder/BuiltinsFrontendDefinitions.hpp ++++ b/IGC/LLVM3DBuilder/BuiltinsFrontendDefinitions.hpp +@@ -4929,7 +4929,7 @@ void LLVM3DBuilder::VectorToScalars( + IGC_ASSERT(nullptr != vector->getType()); + IGC_ASSERT(vector->getType()->isVectorTy()); + +- const unsigned count = (unsigned)llvm::cast(vector->getType())->getNumElements(); ++ const unsigned count = (unsigned)llvm::cast(vector->getType())->getNumElements(); + IGC_ASSERT(1 < count); + IGC_ASSERT(count <= 4); + IGC_ASSERT(count <= maxSize); +diff --git a/IGC/WrapperLLVM/include/llvmWrapper/Support/TypeSize.h b/IGC/WrapperLLVM/include/llvmWrapper/Support/TypeSize.h +index 08e5d6cf..30e29720 100644 +--- a/IGC/WrapperLLVM/include/llvmWrapper/Support/TypeSize.h ++++ b/IGC/WrapperLLVM/include/llvmWrapper/Support/TypeSize.h +@@ -35,10 +35,16 @@ using namespace llvm; + namespace IGCLLVM { + #if LLVM_VERSION_MAJOR < 11 + inline unsigned getElementCount(unsigned EC) { return EC; } +-#else ++#elif LLVM_VERSION_MAJOR == 11 + inline ElementCount getElementCount(unsigned EC) { + return ElementCount(EC, false); + } ++#elif LLVM_VERSION_MAJOR == 12 ++inline ElementCount getElementCount(unsigned EC) { ++ return ElementCount::get(EC, false); ++} ++#else ++#error "unsupported LLVM version" + #endif + } // namespace IGCLLVM + +diff --git a/IGC/WrapperLLVM/include/llvmWrapper/Transforms/Scalar.h b/IGC/WrapperLLVM/include/llvmWrapper/Transforms/Scalar.h +index f6e54fb1..5266ee87 100644 +--- a/IGC/WrapperLLVM/include/llvmWrapper/Transforms/Scalar.h ++++ b/IGC/WrapperLLVM/include/llvmWrapper/Transforms/Scalar.h +@@ -44,7 +44,7 @@ namespace IGCLLVM + { + return llvm::createLoopUnrollPass(OptLevel, false, Threshold, Count, AllowPartial, Runtime, UpperBound, AllowPeeling); + } +-#elif LLVM_VERSION_MAJOR == 9 || LLVM_VERSION_MAJOR == 10 || LLVM_VERSION_MAJOR == 11 ++#elif LLVM_VERSION_MAJOR >= 9 && LLVM_VERSION_MAJOR <= 12 + inline static llvm::Pass * createLoopUnrollPass( + int OptLevel = 2, int Threshold = -1, int Count = -1, + int AllowPartial = -1, int Runtime = -1, +@@ -52,7 +52,7 @@ namespace IGCLLVM + { + return llvm::createLoopUnrollPass(OptLevel, false, false, Threshold, Count, AllowPartial, Runtime, UpperBound, AllowPeeling); + } +-#elif LLVM_VERSION_MAJOR >= 12 ++#else + //DO NOT assume same function signature for all incoming llvm versions! Double check to upgrade! + #error Not supported llvm version. + #endif +diff --git a/IGC/common/igc_resourceDimTypes.h b/IGC/common/igc_resourceDimTypes.h +index 6831b06c..d790330f 100644 +--- a/IGC/common/igc_resourceDimTypes.h ++++ b/IGC/common/igc_resourceDimTypes.h +@@ -66,6 +66,11 @@ namespace IGC + resourceDimTypeId == DIM_2D_TYPE || resourceDimTypeId == DIM_2D_ARRAY_TYPE || + resourceDimTypeId == DIM_3D_TYPE || resourceDimTypeId == DIM_CUBE_TYPE || resourceDimTypeId == DIM_CUBE_ARRAY_TYPE)); + ++#if LLVM_VERSION_MAJOR >= 12 ++ llvm::LLVMContext& llvmCtx = module.getContext(); ++ return llvm::StructType::getTypeByName(llvmCtx, ResourceDimensionTypeName[resourceDimTypeId]); ++#else + return module.getTypeByName(ResourceDimensionTypeName[resourceDimTypeId]); ++#endif + } + } +\ No newline at end of file +-- +2.17.1 + diff --git a/dynamic-layers/clang-layer/recipes-opencl/igc/files/0002-Review-fixes-for-LLVM-12-phase-1.patch b/dynamic-layers/clang-layer/recipes-opencl/igc/files/0002-Review-fixes-for-LLVM-12-phase-1.patch new file mode 100644 index 00000000..6580df75 --- /dev/null +++ b/dynamic-layers/clang-layer/recipes-opencl/igc/files/0002-Review-fixes-for-LLVM-12-phase-1.patch @@ -0,0 +1,318 @@ +From 60136b453bb3a109bfc88c4040b871af9d522ed5 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Zolt=C3=A1n=20B=C3=B6sz=C3=B6rm=C3=A9nyi?= +Date: Thu, 25 Feb 2021 19:40:21 +0100 +Subject: [PATCH 2/3] Review fixes for LLVM 12 phase 1 +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Upstream-Status: Pending + +Signed-off-by: Zoltán Böszörményi +Signed-off-by: Naveen Saini +--- + IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp | 6 +----- + IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp | 6 +----- + IGC/Compiler/CISACodeGen/AdvMemOpt.cpp | 7 ++----- + IGC/Compiler/CISACodeGen/Simd32Profitability.cpp | 7 ++----- + IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp | 11 +---------- + IGC/Compiler/GenTTI.cpp | 9 ++------- + IGC/Compiler/Legalizer/InstPromoter.cpp | 8 +------- + .../DeviceEnqueueFuncs/TransformBlocks.cpp | 6 +----- + .../OpenCLPasses/WIFuncs/WIFuncResolution.cpp | 4 ---- + IGC/Compiler/Optimizer/Scalarizer.cpp | 2 +- + IGC/WrapperLLVM/include/llvmWrapper/IR/DerivedTypes.h | 10 ++++++++++ + .../include/llvmWrapper/Support/TypeSize.h | 4 +--- + .../include/llvmWrapper/Transforms/Utils/LoopUtils.h | 8 ++++++++ + IGC/common/igc_resourceDimTypes.h | 5 ++--- + 14 files changed, 33 insertions(+), 60 deletions(-) + +diff --git a/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp b/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp +index 725a1512..12f42be8 100644 +--- a/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp ++++ b/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp +@@ -1929,11 +1929,7 @@ SPIRVToLLVM::transType(SPIRVType *T) { + auto name = isSubgroupAvcINTELTypeOpCode(OC) ? + OCLSubgroupINTELTypeOpCodeMap::rmap(OC) : + BuiltinOpaqueGenericTypeOpCodeMap::rmap(OC); +-#if LLVM_VERSION_MAJOR >= 12 +- auto *pST = llvm::StructType::getTypeByName(M->getContext(), name); +-#else +- auto *pST = M->getTypeByName(name); +-#endif ++ auto *pST = IGCLLVM::getTypeByName(M, name); + pST = pST ? pST : StructType::create(*Context, name); + + return mapType(T, PointerType::get(pST, getOCLOpaqueTypeAddrSpace(OC))); +diff --git a/IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp b/IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp +index 91b4623c..f4f0dee5 100644 +--- a/IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp ++++ b/IGC/AdaptorOCL/SPIRV/SPIRVUtil.cpp +@@ -93,11 +93,7 @@ saveLLVMModule(Module *M, const std::string &OutputFile) { + PointerType* + getOrCreateOpaquePtrType(Module *M, const std::string &Name, + unsigned AddrSpace) { +-#if LLVM_VERSION_MAJOR >= 12 +- auto OpaqueType = llvm::StructType::getTypeByName(M->getContext(), Name); +-#else +- auto OpaqueType = M->getTypeByName(Name); +-#endif ++ auto OpaqueType = IGCLLVM::getTypeByName(M, Name); + if (!OpaqueType) + OpaqueType = StructType::create(M->getContext(), Name); + return PointerType::get(OpaqueType, AddrSpace); +diff --git a/IGC/Compiler/CISACodeGen/AdvMemOpt.cpp b/IGC/Compiler/CISACodeGen/AdvMemOpt.cpp +index fc45a510..a612a473 100644 +--- a/IGC/Compiler/CISACodeGen/AdvMemOpt.cpp ++++ b/IGC/Compiler/CISACodeGen/AdvMemOpt.cpp +@@ -33,6 +33,7 @@ IN THE SOFTWARE. + #include + #include + #include ++#include "llvmWrapper/Transforms/Utils/LoopUtils.h" + #include "common/LLVMWarningsPop.hpp" + #include "GenISAIntrinsics/GenIntrinsics.h" + #include "Compiler/CISACodeGen/ShaderCodeGen.hpp" +@@ -134,11 +135,7 @@ bool AdvMemOpt::runOnFunction(Function& F) { + for (auto I = LI->begin(), E = LI->end(); I != E; ++I) + for (auto DFI = df_begin(*I), DFE = df_end(*I); DFI != DFE; ++DFI) { + Loop* L = *DFI; +-#if LLVM_VERSION_MAJOR >= 12 +- if (L->isInnermost()) +-#else +- if (L->empty()) +-#endif ++ if (IGCLLVM::isInnermost(L)) + InnermostLoops.push_back(L); + } + +diff --git a/IGC/Compiler/CISACodeGen/Simd32Profitability.cpp b/IGC/Compiler/CISACodeGen/Simd32Profitability.cpp +index c1f4a419..5393d4e8 100644 +--- a/IGC/Compiler/CISACodeGen/Simd32Profitability.cpp ++++ b/IGC/Compiler/CISACodeGen/Simd32Profitability.cpp +@@ -28,6 +28,7 @@ IN THE SOFTWARE. + #include "Compiler/CISACodeGen/Platform.hpp" + #include "common/LLVMWarningsPush.hpp" + #include ++#include + #include + #include + #include +@@ -995,11 +996,7 @@ static bool hasLongStridedLdStInLoop(Function* F, LoopInfo* LI, WIAnalysis* WI) + // Collect innermost simple loop. + for (auto I = LI->begin(), E = LI->end(); I != E; ++I) { + auto L = *I; +-#if LLVM_VERSION_MAJOR >= 12 +- if (!L->isInnermost()) +-#else +- if (!L->empty()) +-#endif ++ if (!IGCLLVM::isInnermost(L)) + continue; + if (L->getNumBlocks() != 2) + continue; +diff --git a/IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp b/IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp +index adf992cb..33473c23 100644 +--- a/IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp ++++ b/IGC/Compiler/ConvertMSAAPayloadTo16Bit.cpp +@@ -153,21 +153,12 @@ void ConvertMSAAPayloadTo16Bit::visitCallInst(CallInst& I) + // In OGL there are uses of ldmcs other then ldms, using vec4float type. + // Fix them to use newly created 16bit ldmcs. + if (ldmcs->getType()->isVectorTy() && +-#if LLVM_VERSION_MAJOR >= 12 +- ldmcs->getType()->getScalarType()->isFloatTy()) +-#else +- ldmcs->getType()->getVectorElementType()->isFloatTy()) +-#endif ++ cast(ldmcs->getType())->getElementType()->isFloatTy()) + { + m_builder->SetInsertPoint(ldmcs); + +-#if LLVM_VERSION_MAJOR >= 12 + uint ldmcsNumOfElements = cast(ldmcs->getType())->getNumElements(); + uint new_mcs_callNumOfElements = cast(new_mcs_call->getType())->getNumElements(); +-#else +- uint ldmcsNumOfElements = ldmcs->getType()->getVectorNumElements(); +- uint new_mcs_callNumOfElements = new_mcs_call->getType()->getVectorNumElements(); +-#endif + + // vec of 16bit ints to vec of 32bit ints + Type* new_mcs_callVecType = IGCLLVM::FixedVectorType::get(m_builder->getInt32Ty(), new_mcs_callNumOfElements); +diff --git a/IGC/Compiler/GenTTI.cpp b/IGC/Compiler/GenTTI.cpp +index 9e4d2f26..53e3ec9e 100644 +--- a/IGC/Compiler/GenTTI.cpp ++++ b/IGC/Compiler/GenTTI.cpp +@@ -37,6 +37,7 @@ IN THE SOFTWARE. + #include "llvm/Analysis/LoopInfo.h" + #include "llvm/Analysis/ScalarEvolution.h" + #include "llvm/Support/raw_ostream.h" ++#include "llvmWrapper/Transforms/Utils/LoopUtils.h" + #include "common/LLVMWarningsPop.hpp" + + using namespace llvm; +@@ -216,13 +217,7 @@ namespace llvm { + + // Skip non-simple loop. + if (L->getNumBlocks() != 1) { +- if (IGC_IS_FLAG_ENABLED(EnableAdvRuntimeUnroll) && +-#if LLVM_VERSION_MAJOR >= 12 +- L->isInnermost() +-#else +- L->empty() +-#endif +- ) { ++ if (IGC_IS_FLAG_ENABLED(EnableAdvRuntimeUnroll) && IGCLLVM::isInnermost(L)) { + auto countNonPHI = [](BasicBlock* BB) { + unsigned Total = BB->size(); + unsigned PHIs = 0; +diff --git a/IGC/Compiler/Legalizer/InstPromoter.cpp b/IGC/Compiler/Legalizer/InstPromoter.cpp +index 8fadf89f..63cbccb5 100644 +--- a/IGC/Compiler/Legalizer/InstPromoter.cpp ++++ b/IGC/Compiler/Legalizer/InstPromoter.cpp +@@ -398,13 +398,7 @@ bool InstPromoter::visitBitCastInst(BitCastInst& I) { + IRB->CreateBitCast(Val, IGCLLVM::FixedVectorType::get(DestTy->getScalarType(), N)); + + std::vector Vals; +- for (unsigned i = 0; +-#if LLVM_VERSION_MAJOR >= 12 +- i < cast(DestTy)->getNumElements(); +-#else +- i < DestTy->getVectorNumElements(); +-#endif +- i++) ++ for (unsigned i = 0; i < cast(DestTy)->getNumElements(); i++) + Vals.push_back(IRB->getInt32(i)); + + Value* Mask = ConstantVector::get(Vals); +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp +index 119520ed..a3681b79 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/DeviceEnqueueFuncs/TransformBlocks.cpp +@@ -952,11 +952,7 @@ namespace //Anonymous + { + auto ndrangeStructName = "struct.ndrange_t"; + auto module = _deviceExecCall->getModule(); +-#if LLVM_VERSION_MAJOR >= 12 +- auto ndrangeTy = llvm::StructType::getTypeByName(module->getContext(), ndrangeStructName); +-#else +- auto ndrangeTy = module->getTypeByName(ndrangeStructName); +-#endif ++ auto ndrangeTy = IGCLLVM::getTypeByName(module, ndrangeStructName); + if (ndrangeTy == nullptr) + { + //create struct type +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncResolution.cpp +index 535d6268..c23c661d 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncResolution.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/WIFuncs/WIFuncResolution.cpp +@@ -303,11 +303,7 @@ static Value* BuildLoadInst(CallInst& CI, unsigned int Offset, Type* DataType) + auto Size = ElemByteSize; + if (DataType->isVectorTy()) + { +-#if LLVM_VERSION_MAJOR >= 12 + Size *= cast(DataType)->getNumElements(); +-#else +- Size *= DataType->getVectorNumElements(); +-#endif + } + unsigned int AlignedOffset = (Offset / ElemByteSize) * ElemByteSize; + unsigned int LoadByteSize = (Offset == AlignedOffset) ? Size : Size * 2; +diff --git a/IGC/Compiler/Optimizer/Scalarizer.cpp b/IGC/Compiler/Optimizer/Scalarizer.cpp +index a4e73a6d..38627553 100644 +--- a/IGC/Compiler/Optimizer/Scalarizer.cpp ++++ b/IGC/Compiler/Optimizer/Scalarizer.cpp +@@ -778,7 +778,7 @@ void ScalarizeFunction::scalarizeInstruction(ShuffleVectorInst* SI) + + // Generate array for shuffled scalar values + SmallVectornewVector; +- unsigned width = int_cast(dyn_cast(SI->getType())->getNumElements()); ++ unsigned width = int_cast(cast(SI->getType())->getNumElements()); + + // Generate undef value, which may be needed as some scalar elements + UndefValue* undef = UndefValue::get(inputType->getElementType()); +diff --git a/IGC/WrapperLLVM/include/llvmWrapper/IR/DerivedTypes.h b/IGC/WrapperLLVM/include/llvmWrapper/IR/DerivedTypes.h +index a3f5a0b8..6a5407bb 100644 +--- a/IGC/WrapperLLVM/include/llvmWrapper/IR/DerivedTypes.h ++++ b/IGC/WrapperLLVM/include/llvmWrapper/IR/DerivedTypes.h +@@ -29,6 +29,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + #include "llvm/Config/llvm-config.h" + #include "llvm/IR/DerivedTypes.h" ++#include "llvm/IR/Module.h" + + namespace IGCLLVM + { +@@ -62,6 +63,15 @@ namespace IGCLLVM + return false; + #endif + } ++ ++ inline llvm::StructType *getTypeByName(llvm::Module *M, llvm::StringRef Name) { ++#if LLVM_VERSION_MAJOR >= 12 ++ return llvm::StructType::getTypeByName(M->getContext(), Name); ++#else ++ return M->getTypeByName(Name); ++#endif ++ } ++ + } + + #endif +diff --git a/IGC/WrapperLLVM/include/llvmWrapper/Support/TypeSize.h b/IGC/WrapperLLVM/include/llvmWrapper/Support/TypeSize.h +index 30e29720..7021820c 100644 +--- a/IGC/WrapperLLVM/include/llvmWrapper/Support/TypeSize.h ++++ b/IGC/WrapperLLVM/include/llvmWrapper/Support/TypeSize.h +@@ -39,12 +39,10 @@ inline unsigned getElementCount(unsigned EC) { return EC; } + inline ElementCount getElementCount(unsigned EC) { + return ElementCount(EC, false); + } +-#elif LLVM_VERSION_MAJOR == 12 ++#else + inline ElementCount getElementCount(unsigned EC) { + return ElementCount::get(EC, false); + } +-#else +-#error "unsupported LLVM version" + #endif + } // namespace IGCLLVM + +diff --git a/IGC/WrapperLLVM/include/llvmWrapper/Transforms/Utils/LoopUtils.h b/IGC/WrapperLLVM/include/llvmWrapper/Transforms/Utils/LoopUtils.h +index db47b00b..bce9cfc1 100644 +--- a/IGC/WrapperLLVM/include/llvmWrapper/Transforms/Utils/LoopUtils.h ++++ b/IGC/WrapperLLVM/include/llvmWrapper/Transforms/Utils/LoopUtils.h +@@ -41,6 +41,14 @@ namespace IGCLLVM + return llvm::InsertPreheaderForLoop(L, DT, LI, nullptr, PreserveLCSSA); + } + #endif ++ ++ inline bool isInnermost(llvm::Loop *L) { ++#if LLVM_VERSION_MAJOR >= 12 ++ return L->isInnermost(); ++#else ++ return L->empty(); ++#endif ++ } + } + + #endif +diff --git a/IGC/common/igc_resourceDimTypes.h b/IGC/common/igc_resourceDimTypes.h +index d790330f..2d675969 100644 +--- a/IGC/common/igc_resourceDimTypes.h ++++ b/IGC/common/igc_resourceDimTypes.h +@@ -67,10 +67,9 @@ namespace IGC + resourceDimTypeId == DIM_3D_TYPE || resourceDimTypeId == DIM_CUBE_TYPE || resourceDimTypeId == DIM_CUBE_ARRAY_TYPE)); + + #if LLVM_VERSION_MAJOR >= 12 +- llvm::LLVMContext& llvmCtx = module.getContext(); +- return llvm::StructType::getTypeByName(llvmCtx, ResourceDimensionTypeName[resourceDimTypeId]); ++ return llvm::StructType::getTypeByName(module.getContext(), ResourceDimensionTypeName[resourceDimTypeId]); + #else + return module.getTypeByName(ResourceDimensionTypeName[resourceDimTypeId]); + #endif + } +-} +\ No newline at end of file ++} +-- +2.17.1 + diff --git a/dynamic-layers/clang-layer/recipes-opencl/igc/files/0003-Review-fixes-for-LLVM-12-phase-2.patch b/dynamic-layers/clang-layer/recipes-opencl/igc/files/0003-Review-fixes-for-LLVM-12-phase-2.patch new file mode 100644 index 00000000..189c2b3f --- /dev/null +++ b/dynamic-layers/clang-layer/recipes-opencl/igc/files/0003-Review-fixes-for-LLVM-12-phase-2.patch @@ -0,0 +1,123 @@ +From c6d333637537263930acb1b6c5dadb0467d745f6 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Zolt=C3=A1n=20B=C3=B6sz=C3=B6rm=C3=A9nyi?= +Date: Fri, 26 Feb 2021 06:39:35 +0100 +Subject: [PATCH 3/3] Review fixes for LLVM 12 phase 2 +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Upstream-Status: Pending + +Signed-off-by: Zoltán Böszörményi +Signed-off-by: Naveen Saini +--- + IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp | 4 ---- + .../AddressSpaceAliasAnalysis.cpp | 10 +++++----- + .../PrivateMemory/PrivateMemoryResolution.cpp | 4 ---- + IGC/DebugInfo/DebugInfoUtils.hpp | 4 ---- + IGC/DebugInfo/DwarfDebug.cpp | 8 -------- + 5 files changed, 5 insertions(+), 25 deletions(-) + +diff --git a/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp b/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp +index 12f42be8..c4f9d1ea 100644 +--- a/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp ++++ b/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp +@@ -1576,11 +1576,7 @@ void SPIRVToLLVMDbgTran::transDbgInfo(SPIRVValue *SV, Value *V) { + Line->getColumn(), scope, iat); + + if(scope && !isa(scope)) +-#if LLVM_VERSION_MAJOR >= 12 + I->setDebugLoc(DILocation::get(scope->getContext(), Line->getLine(), Line->getColumn(), +-#else +- I->setDebugLoc(DebugLoc::get(Line->getLine(), Line->getColumn(), +-#endif + scope, iat)); + } + } +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.cpp +index e9c07b34..b6b779da 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.cpp +@@ -23,8 +23,7 @@ IN THE SOFTWARE. + ============================= end_copyright_notice ===========================*/ + + #include "llvm/Config/llvm-config.h" +-#include "llvmWrapper/IR/DerivedTypes.h" +-#include "llvmWrapper/Analysis/TargetLibraryInfo.h" ++#include + #include "Compiler/Optimizer/OpenCLPasses/AddressSpaceAliasAnalysis/AddressSpaceAliasAnalysis.h" + #include "Compiler/CodeGenPublic.h" + #include "Compiler/IGCPassSupport.h" +@@ -180,11 +179,12 @@ namespace { + bool doInitialization(Module& M) override { + if(M.size() > 0) + { ++ Result.reset(new AddressSpaceAAResult( ++ getAnalysis().getTLI( + #if LLVM_VERSION_MAJOR >= 10 +- Function &F = *M.begin(); ++ *M.begin() + #endif +- Result.reset(new AddressSpaceAAResult( +- getAnalysis().getTLI(), ++ ), + *getAnalysis().getCodeGenContext())); + } + return false; +diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp +index 07f85f4c..98ea616f 100644 +--- a/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp ++++ b/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp +@@ -816,11 +816,7 @@ bool PrivateMemoryResolution::resolveAllocaInstructions(bool privateOnStack) + // Construct an empty DebugLoc. + IF_DEBUG_INFO(DebugLoc entryDebugLoc); + // Assign with the function location if available. +-#if LLVM_VERSION_MAJOR >= 12 + IF_DEBUG_INFO_IF(DISubprogram *subprogram = m_currFunction->getSubprogram(), entryDebugLoc = DILocation::get(subprogram->getContext(), subprogram->getLine(), 0, subprogram);); +-#else +- IF_DEBUG_INFO_IF(DISubprogram *subprogram = m_currFunction->getSubprogram(), entryDebugLoc = DebugLoc::get(subprogram->getLine(), 0, subprogram);); +-#endif + IF_DEBUG_INFO(entryBuilder.SetCurrentDebugLocation(entryDebugLoc)); + + if (privateOnStack) +diff --git a/IGC/DebugInfo/DebugInfoUtils.hpp b/IGC/DebugInfo/DebugInfoUtils.hpp +index b77a550d..88b30a75 100644 +--- a/IGC/DebugInfo/DebugInfoUtils.hpp ++++ b/IGC/DebugInfo/DebugInfoUtils.hpp +@@ -108,11 +108,7 @@ namespace IGC + IGCLLVM::DIBuilder Builder(M); + llvm::DIGlobalVariable* GV = GVs[j]->getVariable(); + llvm::DIScope* scopeToUse = GV->getScope(); +-#if LLVM_VERSION_MAJOR >= 12 + llvm::DILocation* locToUse = llvm::DILocation::get(scopeToUse->getContext(), GV->getLine(), 0, scopeToUse, loc); +-#else +- llvm::DILocation* locToUse = llvm::DebugLoc::get(GV->getLine(), 0, scopeToUse, loc); +-#endif + if (llvm::isa(GV->getScope())) + { + // Function has no DebugLoc so it is either internal +diff --git a/IGC/DebugInfo/DwarfDebug.cpp b/IGC/DebugInfo/DwarfDebug.cpp +index bd9f17b7..3d9f0835 100644 +--- a/IGC/DebugInfo/DwarfDebug.cpp ++++ b/IGC/DebugInfo/DwarfDebug.cpp +@@ -2102,17 +2102,9 @@ static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext& Ctx) + // Check for number of operands since the compatibility is cheap here. + if (SP->getNumOperands() > 19) + { +-#if LLVM_VERSION_MAJOR >= 12 + return DILocation::get(SP->getContext(), SP->getScopeLine(), 0, SP); +-#else +- return DebugLoc::get(SP->getScopeLine(), 0, SP); +-#endif + } +-#if LLVM_VERSION_MAJOR >= 12 + return DILocation::get(SP->getContext(), SP->getLine(), 0, SP); +-#else +- return DebugLoc::get(SP->getLine(), 0, SP); +-#endif + } + + return DebugLoc(); +-- +2.17.1 + diff --git a/dynamic-layers/clang-layer/recipes-opencl/igc/intel-graphics-compiler_1.0.6083.bb b/dynamic-layers/clang-layer/recipes-opencl/igc/intel-graphics-compiler_1.0.6083.bb deleted file mode 100644 index c92b8ea4..00000000 --- a/dynamic-layers/clang-layer/recipes-opencl/igc/intel-graphics-compiler_1.0.6083.bb +++ /dev/null @@ -1,43 +0,0 @@ -SUMMARY = "The Intel(R) Graphics Compiler for OpenCL(TM)" -DESCRIPTION = "The Intel(R) Graphics Compiler for OpenCL(TM) is an \ -llvm based compiler for OpenCL(TM) targeting Intel Gen graphics \ -hardware architecture." - -LICENSE = "MIT & BSD-3-Clause" -LIC_FILES_CHKSUM = "file://IGC/BiFModule/Implementation/ExternalLibraries/libclc/LICENSE.TXT;md5=311cfc1a5b54bab8ed34a0b5fba4373e \ - file://IGC/Compiler/LegalizationPass.cpp;beginline=1;endline=25;md5=4abf1738ff96b18e34186eb763e28eeb \ - file://NOTICES.txt;md5=b12e73994de4fbe0f688cf0bc91512a0" - -SRC_URI = "git://github.com/intel/intel-graphics-compiler.git;protocol=https; \ - file://0001-skip-execution-of-ElfPackager.patch \ - file://link-to-LLVMGenXIntrinsics.patch \ - file://improve_src_package_reproducibility.patch \ - " - -SRCREV = "f6ec355e7e275f87e0756576cd7a390d2365ed48" - -# Used to replace with relative path in reproducibility patch -export B - -S = "${WORKDIR}/git" - -inherit cmake - -COMPATIBLE_HOST = '(x86_64).*-linux' -COMPATIBLE_HOST_libc-musl = "null" - -DEPENDS += " flex-native bison-native clang opencl-clang vc-intrinsics" -DEPENDS_append_class-target = " clang-cross-x86_64" - -RDEPENDS_${PN} += "opencl-clang" - -LLVM_COMPAT_VERSION = "${@bb.utils.contains('LLVMVERSION', '10.0.1', '10.0.0', '11.1.0', d)}" -EXTRA_OECMAKE = "-DIGC_PREFERRED_LLVM_VERSION=${LLVM_COMPAT_VERSION} -DPYTHON_EXECUTABLE=${HOSTTOOLS_DIR}/python3 -DINSTALL_SPIRVDLL=0 -DIGC_BUILD__VC_ENABLED=OFF" - -BBCLASSEXTEND = "native nativesdk" - -UPSTREAM_CHECK_GITTAGREGEX = "^igc-(?P(?!19\..*)\d+(\.\d+)+)$" - -FILES_${PN} += " \ - ${libdir}/igc/NOTICES.txt \ - " diff --git a/dynamic-layers/clang-layer/recipes-opencl/igc/intel-graphics-compiler_1.0.6646.bb b/dynamic-layers/clang-layer/recipes-opencl/igc/intel-graphics-compiler_1.0.6646.bb new file mode 100644 index 00000000..582db553 --- /dev/null +++ b/dynamic-layers/clang-layer/recipes-opencl/igc/intel-graphics-compiler_1.0.6646.bb @@ -0,0 +1,45 @@ +SUMMARY = "The Intel(R) Graphics Compiler for OpenCL(TM)" +DESCRIPTION = "The Intel(R) Graphics Compiler for OpenCL(TM) is an \ +llvm based compiler for OpenCL(TM) targeting Intel Gen graphics \ +hardware architecture." + +LICENSE = "MIT & BSD-3-Clause" +LIC_FILES_CHKSUM = "file://IGC/BiFModule/Implementation/ExternalLibraries/libclc/LICENSE.TXT;md5=311cfc1a5b54bab8ed34a0b5fba4373e \ + file://IGC/Compiler/LegalizationPass.cpp;beginline=1;endline=23;md5=8b19c5999abc484f18232b0905367f9f \ + file://NOTICES.txt;md5=b12e73994de4fbe0f688cf0bc91512a0" + +SRC_URI = "git://github.com/intel/intel-graphics-compiler.git;protocol=https; \ + file://0001-skip-execution-of-ElfPackager.patch \ + file://link-to-LLVMGenXIntrinsics.patch \ + file://improve_src_package_reproducibility.patch \ + file://0001-Fix-build-with-LLVM-12.patch \ + file://0002-Review-fixes-for-LLVM-12-phase-1.patch \ + file://0003-Review-fixes-for-LLVM-12-phase-2.patch \ + " + +SRCREV = "535aaaef03ce338e05e6162118082e6e007e8c10" + +# Used to replace with relative path in reproducibility patch +export B + +S = "${WORKDIR}/git" + +inherit cmake + +COMPATIBLE_HOST = '(x86_64).*-linux' +COMPATIBLE_HOST_libc-musl = "null" + +DEPENDS += " flex-native bison-native clang opencl-clang vc-intrinsics" +DEPENDS_append_class-target = " clang-cross-x86_64" + +RDEPENDS_${PN} += "opencl-clang" + +EXTRA_OECMAKE = "-DIGC_OPTION__LLVM_PREFERRED_VERSION=${LLVMVERSION} -DPYTHON_EXECUTABLE=${HOSTTOOLS_DIR}/python3 -DIGC_BUILD__VC_ENABLED=OFF -DIGC_BUILD__USE_KHRONOS_SPIRV_TRANSLATOR=ON" + +BBCLASSEXTEND = "native nativesdk" + +UPSTREAM_CHECK_GITTAGREGEX = "^igc-(?P(?!19\..*)\d+(\.\d+)+)$" + +FILES_${PN} += " \ + ${libdir}/igc/NOTICES.txt \ + " -- cgit v1.2.3-54-g00ecf