Reduce usage of pointer element types (16).

This change replaces calls to getNonOpaquePtrEltTy with element type
information got through other means. This change is part of the effort
to support opaque pointers in newer LLVM versions.

Author: ViacheslavRb

IGC/AdaptorCommon/TypesLegalizationPass.cpp

@@ -236,7 +236,7 @@ TypesLegalizationPass::ResolveValue( Instruction *ip,Value *val,SmallVector<unsi
     auto alignment = IGCLLVM::getAlignmentValue(ld);
     unsigned pointerTypeSize = ld->getType()->getScalarSizeInBits() / 8;
     if ( alignment && (alignment_t)pointerTypeSize == alignment )
-      return builder.CreateAlignedLoad( gep, IGCLLVM::getAlign(alignment) );
+      return builder.CreateAlignedLoad(ld->getType(), gep, IGCLLVM::getAlign(alignment) );
     return builder.CreateLoad( gep );
   }
   else if(Constant *c = dyn_cast<Constant>(val)) {

IGC/Compiler/CISACodeGen/ConstantCoalescing.hpp

@@ -139,18 +139,42 @@ namespace IGC
                 return val;
             }
 
+            LoadInst* CreateLoad(Type* Ty, Value* Ptr, const char* Name) {
+                LoadInst* val = IGCIRBuilder<>::CreateLoad(Ty, Ptr, Name);
+                m_TT->RegisterNewValueAndAssignID(val);
+                return val;
+            }
+            // This wrapper function is deprecated because it uses typed pointer and
+            // should no longer be used in LLVM 14+ compatible code.
             LoadInst* CreateLoad(Value* Ptr, const char* Name) {
-                LoadInst* val = IGCIRBuilder<>::CreateLoad(Ptr, Name);
+                llvm::Type* ptrType = IGCLLVM::getNonOpaquePtrEltTy(Ptr->getType());
+                LoadInst* val = IGCIRBuilder<>::CreateLoad(ptrType, Ptr, Name);
                 m_TT->RegisterNewValueAndAssignID(val);
                 return val;
             }
+            LoadInst* CreateLoad(Type* Ty, Value* Ptr, const Twine& Name = "") {
+                LoadInst* val = IGCIRBuilder<>::CreateLoad(Ty, Ptr, Name);
+                m_TT->RegisterNewValueAndAssignID(val);
+                return val;
+            }
+            // This wrapper function is deprecated because it uses typed pointer and
+            // should no longer be used in LLVM 14+ compatible code.
             LoadInst* CreateLoad(Value* Ptr, const Twine& Name = "") {
-                LoadInst* val = IGCIRBuilder<>::CreateLoad(Ptr, Name);
+                llvm::Type* ptrType = IGCLLVM::getNonOpaquePtrEltTy(Ptr->getType());
+                LoadInst* val = IGCIRBuilder<>::CreateLoad(ptrType, Ptr, Name);
+                m_TT->RegisterNewValueAndAssignID(val);
+                return val;
+            }
+            LoadInst* CreateLoad(Type* Ty, Value* Ptr, bool isVolatile, const Twine& Name = "") {
+                LoadInst* val = IGCIRBuilder<>::CreateLoad(Ty, Ptr, isVolatile, Name);
                 m_TT->RegisterNewValueAndAssignID(val);
                 return val;
             }
+            // This wrapper function is deprecated because it uses typed pointer and
+            // should no longer be used in LLVM 14+ compatible code.
             LoadInst* CreateLoad(Value* Ptr, bool isVolatile, const Twine& Name = "") {
-            LoadInst* val = IGCIRBuilder<>::CreateLoad(Ptr, isVolatile, Name);
+                llvm::Type* ptrType = IGCLLVM::getNonOpaquePtrEltTy(Ptr->getType());
+                LoadInst* val = IGCIRBuilder<>::CreateLoad(ptrType, Ptr, isVolatile, Name);
                 m_TT->RegisterNewValueAndAssignID(val);
                 return val;
             }

IGC/Compiler/Optimizer/BuiltInFuncImport.cpp

@@ -885,8 +885,9 @@ bool BIImport::runOnModule(Module& M)
                     }
 
                     IGCLLVM::IRBuilder<> builder(CI);
+                    IGC_ASSERT(CI->paramHasAttr(0, llvm::Attribute::ByVal));
                     // Load function address from the table index
-                    Value* FP = builder.CreateGEP(FPTablePtr, builder.getInt32(tableIndex));
+                    Value* FP = builder.CreateGEP(CI->getParamByValType(0), FPTablePtr, builder.getInt32(tableIndex));
                     FP = builder.CreateLoad(cast<llvm::GetElementPtrInst>(FP)->getResultElementType(), FP);
                     IGC_ASSERT(FP->getType()->isPointerTy());
                     // Call the loaded function address

IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp

@@ -802,7 +802,7 @@ void TransposePrivMem::handleStoreInst(StoreInst* pStore, Value* pScalarizedIdx)
     }
 
     Value* addrInElt = convertToPtr(IRB, m_DL, addr, pStore->getPointerOperandType());
-    Value* gep = IRB.CreateGEP(addrInElt, eltIx, VALUE_NAME(pStore->getName() + ".SOAPrivMemGEP"));
+    Value* gep = IRB.CreateGEP(pStore->getValueOperand()->getType(), addrInElt, eltIx, VALUE_NAME(pStore->getName() + ".SOAPrivMemGEP"));
     IRB.CreateAlignedStore(pStore->getValueOperand(), gep, IGCLLVM::getAlign(*pStore));
 
     pStore->eraseFromParent();

IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryToSLM.cpp

@@ -344,7 +344,7 @@ namespace IGC
                             VALUE_NAME(pAI->getName() + ".totalOffset"));
 
                     Value* cast = ConstantExpr::getAddrSpaceCast(slmVar, pAI->getType());
-                    Value* ptr = builder.CreateGEP(cast, totalOffset);
+                    Value* ptr = builder.CreateGEP(pAI->getAllocatedType(), cast, totalOffset);
 
                     pAI->replaceAllUsesWith(ptr);
                     pAI->eraseFromParent();

IGC/VectorCompiler/lib/GenXCodeGen/GenXGASDynamicResolution.cpp

@@ -263,7 +263,7 @@ void GenXGASDynamicResolution::visitLoadInst(LoadInst &LdI) const {
   if (!CanLocalBeGeneric) {
     IGCLLVM::IRBuilder<> Builder{&LdI};
     auto GlobalPtrOp = createASCast(Builder, PtrOp, vc::AddrSpace::Global);
-    auto NewInst = Builder.CreateAlignedLoad(GlobalPtrOp, IGCLLVM::getAlign(LdI),
+    auto NewInst = Builder.CreateAlignedLoad(LdI.getType(), GlobalPtrOp, IGCLLVM::getAlign(LdI),
                                       LdI.isVolatile(), "globalOrPrivateLoad");
     LdI.replaceAllUsesWith(NewInst);
     LdI.eraseFromParent();