Enable LLVM 15 buildability by wrapping getPointerElementType()

Direct usage is deprecated in llvm/llvm-project@c99424f76 as part of the opaque
pointer switch.

GenXIntrinsics/include/llvmVCWrapper/IR/Type.h

@@ -0,0 +1,28 @@
+/*========================== begin_copyright_notice ============================
+
+Copyright (C) 2022 Intel Corporation
+
+SPDX-License-Identifier: MIT
+
+============================= end_copyright_notice ===========================*/
+
+#ifndef VCINTR_IR_TYPE_H
+#define VCINTR_IR_TYPE_H
+
+#include <llvm/IR/Type.h>
+
+namespace VCINTR {
+namespace Type {
+
+inline llvm::Type *getNonOpaquePtrEltTy(const llvm::Type *PTy) {
+#if VC_INTR_LLVM_VERSION_MAJOR < 14
+  return PTy->getPointerElementType();
+#else  // VC_INTR_LLVM_VERSION_MAJOR < 14
+  return PTy->getNonOpaquePointerElementType();
+#endif // VC_INTR_LLVM_VERSION_MAJOR < 14
+}
+
+} // namespace Type
+} // namespace VCINTR
+
+#endif // VCINTR_IR_TYPE_H

GenXIntrinsics/lib/GenXIntrinsics/AdaptorsCommon.cpp

@@ -10,7 +10,8 @@ SPDX-License-Identifier: MIT
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
-#include "llvm/IR/Type.h"
+
+#include "llvmVCWrapper/IR/Type.h"
 
 namespace llvm {
 namespace genx {
@@ -43,7 +44,7 @@ void legalizeParamAttributes(Function *F) {
       continue;
 #endif // VC_INTR_LLVM_VERSION_MAJOR >= 13
 
-    auto *ElemType = PTy->getPointerElementType();
+    auto *ElemType = VCINTR::Type::getNonOpaquePtrEltTy(PTy);
 
     legalizeAttribute(Arg, ElemType, Attribute::ByVal);
 

GenXIntrinsics/lib/GenXIntrinsics/GenXIntrinsics.cpp

@@ -33,6 +33,7 @@ See LICENSE.TXT for details.
 
 #include "llvmVCWrapper/IR/DerivedTypes.h"
 #include "llvmVCWrapper/IR/Intrinsics.h"
+#include "llvmVCWrapper/IR/Type.h"
 
 #include <cstring>
 #include <map>
@@ -416,7 +417,7 @@ static std::string getMangledTypeStr(Type *Ty) {
     if (PTyp->isOpaque())
       return Result;
 #endif // VC_INTR_LLVM_VERSION_MAJOR >= 13
-    Result += getMangledTypeStr(PTyp->getPointerElementType());
+    Result += getMangledTypeStr(VCINTR::Type::getNonOpaquePtrEltTy(PTyp));
   } else if (ArrayType *ATyp = dyn_cast<ArrayType>(Ty)) {
     Result += "a" + llvm::utostr(ATyp->getNumElements()) +
               getMangledTypeStr(ATyp->getElementType());

GenXIntrinsics/lib/GenXIntrinsics/GenXSPIRVReaderAdaptor.cpp

@@ -25,6 +25,7 @@ SPDX-License-Identifier: MIT
 
 #include "llvmVCWrapper/IR/Attributes.h"
 #include "llvmVCWrapper/IR/Function.h"
+#include "llvmVCWrapper/IR/Type.h"
 
 using namespace llvm;
 using namespace genx;
@@ -295,7 +296,7 @@ static SPIRVArgDesc analyzeKernelArg(const Argument &Arg) {
       AddressSpace != SPIRVParams::SPIRVConstantAS)
     return {SPIRVType::Other};
 
-  Type *PointeeTy = PointerTy->getPointerElementType();
+  Type *PointeeTy = VCINTR::Type::getNonOpaquePtrEltTy(PointerTy);
   // Not a pointer to struct, cannot be sampler or image.
   if (!isa<StructType>(PointeeTy))
     return {SPIRVType::Pointer};
@@ -425,8 +426,8 @@ static std::string mapSPIRVDescToArgDesc(SPIRVArgDesc SPIRVDesc) {
 static PointerType *getKernelArgPointerType(PointerType *ConvertTy,
                                             PointerType *ArgTy) {
   auto AddressSpace = ConvertTy->getPointerAddressSpace();
-  auto *ConvertPointeeTy = ConvertTy->getPointerElementType();
-  auto *ArgPointeeTy = ArgTy->getPointerElementType();
+  auto *ConvertPointeeTy = VCINTR::Type::getNonOpaquePtrEltTy(ConvertTy);
+  auto *ArgPointeeTy = VCINTR::Type::getNonOpaquePtrEltTy(ArgTy);
 
   if (ConvertPointeeTy->isAggregateType())
     return ConvertTy;

GenXIntrinsics/lib/GenXIntrinsics/GenXSimdCFLowering.cpp

@@ -174,6 +174,7 @@ SPDX-License-Identifier: MIT
 #include <set>
 
 #include "llvmVCWrapper/IR/DerivedTypes.h"
+#include "llvmVCWrapper/IR/Type.h"
 
 #define DEBUG_TYPE "cmsimdcflowering"
 
@@ -413,7 +414,7 @@ void CMSimdCFLowering::initializeVolatileGlobals(Module &M) {
         auto AS1 = LI->getPointerAddressSpace();
         if (AS1 != AS0) {
           auto PtrTy = cast<PointerType>(Ptr->getType());
-          PtrTy = PointerType::get(PtrTy->getPointerElementType(), AS0);
+          PtrTy = PointerType::get(VCINTR::Type::getNonOpaquePtrEltTy(PtrTy), AS0);
           Ptr = Builder.CreateAddrSpaceCast(Ptr, PtrTy);
         }
         Type* Tys[] = { LI->getType(), Ptr->getType() };
@@ -430,7 +431,7 @@ void CMSimdCFLowering::initializeVolatileGlobals(Module &M) {
         auto AS1 = SI->getPointerAddressSpace();
         if (AS1 != AS0) {
           auto PtrTy = cast<PointerType>(Ptr->getType());
-          PtrTy = PointerType::get(PtrTy->getPointerElementType(), AS0);
+          PtrTy = PointerType::get(VCINTR::Type::getNonOpaquePtrEltTy(PtrTy), AS0);
           Ptr = Builder.CreateAddrSpaceCast(Ptr, PtrTy);
         }
         Type* Tys[] = { SI->getValueOperand()->getType(), Ptr->getType() };
@@ -1441,14 +1442,14 @@ void CMSimdCFLower::predicateStore(Instruction *SI, unsigned SimdWidth)
   Instruction *Load = nullptr;
   if (auto SInst = dyn_cast<StoreInst>(SI)) {
     auto *PtrOp = SInst->getPointerOperand();
-    Load = new LoadInst(PtrOp->getType()->getPointerElementType(), PtrOp,
+    Load = new LoadInst(VCINTR::Type::getNonOpaquePtrEltTy(PtrOp->getType()), PtrOp,
                         PtrOp->getName() + ".simdcfpred.load",
                         false /* isVolatile */, SI);
   }
   else {
     auto ID = GenXIntrinsic::genx_vload;
     Value *Addr = SI->getOperand(1);
-    Type *Tys[] = {Addr->getType()->getPointerElementType(), Addr->getType()};
+    Type *Tys[] = {VCINTR::Type::getNonOpaquePtrEltTy(Addr->getType()), Addr->getType()};
     auto Fn = GenXIntrinsic::getGenXDeclaration(
         SI->getParent()->getParent()->getParent(), ID, Tys);
     Load = CallInst::Create(Fn, Addr, ".simdcfpred.vload", SI);
@@ -1694,11 +1695,11 @@ void CMSimdCFLower::lowerSimdCF()
         Br);
     Value *RMAddr = getRMAddr(UIP, SimdWidth);
     Instruction *OldEM =
-        new LoadInst(EMVar->getType()->getPointerElementType(), EMVar,
+        new LoadInst(VCINTR::Type::getNonOpaquePtrEltTy(EMVar->getType()), EMVar,
                      EMVar->getName(), false /* isVolatile */, Br);
     OldEM->setDebugLoc(DL);
     auto OldRM =
-        new LoadInst(RMAddr->getType()->getPointerElementType(), RMAddr,
+        new LoadInst(VCINTR::Type::getNonOpaquePtrEltTy(RMAddr->getType()), RMAddr,
                      RMAddr->getName(), false /* isVolatile */, Br);
     OldRM->setDebugLoc(DL);
     Type *Tys[] = { OldEM->getType(), OldRM->getType() };
@@ -1733,11 +1734,11 @@ void CMSimdCFLower::lowerSimdCF()
     // Insert {NewEM,BranchCond} = llvm.genx.simdcf.join(OldEM,RM)
     Value *RMAddr = getRMAddr(JP, SimdWidth);
     Instruction *OldEM =
-        new LoadInst(EMVar->getType()->getPointerElementType(), EMVar,
+        new LoadInst(VCINTR::Type::getNonOpaquePtrEltTy(EMVar->getType()), EMVar,
                      EMVar->getName(), false /* isVolatile */, InsertBefore);
     OldEM->setDebugLoc(DL);
     auto RM =
-        new LoadInst(RMAddr->getType()->getPointerElementType(), RMAddr,
+        new LoadInst(VCINTR::Type::getNonOpaquePtrEltTy(RMAddr->getType()), RMAddr,
                      RMAddr->getName(), false /* isVolatile */, InsertBefore);
     RM->setDebugLoc(DL);
     Type *Tys[] = { OldEM->getType(), RM->getType() };
@@ -1818,7 +1819,7 @@ void CMSimdCFLower::lowerUnmaskOps() {
           // put in genx_simdcf_savemask and genx_simdcf_remask
           auto DL = CIB->getDebugLoc();
           Instruction *OldEM =
-              new LoadInst(EMVar->getType()->getPointerElementType(), EMVar,
+              new LoadInst(VCINTR::Type::getNonOpaquePtrEltTy(EMVar->getType()), EMVar,
                            EMVar->getName(), false /* isVolatile */, CIB);
           OldEM->setDebugLoc(DL);
           Type *Tys[] = {OldEM->getType()};
@@ -1841,7 +1842,7 @@ void CMSimdCFLower::lowerUnmaskOps() {
               ->setDebugLoc(DL);
           // put in genx_simdcf_remask
           DL = CIE->getDebugLoc();
-          OldEM = new LoadInst(EMVar->getType()->getPointerElementType(), EMVar,
+          OldEM = new LoadInst(VCINTR::Type::getNonOpaquePtrEltTy(EMVar->getType()), EMVar,
                                EMVar->getName(), false /* isVolatile */, CIE);
           OldEM->setDebugLoc(DL);
           Type *Ty2s[] = {OldEM->getType()};
@@ -1918,7 +1919,7 @@ Value *CMSimdCFLower::replicateMask(Value *EM, Instruction *InsertBefore,
 Instruction *CMSimdCFLower::loadExecutionMask(Instruction *InsertBefore,
                                               unsigned SimdWidth) {
   Instruction *EM =
-      new LoadInst(EMVar->getType()->getPointerElementType(), EMVar,
+      new LoadInst(VCINTR::Type::getNonOpaquePtrEltTy(EMVar->getType()), EMVar,
                    EMVar->getName(), false /* isVolatile */, InsertBefore);
 
   // If the simd width is not MAX_SIMD_CF_WIDTH, extract the part of EM we want.
@@ -1962,7 +1963,7 @@ Value *CMSimdCFLower::getRMAddr(BasicBlock *JP, unsigned SimdWidth)
   }
   assert(!SimdWidth ||
          VCINTR::VectorType::getNumElements(cast<VectorType>(
-             (*RMAddr)->getType()->getPointerElementType())) == SimdWidth);
+             VCINTR::Type::getNonOpaquePtrEltTy((*RMAddr)->getType()))) == SimdWidth);
   return *RMAddr;
 }
 

GenXIntrinsics/lib/GenXIntrinsics/GenXSingleElementVectorUtil.cpp

@@ -27,6 +27,7 @@ SPDX-License-Identifier: MIT
 #include "llvmVCWrapper/IR/DerivedTypes.h"
 #include "llvmVCWrapper/IR/Function.h"
 #include "llvmVCWrapper/IR/Instructions.h"
+#include "llvmVCWrapper/IR/Type.h"
 #include "llvmVCWrapper/Support/Alignment.h"
 
 namespace llvm {
@@ -92,7 +93,7 @@ static size_t getPointerNesting(Type *T, Type **ReturnNested = nullptr) {
   auto NPtrs = size_t{0};
   auto *NestedType = T;
   while (dyn_cast<PointerType>(NestedType)) {
-    NestedType = cast<PointerType>(NestedType)->getPointerElementType();
+    NestedType = VCINTR::Type::getNonOpaquePtrEltTy(NestedType);
     ++NPtrs;
   }
   if (ReturnNested)
@@ -138,8 +139,8 @@ static size_t getInnerPointerVectorNesting(Type *T) {
 static Type *getTypeFreeFromSingleElementVector(Type *T) {
   // Pointer types should be "undressed" first
   if (auto *Ptr = dyn_cast<PointerType>(T)) {
-    auto UT = getTypeFreeFromSingleElementVector(Ptr->getPointerElementType());
-    if (UT == Ptr->getPointerElementType())
+    auto UT = getTypeFreeFromSingleElementVector(VCINTR::Type::getNonOpaquePtrEltTy(Ptr));
+    if (UT == VCINTR::Type::getNonOpaquePtrEltTy(Ptr))
       return Ptr;
     return PointerType::get(UT, Ptr->getAddressSpace());
   } else if (auto *VecTy = dyn_cast<VectorType>(T)) {
@@ -166,7 +167,7 @@ static Type *getTypeWithSingleElementVector(Type *T, size_t InnerPointers = 0) {
     return VCINTR::getVectorType(T, 1);
 
   auto *Ptr = cast<PointerType>(T);
-  auto *UT = getTypeWithSingleElementVector(Ptr->getPointerElementType(),
+  auto *UT = getTypeWithSingleElementVector(VCINTR::Type::getNonOpaquePtrEltTy(Ptr),
                                             InnerPointers);
   return PointerType::get(UT, Ptr->getAddressSpace());
 }
@@ -770,7 +771,7 @@ static void manageSingleElementVectorAttribute(GlobalVariable &GV, Type *OldT,
 static GlobalVariable &createAndTakeFrom(GlobalVariable &GV, PointerType *NewT,
                                          Constant *Initializer) {
   auto *NewGV = new GlobalVariable(
-      *GV.getParent(), NewT->getPointerElementType(), GV.isConstant(),
+      *GV.getParent(), VCINTR::Type::getNonOpaquePtrEltTy(NewT), GV.isConstant(),
       GV.getLinkage(), Initializer, "sev.global.", &GV, GV.getThreadLocalMode(),
       GV.getAddressSpace(), GV.isExternallyInitialized());
   auto DebugInfoVec = SmallVector<DIGlobalVariableExpression *, 2>{};
@@ -818,7 +819,7 @@ static void restoreGlobalVariable(GlobalVariable &GV) {
   auto *Initializer = static_cast<Constant *>(nullptr);
   if (GV.hasInitializer())
     Initializer = cast<Constant>(createScalarToVectorValue(
-        GV.getInitializer(), NewT->getPointerElementType(),
+        GV.getInitializer(), VCINTR::Type::getNonOpaquePtrEltTy(NewT),
         static_cast<Instruction *>(nullptr)));
   auto &&NewGV = createAndTakeFrom(GV, NewT, Initializer);
   while (GV.use_begin() != GV.use_end()) {