LLVM API changes minor fixes

Wrap removed ConstantExpr::getUIToFP.

LLVM 22 PatternMatch.h now calls matcher.match() on a const matcher
object. Mark match() const in FMaxMinCast_match,
ClampWithConstants_match, and IsNaN_match. For LLVM < 22 compat, mark
by-value sub-matcher members mutable so their non-const match() is
still callable on older LLVM versions.

Author: karolzwolak

IGC/Compiler/CISACodeGen/GenIRLowering.cpp

@@ -77,8 +77,8 @@ char GenIRLowering::ID = 0;
 
 template <typename LHS_t, typename RHS_t, typename Pred_t> struct FMaxMinCast_match {
   unsigned &CastOpcode;
-  LHS_t L;
-  RHS_t R;
+  mutable LHS_t L;
+  mutable RHS_t R;
 
   FMaxMinCast_match(unsigned &Opcode, const LHS_t &LHS, const RHS_t &RHS) : CastOpcode(Opcode), L(LHS), R(RHS) {}
 
@@ -100,7 +100,7 @@ template <typename LHS_t, typename RHS_t, typename Pred_t> struct FMaxMinCast_ma
     return false;
   }
 
-  template <typename OpTy> bool match(OpTy *V) {
+  template <typename OpTy> bool match(OpTy *V) const {
     SelectInst *SI = dyn_cast<SelectInst>(V);
     if (!SI)
       return false;
@@ -158,12 +158,12 @@ inline FMaxMinCast_match<LHS, RHS, llvm::PatternMatch::ofmin_pred_ty> m_OrdFMinC
 template <typename Op_t, typename ConstTy> struct ClampWithConstants_match {
   typedef ConstTy *ConstPtrTy;
 
-  Op_t Op;
+  mutable Op_t Op;
   ConstPtrTy &CMin, &CMax;
 
   ClampWithConstants_match(const Op_t &OpMatch, ConstPtrTy &Min, ConstPtrTy &Max) : Op(OpMatch), CMin(Min), CMax(Max) {}
 
-  template <typename OpTy> bool match(OpTy *V) {
+  template <typename OpTy> bool match(OpTy *V) const {
     CallInst *GII = dyn_cast<CallInst>(V);
     if (!GII)
       return false;

IGC/Compiler/CISACodeGen/PatternMatchPass.cpp

@@ -23,6 +23,7 @@ SPDX-License-Identifier: MIT
 #include <llvmWrapper/IR/Instructions.h>
 #include "llvmWrapper/Support/Alignment.h"
 #include <llvmWrapper/IR/CmpPredicate.h>
+#include "llvmWrapper/IR/Constants.h"
 #include "Compiler/IGCPassSupport.h"
 #include "Compiler/InitializePasses.h"
 #include "Compiler/DebugInfo/ScalarVISAModule.h"
@@ -480,12 +481,12 @@ void CodeGenPatternMatch::SetPatternRoot(llvm::Instruction &inst) {
 template <typename Op_t, typename ConstTy> struct ClampWithConstants_match {
   typedef ConstTy *ConstPtrTy;
 
-  Op_t Op;
+  mutable Op_t Op;
   ConstPtrTy &CMin, &CMax;
 
   ClampWithConstants_match(const Op_t &OpMatch, ConstPtrTy &Min, ConstPtrTy &Max) : Op(OpMatch), CMin(Min), CMax(Max) {}
 
-  template <typename OpTy> bool match(OpTy *V) {
+  template <typename OpTy> bool match(OpTy *V) const {
     CallInst *GII = dyn_cast<CallInst>(V);
     if (!GII)
       return false;
@@ -540,7 +541,7 @@ template <typename Op_t> struct IsNaN_match {
 
   IsNaN_match(const Op_t &OpMatch) : Op(OpMatch) {}
 
-  template <typename OpTy> bool match(OpTy *V) {
+  template <typename OpTy> bool match(OpTy *V) const {
     using namespace llvm::PatternMatch;
 
     FCmpInst *FCI = dyn_cast<FCmpInst>(V);
@@ -676,8 +677,8 @@ CodeGenPatternMatch::isFPToUnsignedIntSatWithInexactConstant(llvm::SelectInst *S
   if (!CMax || !CMin || !CMax->isMaxValue(false) || !CMin->isMinValue(false))
     return std::make_tuple(nullptr, 0, ISA_TYPE_F);
 
-  Constant *FMin = ConstantExpr::getUIToFP(CMin, Ty);
-  Constant *FMax = ConstantExpr::getUIToFP(CMax, Ty);
+  Constant *FMin = IGCLLVM::ConstantExpr::getUIToFP(CMin, Ty);
+  Constant *FMax = IGCLLVM::ConstantExpr::getUIToFP(CMax, Ty);
 
   IGCLLVM::FCmpInstPredicate Pred(FCmpInst::FCMP_FALSE);
   if (!match(Cond2, m_FCmp(Pred, m_Specific(X), m_Specific(FMax))))

IGC/VectorCompiler/lib/GenXOpts/CMTrans/GenXTypeLegalization.cpp

@@ -25,6 +25,7 @@ SPDX-License-Identifier: MIT
 #include "Probe/Assertion.h"
 
 #include "llvmWrapper/IR/IRBuilder.h"
+#include "llvmWrapper/IR/Constants.h"
 
 #include <llvm/IR/Dominators.h>
 #include <llvm/IR/Function.h>
@@ -130,7 +131,7 @@ Value *GenXTypeLegalization::getLegalizedValue(Value *OldV) {
   if (auto *C = dyn_cast<Constant>(OldV)) {
     auto *NewCType = getLegalizedType(C->getType());
     // TODO: consider signess here.
-    return ConstantExpr::getZExt(C, NewCType);
+    return IGCLLVM::ConstantExpr::getZExt(C, NewCType);
   }
   auto *NewV = ValueMap[OldV];
   // Instructions are visited in topological order so a record should exist.

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

@@ -23,6 +23,27 @@ inline llvm::Constant *getShuffleVector(llvm::Constant *V1, llvm::Constant *V2,
                                         llvm::Type *OnlyIfReducedTy = nullptr) {
   return llvm::ConstantExpr::getShuffleVector(V1, V2, static_cast<int>(Mask), OnlyIfReducedTy);
 }
+inline llvm::Constant *getZExt(llvm::Constant *C, llvm::Type *Ty, bool OnlyIfReduced = false) {
+#if LLVM_VERSION_MAJOR < 22
+  return llvm::ConstantExpr::getZExt(C, Ty, OnlyIfReduced);
+#else
+  return llvm::ConstantExpr::getCast(llvm::Instruction::ZExt, C, Ty, OnlyIfReduced);
+#endif
+}
+inline llvm::Constant *getSExt(llvm::Constant *C, llvm::Type *Ty, bool OnlyIfReduced = false) {
+#if LLVM_VERSION_MAJOR < 22
+  return llvm::ConstantExpr::getSExt(C, Ty, OnlyIfReduced);
+#else
+  return llvm::ConstantExpr::getCast(llvm::Instruction::SExt, C, Ty, OnlyIfReduced);
+#endif
+}
+inline llvm::Constant *getUIToFP(llvm::Constant *C, llvm::Type *Ty, bool OnlyIfReduced = false) {
+#if LLVM_VERSION_MAJOR < 22
+  return llvm::ConstantExpr::getUIToFP(C, Ty, OnlyIfReduced);
+#else
+  return llvm::ConstantExpr::getCast(llvm::Instruction::UIToFP, C, Ty, OnlyIfReduced);
+#endif
+}
 } // namespace ConstantExpr
 
 namespace ConstantFixedVector {