LLVM API Changes

amielcza · igcbot · commit 910e936498ce · 2025-12-19T13:04:53.000+01:00
Adjust the codebase to LLVM17 API changes
diff --git a/IGC/Compiler/CISACodeGen/GenIRLowering.cpp b/IGC/Compiler/CISACodeGen/GenIRLowering.cpp
@@ -28,6 +28,7 @@ SPDX-License-Identifier: MIT
 #include <llvm/Transforms/Utils/Local.h>
 #include "llvmWrapper/IR/Intrinsics.h"
 #include "llvmWrapper/IR/DerivedTypes.h"
+#include "llvmWrapper/Support/MathExtras.h"
 #include "common/LLVMWarningsPop.hpp"
 #include "GenISAIntrinsics/GenIntrinsics.h"
 #include "common/IGCIRBuilder.h"
@@ -1096,8 +1097,8 @@ bool GenIRLowering::combinePack4i8Or2i16(Instruction *inst, uint64_t numBits) co
     // the packed vector.
     KnownBits kb = computeKnownBits(v, DL);
     uint32_t nonZeroBits = ~(static_cast<uint32_t>(kb.Zero.getZExtValue()));
-    uint32_t lsb = findFirstSet(nonZeroBits);
-    uint32_t msb = findLastSet(nonZeroBits);
+    uint32_t lsb = IGCLLVM::findFirstSet(nonZeroBits);
+    uint32_t msb = IGCLLVM::findLastSet(nonZeroBits);
     if (msb != lsb && (msb / numBits) == (lsb / numBits)) {
       uint32_t idx = (prevShlBits / numBits) + (lsb / numBits);
       if (idx < packedVecSize && toPack[idx].first == nullptr) {
diff --git a/IGC/Compiler/CISACodeGen/PatternMatchPass.cpp b/IGC/Compiler/CISACodeGen/PatternMatchPass.cpp
@@ -6117,7 +6117,7 @@ bool isSat(llvm::Instruction *sat, llvm::Value *&source, bool &isUnsigned) {
 
 bool isCandidateForConstantPool(llvm::Value *val) {
   auto ci = dyn_cast<ConstantInt>(val);
-  bool isBigQW = ci && !ci->getValue().isNullValue() && !ci->getValue().isSignedIntN(32);
+  bool isBigQW = ci && !ci->getValue().isZero() && !ci->getValue().isSignedIntN(32);
   bool isDF = val->getType()->isDoubleTy();
   return (isBigQW || isDF);
 }
diff --git a/IGC/Compiler/CustomSafeOptPass.cpp b/IGC/Compiler/CustomSafeOptPass.cpp
@@ -2279,7 +2279,7 @@ void CustomSafeOptPass::visitInsertElementInst(llvm::InsertElementInst &I) {
     if (NextInst->hasOneUse() && NextInst->getOpcode() == Instruction::InsertElement) {
       CurrentInst = NextInst;
     } else {
-      if (VisitedMask.isAllOnesValue()) {
+      if (VisitedMask.isAllOnes()) {
         // All elements are inserted, so input vector is fully overwritten.
         CurrentInst->setOperand(0, PoisonValue::get(VType));
       }
diff --git a/IGC/Compiler/Legalizer/TypeLegalizer.h b/IGC/Compiler/Legalizer/TypeLegalizer.h
@@ -429,7 +429,7 @@ class TypeLegalizer : public FunctionPass {
   Value *zext(Value *V, Type *OrigTy) const {
     IGC_ASSERT(V->getType()->getIntegerBitWidth() > OrigTy->getIntegerBitWidth());
 
-    APInt Mask = APInt::getAllOnesValue(OrigTy->getIntegerBitWidth());
+    APInt Mask = APInt::getAllOnes(OrigTy->getIntegerBitWidth());
     Constant *C = getIntN(V->getType()->getIntegerBitWidth(), Mask.getZExtValue());
     return IRB->CreateAnd(V, C, Twine(V->getName(), ".zext"));
   }
@@ -438,7 +438,7 @@ class TypeLegalizer : public FunctionPass {
     IGC_ASSERT(LHS->getType() == RHS->getType());
     IGC_ASSERT(LHS->getType()->getIntegerBitWidth() > OrigTy->getIntegerBitWidth());
 
-    APInt Mask = APInt::getAllOnesValue(OrigTy->getIntegerBitWidth());
+    APInt Mask = APInt::getAllOnes(OrigTy->getIntegerBitWidth());
     Constant *C = getIntN(LHS->getType()->getIntegerBitWidth(), Mask.getZExtValue());
     return std::make_pair(IRB->CreateAnd(LHS, C, Twine(LHS->getName(), ".zext")),
                           IRB->CreateAnd(RHS, C, Twine(RHS->getName(), ".zext")));
diff --git a/IGC/Compiler/Optimizer/IntDivConstantReduction.cpp b/IGC/Compiler/Optimizer/IntDivConstantReduction.cpp
@@ -119,7 +119,7 @@ struct IntDivConstantReduction : public FunctionPass {
         result = zero;
       else // X/1 == X
         result = dividend;
-    } else if (isSigned && divisorValue.isAllOnesValue()) {
+    } else if (isSigned && divisorValue.isAllOnes()) {
       if (isMod) // X%-1 == 0
         result = zero;
       else // X/-1 == -X
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/JointMatrixFuncsResolutionPass/JointMatrixFuncsResolutionPass.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/JointMatrixFuncsResolutionPass/JointMatrixFuncsResolutionPass.cpp
@@ -2957,10 +2957,7 @@ void JointMatrixFuncsResolutionPass::visitAllocaInst(AllocaInst &I) {
 
   // update debug info
   {
-    TinyPtrVector<DbgDeclareInst *> DDIs;
-    for (DbgVariableIntrinsic *DVI : FindDbgAddrUses(&I))
-      if (auto *DDI = dyn_cast<DbgDeclareInst>(DVI))
-        DDIs.push_back(DDI);
+    TinyPtrVector<DbgDeclareInst *> DDIs = FindDbgDeclareUses(&I);
 
     for (DbgDeclareInst *ddi : DDIs) {
       auto loc = ddi->getDebugLoc();
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp
@@ -1003,19 +1003,17 @@ bool PrivateMemoryResolution::resolveAllocaInstructions(bool privateOnStack) {
 
         // Attaching this metadata is crucial to both properly interpret this locations as stack based ond to inline it.
         // Because these are stack locations we can safely inline them even with optimizations disabled (O0).
-        auto DbgUses = llvm::FindDbgAddrUses(pAI);
-        for (auto Use : DbgUses) {
-          if (auto DbgDcl = dyn_cast_or_null<DbgDeclareInst>(Use)) {
-            unsigned scalarBufferOffset = m_ModAllocaInfo->getBufferOffset(pAI);
-            unsigned bufferSize = m_ModAllocaInfo->getBufferStride(pAI);
-
-            // Attach metadata to instruction containing offset of storage
-            auto OffsetMD =
-                MDNode::get(builder.getContext(), ConstantAsMetadata::get(builder.getInt32(scalarBufferOffset)));
-            DbgDcl->setMetadata("StorageOffset", OffsetMD);
-            auto SizeMD = MDNode::get(builder.getContext(), ConstantAsMetadata::get(builder.getInt32(bufferSize)));
-            DbgDcl->setMetadata("StorageSize", SizeMD);
-          }
+        auto DbgDcls = llvm::FindDbgDeclareUses(pAI);
+        for (auto DbgDcl : DbgDcls) {
+          unsigned scalarBufferOffset = m_ModAllocaInfo->getBufferOffset(pAI);
+          unsigned bufferSize = m_ModAllocaInfo->getBufferStride(pAI);
+
+          // Attach metadata to instruction containing offset of storage
+          auto OffsetMD =
+              MDNode::get(builder.getContext(), ConstantAsMetadata::get(builder.getInt32(scalarBufferOffset)));
+          DbgDcl->setMetadata("StorageOffset", OffsetMD);
+          auto SizeMD = MDNode::get(builder.getContext(), ConstantAsMetadata::get(builder.getInt32(bufferSize)));
+          DbgDcl->setMetadata("StorageSize", SizeMD);
         }
       }
       // Replace all uses of original alloca with the bitcast
@@ -1307,15 +1305,13 @@ bool PrivateMemoryResolution::resolveAllocaInstructions(bool privateOnStack) {
     // We can only safely inline such locations with optimizations disabled.
     // On O2 we have no guarantee the offsets in registers are gonna be valid throughout the entire variable lifetime.
     if (modMD->compOpt.OptDisable) {
-      auto DbgUses = llvm::FindDbgAddrUses(pAI);
-      for (auto Use : DbgUses) {
-        if (auto DbgDcl = dyn_cast_or_null<DbgDeclareInst>(Use)) {
-          // Attach metadata to instruction containing offset of storage
-          unsigned int scalarBufferOffset = m_ModAllocaInfo->getBufferOffset(pAI);
-          auto OffsetMD =
-              MDNode::get(builder.getContext(), ConstantAsMetadata::get(builder.getInt32(scalarBufferOffset)));
-          DbgDcl->setMetadata("StorageOffset", OffsetMD);
-        }
+      auto DbgDcls = llvm::FindDbgDeclareUses(pAI);
+      for (auto DbgDcl : DbgDcls) {
+        // Attach metadata to instruction containing offset of storage
+        unsigned int scalarBufferOffset = m_ModAllocaInfo->getBufferOffset(pAI);
+        auto OffsetMD =
+            MDNode::get(builder.getContext(), ConstantAsMetadata::get(builder.getInt32(scalarBufferOffset)));
+        DbgDcl->setMetadata("StorageOffset", OffsetMD);
       }
     }
 
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/ConstantEncoder.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/ConstantEncoder.cpp
@@ -132,7 +132,7 @@ encodeGlobalValue(const GlobalValue &GV, const DataLayout &DL) {
     vc::diagnose(GV.getContext(), "ConstantEncoder",
                  "Relocation of the provided pointer is not supported", &GV);
   }
-  return {APInt::getNullValue(Size.inBits()),
+  return {APInt::getZero(Size.inBits()),
           {vISA::ZERelocEntry{RelType, 0, GV.getName().str()}}};
 }
 
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXCisaBuilder.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXCisaBuilder.cpp
@@ -4358,7 +4358,7 @@ void GenXKernelBuilder::buildBinaryOperator(BinaryOperator *BO, BaleInfo BI,
       auto C = dyn_cast<ConstantInt>(V);
       if (!C)
         return false;
-      return C->getValue().getMinSignedBits() <= genx::WordBits;
+      return C->getValue().getSignificantBits() <= genx::WordBits;
     });
   };
   if (auto *VT = dyn_cast<IGCLLVM::FixedVectorType>(BO->getType()))
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXLegalization.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXLegalization.cpp
@@ -183,6 +183,7 @@ SPDX-License-Identifier: MIT
 #include "llvm/Transforms/Utils/Local.h"
 
 #include "llvmWrapper/IR/DerivedTypes.h"
+#include "llvmWrapper/Support/MathExtras.h"
 
 #define DEBUG_TYPE "GENX_LEGALIZATION"
 
@@ -1655,7 +1656,7 @@ LegalPredSize GenXLegalization::getLegalPredSize(Value *Pred, unsigned StartIdx,
   // However, Max cannot be any bigger than the misalignment of the offset into
   // the part. For example. if the offset is 4 or 12, the size must be 4, not 8
   // or 16.
-  LogMax = std::min(LogMax, findFirstSet(StartIdx - PP.Offset));
+  LogMax = std::min(LogMax, IGCLLVM::findFirstSet(StartIdx - PP.Offset));
   IGC_ASSERT_EXIT(LogMax < 32);
   Ret.Max = 1 << LogMax;
   // If Min>Max, then we're at the end of that part and we don't need to ensure
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXLowering.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXLowering.cpp
@@ -2955,8 +2955,8 @@ bool GenXLowering::lowerBoolShuffleReplicatedSlice(ShuffleVectorInst *Inst) {
   Src->getShuffleMask(SrcMask);
 
   transform(InstMask, InstMask.begin(), [&](int Idx) {
-    if (Idx == UndefMaskElem)
-      return UndefMaskElem;
+    if (Idx == IGCLLVM::PoisonMaskElem)
+      return IGCLLVM::PoisonMaskElem;
     return SrcMask[Idx];
   });
 
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXLscAddrCalcFolding.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXLscAddrCalcFolding.cpp
@@ -326,7 +326,7 @@ Value *GenXLscAddrCalcFolding::applyLscAddrFolding(Value *Offsets, APInt &Scale,
     return nullptr;
   case Instruction::Add:
   case Instruction::Sub:
-    if (Imm.getMinSignedBits() > Offset.getBitWidth())
+    if (Imm.getSignificantBits() > Offset.getBitWidth())
       return nullptr;
     Imm = Imm.sextOrTrunc(Offset.getBitWidth())
               .smul_ov(Scale.zext(Offset.getBitWidth()), Overflow);
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXReduceIntSize.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXReduceIntSize.cpp
@@ -972,7 +972,7 @@ GenXReduceIntSize::getValueNumBits(Value *V, bool PreferSigned) {
       if (Val == std::numeric_limits<int64_t>::min())
         return ValueNumBits(64, /*isSignExtended=*/false);
       unsigned const BitsWithSignBit =
-          64 - llvm::countLeadingOnes(static_cast<uint64_t>(Val)) + 1;
+          64 - IGCLLVM::countl_one(static_cast<uint64_t>(Val)) + 1;
       return ValueNumBits(BitsWithSignBit, true);
     }
     return NumBits;
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXUtil.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXUtil.cpp
@@ -951,13 +951,14 @@ int ShuffleVectorAnalyzer::getAsUnslice() {
  * extension of ShuffleVectorInst::isZeroEltSplatMask method
  */
 static int nEltSplatMask(ArrayRef<int> Mask) {
-  int Elt = UndefMaskElem;
+  int Elt = IGCLLVM::PoisonMaskElem;
   for (int i = 0, NumElts = Mask.size(); i < NumElts; ++i) {
-    if (Mask[i] == UndefMaskElem)
+    if (Mask[i] == IGCLLVM::PoisonMaskElem)
       continue;
-    if ((Elt != UndefMaskElem) && (Mask[i] != Mask[Elt]))
-      return UndefMaskElem;
-    if ((Mask[i] != UndefMaskElem) && (Elt == UndefMaskElem))
+    if ((Elt != IGCLLVM::PoisonMaskElem) && (Mask[i] != Mask[Elt]))
+      return IGCLLVM::PoisonMaskElem;
+    if ((Mask[i] != IGCLLVM::PoisonMaskElem) &&
+        (Elt == IGCLLVM::PoisonMaskElem))
       Elt = i;
   }
   return Elt;
@@ -974,7 +975,7 @@ ShuffleVectorAnalyzer::SplatInfo ShuffleVectorAnalyzer::getAsSplat() {
   SmallVector<int, 16> MaskAsInts;
   SI->getShuffleMask(MaskAsInts);
   int ShuffleIdx = nEltSplatMask(MaskAsInts);
-  if (ShuffleIdx == UndefMaskElem)
+  if (ShuffleIdx == IGCLLVM::PoisonMaskElem)
     return SplatInfo(nullptr, 0);
 
   // We have position of shuffleindex as output, turn it to real index
diff --git a/IGC/WrapperLLVM/include/llvmWrapper/IR/Instructions.h b/IGC/WrapperLLVM/include/llvmWrapper/IR/Instructions.h
@@ -83,6 +83,12 @@ inline llvm::Type *getGEPIndexedType(llvm::Type *Ty, llvm::ArrayRef<llvm::Value
   return llvm::GetElementPtrInst::getIndexedType(Ty, indices);
 }
 
+#if LLVM_VERSION_MAJOR <= 16
+constexpr int PoisonMaskElem = llvm::UndefMaskElem;
+#else
+constexpr int PoisonMaskElem = llvm::PoisonMaskElem;
+#endif
+
 } // namespace IGCLLVM
 
 #endif
diff --git a/IGC/WrapperLLVM/include/llvmWrapper/IR/LLVMContext.h b/IGC/WrapperLLVM/include/llvmWrapper/IR/LLVMContext.h
@@ -16,13 +16,15 @@ SPDX-License-Identifier: MIT
 
 namespace IGCLLVM {
 inline void setOpaquePointers(llvm::LLVMContext *Ctx, const bool Enable) {
+#if LLVM_VERSION_MAJOR < 17
   IGC_ASSERT_MESSAGE(Ctx, "Null LLVMContext pointer!");
 #if LLVM_VERSION_MAJOR == 14
   if (Enable)
     Ctx->enableOpaquePointers();
 #elif LLVM_VERSION_MAJOR >= 15
   Ctx->setOpaquePointers(Enable);
 #endif // LLVM_VERSION_MAJOR
+#endif
 };
 } // end namespace IGCLLVM
 
diff --git a/IGC/WrapperLLVM/include/llvmWrapper/Support/MathExtras.h b/IGC/WrapperLLVM/include/llvmWrapper/Support/MathExtras.h
@@ -41,6 +41,46 @@ template <typename T> unsigned countl_zero(T Val) {
   return llvm::countLeadingZeros(Val);
 #endif
 }
+
+template <typename T> unsigned countl_one(T Val) {
+#if LLVM_VERSION_MAJOR > 16
+  return llvm::countl_one(Val);
+#else
+  return llvm::countLeadingOnes(Val);
+#endif
+}
+#if LLVM_VERSION_MAJOR > 16
+
+enum ZeroBehavior {
+  /// The returned value is undefined.
+  ZB_Undefined,
+  /// The returned value is numeric_limits<T>::max()
+  ZB_Max
+};
+#endif
+
+#if LLVM_VERSION_MAJOR > 16
+template <typename T> T findFirstSet(T Val, IGCLLVM::ZeroBehavior ZB = IGCLLVM::ZB_Max) {
+  if (ZB == IGCLLVM::ZB_Max && Val == 0)
+    return std::numeric_limits<T>::max();
+  return llvm::countr_zero(Val);
+#else
+template <typename T> T findFirstSet(T Val, llvm::ZeroBehavior ZB = llvm::ZB_Max) {
+  return llvm::findFirstSet(Val, ZB);
+#endif
+}
+
+#if LLVM_VERSION_MAJOR > 16
+template <typename T> T findLastSet(T Val, IGCLLVM::ZeroBehavior ZB = IGCLLVM::ZB_Max) {
+  if (ZB == IGCLLVM::ZB_Max && Val == 0)
+    return std::numeric_limits<T>::max();
+  return llvm::countl_zero(Val) ^ (std::numeric_limits<T>::digits - 1);
+#else
+template <typename T> T findLastSet(T Val, llvm::ZeroBehavior ZB = llvm::ZB_Max) {
+  return llvm::findLastSet(Val, ZB);
+#endif
+}
+
 } // namespace IGCLLVM
 
 #endif

Original file line number	Diff line number	Diff line change
`@@ -6117,7 +6117,7 @@ bool isSat(llvm::Instruction sat, llvm::Value &source, bool &isUnsigned) {`
`6117`	`6117`
`6118`	`6118`	`bool isCandidateForConstantPool(llvm::Value *val) {`
`6119`	`6119`	`auto ci = dyn_cast<ConstantInt>(val);`
`6120`		`- bool isBigQW = ci && !ci->getValue().isNullValue() && !ci->getValue().isSignedIntN(32);`
	`6120`	`+ bool isBigQW = ci && !ci->getValue().isZero() && !ci->getValue().isSignedIntN(32);`
`6121`	`6121`	`bool isDF = val->getType()->isDoubleTy();`
`6122`	`6122`	`return (isBigQW \|\| isDF);`
`6123`	`6123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2279,7 +2279,7 @@ void CustomSafeOptPass::visitInsertElementInst(llvm::InsertElementInst &I) {`
`2279`	`2279`	`if (NextInst->hasOneUse() && NextInst->getOpcode() == Instruction::InsertElement) {`
`2280`	`2280`	`CurrentInst = NextInst;`
`2281`	`2281`	`} else {`
`2282`		`- if (VisitedMask.isAllOnesValue()) {`
	`2282`	`+ if (VisitedMask.isAllOnes()) {`
`2283`	`2283`	`// All elements are inserted, so input vector is fully overwritten.`
`2284`	`2284`	`CurrentInst->setOperand(0, PoisonValue::get(VType));`
`2285`	`2285`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ encodeGlobalValue(const GlobalValue &GV, const DataLayout &DL) {`
`132`	`132`	`vc::diagnose(GV.getContext(), "ConstantEncoder",`
`133`	`133`	`"Relocation of the provided pointer is not supported", &GV);`
`134`	`134`	`}`
`135`		`- return {APInt::getNullValue(Size.inBits()),`
	`135`	`+ return {APInt::getZero(Size.inBits()),`
`136`	`136`	`{vISA::ZERelocEntry{RelType, 0, GV.getName().str()}}};`
`137`	`137`	`}`
`138`	`138`