Enablement of GenISAIntrinsics target on LLVM16

Enablement of GenISAIntrinsics target on LLVM16

* Updated ShiftAmount of UnsignedDivisionByConstantInfo calculation based on https://reviews.llvm.org/D141014
* Used newer API (isKillLocation) in getVariableLocation
* Updated LLVMWrapper for InlineFunction and slightly refactored it

Author: bokrzesi

IGC/AdaptorCommon/DivergentBarrierPass.cpp

@@ -424,7 +424,7 @@ void DivergentBarrierPass::generateBody(
     for (auto* CI : ContCalls)
     {
         InlineFunctionInfo IFI;
-        bool CanInline = IGCLLVM::InlineFunction(CI, IFI, nullptr, false);
+        bool CanInline = IGCLLVM::InlineFunction(*CI, IFI, nullptr, false);
         IGC_ASSERT_MESSAGE(CanInline, "failed to inline?");
     }
 

IGC/Compiler/LegalizationPass.cpp

@@ -28,6 +28,7 @@ SPDX-License-Identifier: MIT
 #include "GenISAIntrinsics/GenIntrinsicInst.h"
 #include "Probe/Assertion.h"
 #include "LLVM3DBuilder/BuiltinsFrontend.hpp"
+#include "llvm/Support/Casting.h"
 
 
 using namespace llvm;
@@ -2200,7 +2201,7 @@ void Legalization::visitIntrinsicInst(llvm::IntrinsicInst& I)
                     Value* result = (llvmBuilder.*replacementFunc)(argument);
                     InlineFunctionInfo IFI;
                     I.replaceAllUsesWith(result);
-                    IGCLLVM::InlineFunction(static_cast<CallInst*>(result), IFI, nullptr, false);
+                    IGCLLVM::InlineFunction(*cast<CallBase>(result), IFI, nullptr, false);
                     I.eraseFromParent();
                 }
             };

IGC/Compiler/Optimizer/OpenCLPasses/TransformUnmaskedFunctionsPass/TransformUnmaskedFunctionsPass.cpp

@@ -345,7 +345,7 @@ bool InlineUnmaskedFunctionsPass::runOnModule(llvm::Module& M)
 
         llvm::InlineFunctionInfo IFI;
         for (auto *CB : Calls)
-            IGCLLVM::InlineFunction(CB, IFI);
+            IGCLLVM::InlineFunction(*CB, IFI);
 
         for (Function *F : Funcs) {
             F->removeDeadConstantUsers();

IGC/VectorCompiler/lib/GenXCodeGen/GenXSimdCFConformance.cpp

@@ -3918,7 +3918,7 @@ static void fixBlockDataBeforeRemoval(BasicBlock *BB, BasicBlock *SuccBB) {
   while (auto *DBG = dyn_cast<DbgVariableIntrinsic>(BB->begin())) {
     DBG->moveBefore(InsertBefore);
     if (!HasOnePred)
-      IGCLLVM::setDbgVariableLocationToUndef(DBG);
+      IGCLLVM::setKillLocation(DBG);
   }
 }
 

IGC/VectorCompiler/lib/GenXCodeGen/GenXTidyControlFlow.cpp

@@ -152,7 +152,7 @@ static void moveDbgBeforeBlockRemoval(BasicBlock *BB, Instruction *InsertBefore,
   while (auto *DBG = dyn_cast<llvm::DbgVariableIntrinsic>(BB->begin())) {
     DBG->moveBefore(InsertBefore);
     if (MakeUndef)
-      IGCLLVM::setDbgVariableLocationToUndef(DBG);
+      IGCLLVM::setKillLocation(DBG);
   }
   IGC_ASSERT_MESSAGE(BB->front().isTerminator(), "Expected that only terminator instruction remains");
 }

IGC/WrapperLLVM/include/llvmWrapper/ADT/APInt.h

@@ -71,7 +71,10 @@ inline bool IsAddition(const UnsignedDivisionByConstantInfo &mu) {
 }
 
 inline unsigned ShiftAmount(const UnsignedDivisionByConstantInfo &mu) {
-#if LLVM_VERSION_MAJOR >= 14
+#if LLVM_VERSION_MAJOR >= 16
+    // Basing on this: https://reviews.llvm.org/D141014
+    return IsAddition(mu) ? mu.PostShift + 1 : mu.PostShift;
+#elif LLVM_VERSION_MAJOR >= 14
     return mu.ShiftAmount;
 #else
     return mu.s;

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

@@ -13,35 +13,51 @@ SPDX-License-Identifier: MIT
 #include <llvm/IR/Constants.h>
 #include <llvm/IR/IntrinsicInst.h>
 #include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/Support/Casting.h"
 
 #include "Probe/Assertion.h"
 
 namespace IGCLLVM
 {
+    inline bool isKillLocation(const llvm::DbgVariableIntrinsic* DbgInst)
+    {
+        IGC_ASSERT(DbgInst);
+#if LLVM_VERSION_MAJOR <= 12
+        return llvm::dyn_cast<llvm::UndefValue>(DbgInst->getVariableLocation());
+#elif LLVM_VERSION_MAJOR <= 15
+        return DbgInst->isUndef();
+#else // LLVM_VERSION_MAJOR >= 16
+        return DbgInst->isKillLocation();
+#endif
+    }
+
     inline llvm::Value* getVariableLocation(const llvm::DbgVariableIntrinsic* DbgInst)
     {
         IGC_ASSERT(DbgInst);
 #if LLVM_VERSION_MAJOR <= 12
         return DbgInst->getVariableLocation();
 #else
-        IGC_ASSERT_MESSAGE(((DbgInst->getNumVariableLocationOps() == 1) || DbgInst->isUndef()),
+        IGC_ASSERT_MESSAGE((DbgInst->getNumVariableLocationOps() == 1) || isKillLocation(DbgInst),
                            "unsupported number of location ops");
         return DbgInst->getVariableLocationOp(0);
 #endif
     }
 
-    inline void setDbgVariableLocationToUndef(llvm::DbgVariableIntrinsic *DbgInst)
+    inline void setKillLocation(llvm::DbgVariableIntrinsic *DbgInst)
     {
         IGC_ASSERT(DbgInst);
+
 #if LLVM_VERSION_MAJOR <= 12
         auto *OP = DbgInst->getVariableLocation();
         IGC_ASSERT_MESSAGE(OP != nullptr, "Empty dbg var not supported");
+
         auto *Undef = llvm::UndefValue::get(OP->getType());
-        DbgInst->setOperand(
-            0, llvm::MetadataAsValue::get(DbgInst->getContext(),
-                                          llvm::ValueAsMetadata::get(Undef)));
-#else
+        DbgInst->setOperand(0, llvm::MetadataAsValue::get(DbgInst->getContext(),
+                               llvm::ValueAsMetadata::get(Undef)));
+#elif LLVM_VERSION_MAJOR <= 15
         DbgInst->setUndef();
+#else // LLVM_VERSION_MAJOR >= 16
+        DbgInst->setKillLocation();
 #endif
     }
 

IGC/WrapperLLVM/include/llvmWrapper/Transforms/Utils/Cloning.h

@@ -11,25 +11,25 @@ SPDX-License-Identifier: MIT
 
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Transforms/Utils/Cloning.h"
+#include "llvm/Support/Casting.h"
+#include "Probe/Assertion.h"
 
 namespace IGCLLVM
 {
-    inline bool InlineFunction(llvm::CallInst* CB, llvm::InlineFunctionInfo& IFI,
+    inline bool InlineFunction(llvm::CallBase& CB, llvm::InlineFunctionInfo& IFI,
         llvm::AAResults* CalleeAAR = nullptr,
         bool InsertLifetime = true,
         llvm::Function* ForwardVarArgsTo = nullptr)
     {
-        return llvm::InlineFunction(
 #if LLVM_VERSION_MAJOR < 11
-            CB
-#else
-            *llvm::dyn_cast<llvm::CallBase>(CB)
-#endif
-            , IFI, CalleeAAR, InsertLifetime, ForwardVarArgsTo)
-#if LLVM_VERSION_MAJOR >= 11
-            .isSuccess()
+        auto* CI = llvm::dyn_cast<llvm::CallInst>(&CB);
+        IGC_ASSERT(CI);
+        return llvm::InlineFunction(CI, IFI, CalleeAAR, InsertLifetime, ForwardVarArgsTo);
+#elif LLVM_VERSION_MAJOR <= 15
+        return llvm::InlineFunction(CB, IFI, CalleeAAR, InsertLifetime, ForwardVarArgsTo).isSuccess();
+#else  // LLVM_VERSION_MAJOR >= 16
+        return llvm::InlineFunction(CB, IFI, true, CalleeAAR, InsertLifetime, ForwardVarArgsTo).isSuccess();
 #endif
-            ;
     }
 
 #if LLVM_VERSION_MAJOR < 13

IGC/common/LLVMUtils.cpp

@@ -945,7 +945,7 @@ void InlineHelper::InlineAndOptimize(CallInst* callInst)
     auto* fn = callInst->getFunction();
 
     InlineFunctionInfo IFI;
-    bool CanInline = IGCLLVM::InlineFunction(callInst, IFI);
+    bool CanInline = IGCLLVM::InlineFunction(*callInst, IFI);
     IGC_ASSERT_MESSAGE(CanInline, "failed to inline?");
 
     auto& perFnAllocas = m_InlinedStaticArrayAllocas[fn];