Reduce usage of pointer element types (6).

ViacheslavRb · igcbot · commit 98182844bbca · 2024-02-19T13:15:00.000+01:00
This change replaces calls to getNonOpaquePtrEltTy in compute-related
passes with element type information got through other means. This
change is part of the effort to support opaque pointers in newer LLVM
versions.
diff --git a/IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp b/IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp
@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2020-2021 Intel Corporation
+Copyright (C) 2020-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -205,7 +205,6 @@ inline void StoreToStruct(IGCLLVM::IRBuilder<>& builder, Value* strVal, Value* s
 {
     IGC_ASSERT(strPtr->getType()->isPointerTy());
     IGC_ASSERT(strVal->getType()->isStructTy());
-    IGC_ASSERT(IGCLLVM::getNonOpaquePtrEltTy(strPtr->getType()) == strVal->getType());
 
     StructType* sTy = cast<StructType>(strVal->getType());
     for (unsigned i = 0; i < sTy->getNumElements(); i++)
@@ -617,6 +616,7 @@ void LegalizeFunctionSignatures::FixCallInstruction(Module& M, CallInst* callIns
     {
         IGCLLVM::IRBuilder<> builder(callInst);
         Value* newCalledValue = nullptr;
+        FunctionType* newFnTy = nullptr;
         if (!calledFunc)
         {
             // Indirect call, cast the pointer type
@@ -628,7 +628,7 @@ void LegalizeFunctionSignatures::FixCallInstruction(Module& M, CallInst* callIns
             Type* retType = legalizeReturnType ? Type::getVoidTy(callInst->getContext()) :
                 promoteSRetType ? PromotedStructValueType(M, callInst->getArgOperand(0)->getType()) :
                 callInst->getType();
-            FunctionType* newFnTy = FunctionType::get(retType, argTypes, false);
+            newFnTy = FunctionType::get(retType, argTypes, false);
             Value* calledValue = IGCLLVM::getCalledValue(callInst);
             newCalledValue = builder.CreatePointerCast(calledValue, PointerType::get(newFnTy, 0));
         }
@@ -637,10 +637,11 @@ void LegalizeFunctionSignatures::FixCallInstruction(Module& M, CallInst* callIns
             // Directly call the new function pointer
             IGC_ASSERT(oldToNewFuncMap.find(calledFunc) != oldToNewFuncMap.end());
             newCalledValue = oldToNewFuncMap[calledFunc];
+            newFnTy = cast<Function>(newCalledValue)->getFunctionType();
         }
 
         // Create the new call instruction
-        CallInst* newCallInst = builder.CreateCall(newCalledValue, callArgs);
+        CallInst* newCallInst = builder.CreateCall(newFnTy, newCalledValue, callArgs);
         newCallInst->setCallingConv(callInst->getCallingConv());
         newCallInst->setAttributes(AttributeList::get(M.getContext(), IGCLLVM::getFnAttrs(PAL), IGCLLVM::getRetAttrs(PAL), ArgAttrVec));
         newCallInst->setDebugLoc(callInst->getDebugLoc());
diff --git a/IGC/AdaptorOCL/LowerInvokeSIMD.cpp b/IGC/AdaptorOCL/LowerInvokeSIMD.cpp
@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2023 Intel Corporation
+Copyright (C) 2023-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -125,7 +125,7 @@ void LowerInvokeSIMD::visitCallInst(CallInst &CI) {
         FTy,
         cast<PointerType>(CI.getArgOperand(0)->getType())->getAddressSpace());
     auto CastedPointer = m_Builder->CreateBitCast(CI.getArgOperand(0), PTy);
-    NewCall = m_Builder->CreateCall(CastedPointer, ArgVals);
+    NewCall = m_Builder->CreateCall(FTy, CastedPointer, ArgVals);
   }
 
   NewCall->setCallingConv(CI.getCallingConv());
diff --git a/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp b/IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp
@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2021 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -1931,7 +1931,7 @@ bool SPIRVToLLVM::transOCLBuiltinFromVariable(GlobalVariable *GV,
   decorateSPIRVBuiltin(FuncName);
   Function *Func = M->getFunction(FuncName);
   if (!Func) {
-    Type *ReturnTy = IGCLLVM::getNonOpaquePtrEltTy(GV->getType());
+    Type *ReturnTy = GV->getValueType();
     FunctionType *FT = FunctionType::get(ReturnTy, false);
     Func = Function::Create(FT, GlobalValue::ExternalLinkage, FuncName, M);
     Func->setCallingConv(CallingConv::SPIR_FUNC);
@@ -1974,7 +1974,7 @@ bool SPIRVToLLVM::transOCLBuiltinFromVariable(GlobalVariable *GV,
     Value* substitution = call;
     // Check if an ExtractElement instruction is needed.
     if (Func->getFunctionType()->getReturnType()->isVectorTy() &&
-        !IGCLLVM::getNonOpaquePtrEltTy(load->getPointerOperandType())->isVectorTy()) {
+        !load->getType()->isVectorTy()) {
       auto gep = cast<GetElementPtrInst>(load->getOperand(0));
       IGC_ASSERT_MESSAGE(gep, "Expected GetElementrPtr instruction");
       IGC_ASSERT_MESSAGE(gep->getNumIndices() == 2, "Expected GetElementrPtr with exactly two indices");
@@ -3367,7 +3367,7 @@ SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
         0, GlobalVariable::NotThreadLocal, 0);
 
     auto LD = new LoadInst(
-      IGCLLVM::getNonOpaquePtrEltTy(GV->getType()),
+      GV->getValueType(),
       GV, BV->getName(), BB);
     PlaceholderMap[BV] = LD;
     return mapValue(BV, LD);
diff --git a/IGC/AdaptorOCL/preprocess_spvir/PromoteBools.cpp b/IGC/AdaptorOCL/preprocess_spvir/PromoteBools.cpp
@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2022-2023 Intel Corporation
+Copyright (C) 2022-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -658,7 +658,7 @@ GlobalVariable* PromoteBools::promoteGlobalVariable(GlobalVariable* globalVariab
 
     auto newGlobalVariable = new GlobalVariable(
         *globalVariable->getParent(),
-        getOrCreatePromotedType(IGCLLVM::getNonOpaquePtrEltTy(globalVariable->getType())),
+        getOrCreatePromotedType(globalVariable->getValueType()),
         globalVariable->isConstant(),
         globalVariable->getLinkage(),
         promoteConstant(globalVariable->getInitializer()),
diff --git a/IGC/Compiler/CISACodeGen/CShader.cpp b/IGC/Compiler/CISACodeGen/CShader.cpp
@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2022 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -3076,7 +3076,7 @@ CVariable* CShader::GetSymbol(llvm::Value* value, bool fromConstantPool)
             {
                 return isa<GlobalValue>(value) &&
                     value->getType()->isPointerTy() &&
-                    IGCLLVM::getNonOpaquePtrEltTy(value->getType())->isFunctionTy();
+                    cast<GlobalValue>(value)->getValueType()->isFunctionTy();
             };
             // Global Variable/Constant
             auto isGlobalVarType = [this](Value* value)
diff --git a/IGC/Compiler/CISACodeGen/helper.cpp b/IGC/Compiler/CISACodeGen/helper.cpp
@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2023 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -2788,8 +2788,7 @@ namespace IGC
 
             if (instType && instType->getAddressSpace() == oldAS)
             {
-                Type* eltType = IGCLLVM::getNonOpaquePtrEltTy(instType);
-                PointerType* ptrType = PointerType::get(eltType, newAS);
+                PointerType* ptrType = IGCLLVM::getWithSamePointeeType(dyn_cast<PointerType>(instType), newAS);
                 inst->mutateType(ptrType);
                 FixAddressSpaceInAllUses(inst, newAS, oldAS);
             }
diff --git a/IGC/Compiler/Optimizer/BuiltInFuncImport.cpp b/IGC/Compiler/Optimizer/BuiltInFuncImport.cpp
@@ -795,7 +795,7 @@ bool BIImport::runOnModule(Module& M)
                     FunctionType* funcTy = FunctionType::get(builder.getVoidTy(), { argBuffer->getType() }, false);
                     Value* funcPtr = builder.CreatePointerCast(CI->getArgOperand(0), PointerType::get(funcTy, 0));
                     // Replace builtin with the function call
-                    CallInst* callFunc = builder.CreateCall(funcPtr, argBuffer);
+                    CallInst* callFunc = builder.CreateCall(funcTy, funcPtr, argBuffer);
                     callFunc->setCallingConv(llvm::CallingConv::SPIR_FUNC);
                     CI->replaceAllUsesWith(callFunc);
                     InstToRemove.push_back(CI);
diff --git a/IGC/WrapperLLVM/include/llvmWrapper/IR/IRBuilder.h b/IGC/WrapperLLVM/include/llvmWrapper/IR/IRBuilder.h
@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2018-2021 Intel Corporation
+Copyright (C) 2018-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -166,31 +166,30 @@ namespace IGCLLVM
 #endif
 
 #if LLVM_VERSION_MAJOR >= 11
-      inline llvm::CallInst* CreateCall(llvm::Value* Callee, llvm::ArrayRef<llvm::Value*> Args = llvm::None,
-                                           const llvm::Twine& Name = "", llvm::MDNode* FPMathTag = nullptr) {
+
+        inline llvm::CallInst* CreateCall(llvm::Value* Callee, llvm::ArrayRef<llvm::Value*> Args = llvm::None,
+                                          const llvm::Twine& Name = "", llvm::MDNode* FPMathTag = nullptr) {
             return llvm::IRBuilder<T, InserterTyDef()>::CreateCall(
-                                                           llvm::cast<llvm::FunctionType>(IGCLLVM::getNonOpaquePtrEltTy(Callee->getType())), Callee,
-            Args, Name, FPMathTag);
+                llvm::cast<llvm::Function>(Callee)->getFunctionType(),
+                Callee, Args, Name, FPMathTag);
         }
 
         inline llvm::CallInst *
         CreateCall(llvm::Value *Callee, llvm::ArrayRef<llvm::Value *> Args,
                    llvm::ArrayRef<llvm::OperandBundleDef> OpBundles,
                    const llvm::Twine &Name = "",
                    llvm::MDNode *FPMathTag = nullptr) {
-          return llvm::IRBuilder<T, InserterTyDef()>::CreateCall(
-              llvm::cast<llvm::FunctionType>(
-                  IGCLLVM::getNonOpaquePtrEltTy(Callee->getType())),
-              Callee, Args, OpBundles, Name, FPMathTag);
+            return llvm::IRBuilder<T, InserterTyDef()>::CreateCall(
+                llvm::cast<llvm::Function>(Callee)->getFunctionType(),
+                Callee, Args, OpBundles, Name, FPMathTag);
         }
 
         inline llvm::CallInst *
         CreateCall(llvm::FunctionType *FTy, llvm::Value *Callee,
                    llvm::ArrayRef<llvm::Value *> Args = llvm::None,
                    const llvm::Twine &Name = "",
                    llvm::MDNode *FPMathTag = nullptr) {
-          return llvm::IRBuilder<T, InserterTyDef()>::CreateCall(FTy, Callee, Args,
-                                                          Name, FPMathTag);
+            return llvm::IRBuilder<T, InserterTyDef()>::CreateCall(FTy, Callee, Args, Name, FPMathTag);
         }
 #endif
 

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`/*========================== begin_copyright_notice ============================`
`2`	`2`
`3`		`-Copyright (C) 2017-2023 Intel Corporation`
	`3`	`+Copyright (C) 2017-2024 Intel Corporation`
`4`	`4`
`5`	`5`	`SPDX-License-Identifier: MIT`
`6`	`6`
`@@ -2788,8 +2788,7 @@ namespace IGC`
`2788`	`2788`
`2789`	`2789`	`if (instType && instType->getAddressSpace() == oldAS)`
`2790`	`2790`	`{`
`2791`		`- Type* eltType = IGCLLVM::getNonOpaquePtrEltTy(instType);`
`2792`		`- PointerType* ptrType = PointerType::get(eltType, newAS);`
	`2791`	`+ PointerType* ptrType = IGCLLVM::getWithSamePointeeType(dyn_cast<PointerType>(instType), newAS);`
`2793`	`2792`	`inst->mutateType(ptrType);`
`2794`	`2793`	`FixAddressSpaceInAllUses(inst, newAS, oldAS);`
`2795`	`2794`	`}`