Reduce usage of pointer element types (3).

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.

Author: ViacheslavRb

IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASResolving.cpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2022 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -10,6 +10,7 @@ SPDX-License-Identifier: MIT
 
 #include "Compiler/CISACodeGen/ShaderCodeGen.hpp"
 #include "Compiler/InitializePasses.h"
+#include "llvmWrapper/IR/DerivedTypes.h"
 
 // Generic address space (GAS) pointer resolving is done in two steps:
 // 1) Find cast from non-GAS pointer to GAS pointer
@@ -259,7 +260,7 @@ void GASResolving::convertLoadToGlobal(LoadInst* LI) const {
 
     PointerType* PtrTy = cast<PointerType>(LI->getType());
     IRB->SetInsertPoint(LI->getNextNode());
-    PointerType* GlobalPtrTy = PointerType::get(IGCLLVM::getNonOpaquePtrEltTy(PtrTy), ADDRESS_SPACE_GLOBAL);
+    PointerType* GlobalPtrTy = IGCLLVM::getWithSamePointeeType(PtrTy, ADDRESS_SPACE_GLOBAL);
     Value* GlobalAddr = IRB->CreateAddrSpaceCast(LI, GlobalPtrTy);
     Value* GenericCopyAddr = IRB->CreateAddrSpaceCast(GlobalAddr, PtrTy);
 

IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASRetValuePropagator.cpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2023 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -17,6 +17,7 @@ SPDX-License-Identifier: MIT
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "common/LLVMWarningsPop.hpp"
+#include "llvmWrapper/IR/DerivedTypes.h"
 #include "DebugInfo/DwarfDebug.hpp"
 
 #define PASS_FLAG "igc-gas-ret-value-propagator"
@@ -152,8 +153,10 @@ PointerType* GASRetValuePropagator::getRetValueNonGASType(Function* F)
         originAddrSpace.emplace(AS);
     }
 
+    PointerType* retTy = cast<PointerType>(F->getReturnType());
+
     return originAddrSpace ?
-        PointerType::get(IGCLLVM::getNonOpaquePtrEltTy(F->getReturnType()), originAddrSpace.value()) :
+        IGCLLVM::getWithSamePointeeType(retTy, originAddrSpace.value()) :
         nullptr;
 }
 

IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GenericAddressDynamicResolution.cpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2023 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -16,6 +16,7 @@ SPDX-License-Identifier: MIT
 #include "Compiler/MetaDataUtilsWrapper.h"
 #include "common/LLVMWarningsPush.hpp"
 #include "llvmWrapper/Support/Alignment.h"
+#include "llvmWrapper/IR/DerivedTypes.h"
 #include <llvm/IR/Module.h>
 #include <llvm/IR/Instructions.h>
 #include <llvm/IR/DataLayout.h>
@@ -272,7 +273,7 @@ void GenericAddressDynamicResolution::resolveGAS(Instruction& I, Value* pointerO
     {
         BasicBlock* BB = BasicBlock::Create(I.getContext(), BlockName, convergeBlock->getParent(), convergeBlock);
         builder.SetInsertPoint(BB);
-        PointerType* ptrType = IGCLLVM::getNonOpaquePtrEltTy(pointerType)->getPointerTo(addressSpace);
+        PointerType* ptrType = IGCLLVM::getWithSamePointeeType(pointerType, addressSpace);
         Value* ptr = builder.CreateAddrSpaceCast(pointerOperand, ptrType);
 
         if (LoadInst* LI = dyn_cast<LoadInst>(&I))
@@ -349,7 +350,7 @@ void GenericAddressDynamicResolution::resolveGASWithoutBranches(Instruction& I,
 
     Value* nonLocalLoad = nullptr;
 
-    PointerType* ptrType = IGCLLVM::getNonOpaquePtrEltTy(pointerType)->getPointerTo(ADDRESS_SPACE_GLOBAL);
+    PointerType* ptrType = IGCLLVM::getWithSamePointeeType(pointerType, ADDRESS_SPACE_GLOBAL);
     Value* globalPtr = builder.CreateAddrSpaceCast(pointerOperand, ptrType);
 
     if (LoadInst* LI = dyn_cast<LoadInst>(&I))
@@ -438,7 +439,7 @@ bool GenericAddressDynamicResolution::visitIntrinsicCall(CallInst& I)
         // If Block
         {
             IRBuilder<> ifBuilder(ifBlock);
-            PointerType* ptrType = IGCLLVM::getNonOpaquePtrEltTy(pointerType)->getPointerTo(targetAS);
+            PointerType* ptrType = IGCLLVM::getWithSamePointeeType(pointerType, targetAS);
             newPtr = ifBuilder.CreateAddrSpaceCast(arg, ptrType);
             ifBuilder.CreateBr(convergeBlock);
         }

IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/StaticGASResolution.cpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2022 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -10,6 +10,7 @@ SPDX-License-Identifier: MIT
 
 #include "Compiler/CISACodeGen/ShaderCodeGen.hpp"
 #include "Compiler/InitializePasses.h"
+#include "llvmWrapper/IR/DerivedTypes.h"
 
 FunctionPass* IGC::createStaticGASResolution() { return new StaticGASResolution(); }
 
@@ -59,8 +60,7 @@ bool StaticGASResolution::runOnFunction(llvm::Function& F)
             if (!toSkip(Ptr))
             {
                 PointerType* PtrTy = cast<PointerType>(Ptr->getType());
-                Type* eltTy = IGCLLVM::getNonOpaquePtrEltTy(PtrTy);
-                PointerType* glbPtrTy = PointerType::get(eltTy, ADDRESS_SPACE_GLOBAL);
+                PointerType* glbPtrTy = IGCLLVM::getWithSamePointeeType(PtrTy, ADDRESS_SPACE_GLOBAL);
 
                 IRB.SetInsertPoint(I);
                 Value* NewPtr = IRB.CreateAddrSpaceCast(Ptr, glbPtrTy);

IGC/Compiler/Optimizer/OpenCLPasses/LocalBuffers/InlineLocalsResolution.cpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2021 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -519,8 +519,7 @@ void InlineLocalsResolution::computeOffsetList(Module& M, llvm::MapVector<Functi
             offsetMap[F][G] = (offset & 0xFFFF);
 
             // And the total size after this local is added
-            PointerType* ptrType = dyn_cast<PointerType>(G->getType());
-            Type* varType = IGCLLVM::getNonOpaquePtrEltTy(ptrType);
+            Type* varType = G->getValueType();
             if (G == m_pGV)
             {
                 // it is GetMemPoolPtr usage

IGC/Compiler/Optimizer/OpenCLPasses/NamedBarriers/NamedBarriersResolution.cpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2020-2021 Intel Corporation
+Copyright (C) 2020-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -332,7 +332,7 @@ void NamedBarriersResolution::HandleNamedBarrierInitSW(CallInst& NBarrierInitCal
         m_NamedBarrierType->getPointerTo(SPIRAS_Local),
         Type::getInt32PtrTy(context, SPIRAS_Local)
     };
-    Type *BaseTy = IGCLLVM::getNonOpaquePtrEltTy(m_NamedBarrierArray->getType());
+    Type* BaseTy = m_NamedBarrierArray->getValueType();
     auto pointerNBarrier = GetElementPtrInst::Create(BaseTy, m_NamedBarrierArray, { getInt64(module, 0), getInt32(module, 0) }, "", &(NBarrierInitCall));
     auto bitcastPointerNBarrier = BitCastInst::CreatePointerBitCastOrAddrSpaceCast(pointerNBarrier, m_NamedBarrierType->getPointerTo(SPIRAS_Local), "", &(NBarrierInitCall));
     SmallVector<Value*, 3> ArgsVal

IGC/Compiler/Optimizer/OpenCLPasses/PoisonFP64KernelsPass/PoisonFP64KernelsPass.cpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2022 Intel Corporation
+Copyright (C) 2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -90,7 +90,7 @@ bool PoisonFP64Kernels::runOnSCC(CallGraphSCC &SCC) {
     return modified;
 }
 
-static Constant *createPoisonMessage(Module *M, Function *Kernel) {
+static GlobalVariable *createPoisonMessage(Module *M, Function *Kernel) {
     std::string message = "[CRITICAL ERROR] Kernel '" + Kernel->getName().str()
                         + "' removed due to usage of FP64 instructions unsupported by the targeted hardware. "
                         + "Running this kernel may result in unexpected results.\n";
@@ -162,8 +162,8 @@ static void poisonKernel(Function *Kernel) {
 
     Function *Printf = getOrDeclareFunction(M, "printf", FunctionType::get(Int32Ty, { Type::getInt8PtrTy(Ctx, 2) }, true));
 
-    Constant *PoisonMessage = createPoisonMessage(M, Kernel);
-    Type *MessageType = IGCLLVM::getNonOpaquePtrEltTy(PoisonMessage->getType());
+    GlobalVariable* PoisonMessage = createPoisonMessage(M, Kernel);
+    Type* MessageType = PoisonMessage->getValueType();
 
     std::vector<Value *> Indices = {
         ConstantInt::getSigned(Type::getInt32Ty(Ctx), 0),

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

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2021 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -571,7 +571,7 @@ class TransposeHelperPrivateMem : public TransposeHelper
         IRB.SetInsertPoint(pLoad);
         if (!vectorIO && pLoad->getType()->isVectorTy())
         {
-            Type* scalarType = IGCLLVM::getNonOpaquePtrEltTy(pLoad->getPointerOperand()->getType())->getScalarType();
+            Type* scalarType = pLoad->getType()->getScalarType();
             IGC_ASSERT(nullptr != scalarType);
             Type* scalarptrTy = PointerType::get(scalarType, pLoad->getPointerAddressSpace());
             IGC_ASSERT(scalarType->getPrimitiveSizeInBits() / 8 == elementSize);
@@ -609,7 +609,7 @@ class TransposeHelperPrivateMem : public TransposeHelper
         IRB.SetInsertPoint(pStore);
         if (!vectorIO && pStore->getValueOperand()->getType()->isVectorTy())
         {
-            Type* scalarType = IGCLLVM::getNonOpaquePtrEltTy(pStore->getPointerOperand()->getType())->getScalarType();
+            Type* scalarType = pStore->getValueOperand()->getType()->getScalarType();
             IGC_ASSERT(nullptr != scalarType);
             Type* scalarptrTy = PointerType::get(scalarType, pStore->getPointerAddressSpace());
             IGC_ASSERT(scalarType->getPrimitiveSizeInBits() / 8 == elementSize);
@@ -998,7 +998,7 @@ bool PrivateMemoryResolution::resolveAllocaInstructions(bool privateOnStack)
                 // possibility to use large loads/stores, so cancel the transformation.
                 // Currently it is only enabled by option
                 bool isSOABeneficial = pTypeOfAccessedObject->isVectorTy() || !allUsesAreVector;
-                Type* allocaType = GetBaseType(IGCLLVM::getNonOpaquePtrEltTy(pAI->getType()));
+                Type* allocaType = pAI->getAllocatedType();
                 if (VectorType* vectorType = dyn_cast<VectorType>(allocaType))
                 {
                     bool baseTypeIsSmall = (unsigned)(vectorType->getElementType()->getScalarSizeInBits()) < 32;
@@ -1012,7 +1012,7 @@ bool PrivateMemoryResolution::resolveAllocaInstructions(bool privateOnStack)
             {
                 auto DL = &m_currFunction->getParent()->getDataLayout();
                 bufferSize = (unsigned)DL->getTypeAllocSize(pTypeOfAccessedObject);
-                IGC_ASSERT(testTransposedMemory(IGCLLVM::getNonOpaquePtrEltTy(pAI->getType()), pTypeOfAccessedObject, bufferSize, (m_ModAllocaInfo->getConstBufferSize(pAI))));
+                IGC_ASSERT(testTransposedMemory(pAI->getAllocatedType(), pTypeOfAccessedObject, bufferSize, (m_ModAllocaInfo->getConstBufferSize(pAI))));
             }
             else
             {

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

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2020-2021 Intel Corporation
+Copyright (C) 2020-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -192,8 +192,7 @@ namespace IGC
             unsigned int offset = 0;
             for (const auto &offsets : ModuleMD->FuncMD[F].localOffsets)
             {
-                PointerType* ptrType = dyn_cast<PointerType>(offsets.m_Var->getType());
-                Type* varType = IGCLLVM::getNonOpaquePtrEltTy(ptrType);
+                Type* varType = offsets.m_Var->getValueType();
                 offset = iSTD::Align(offset, IGCLLVM::getPreferredAlignValue(&DL, offsets.m_Var));
                 offset += (unsigned int) DL.getTypeAllocSize(varType);
             }
@@ -229,7 +228,7 @@ namespace IGC
 
                 if (m_ForceAll || isForcedBuffer)
                 {
-                    Type* origType = IGCLLVM::getNonOpaquePtrEltTy(pAI->getType());
+                    Type* origType = pAI->getAllocatedType();
                     bool isArray = origType->isArrayTy();
                     Type* eltType = isArray ? origType->getArrayElementType() : origType;
                     uint64_t numEltsPerThread = isArray ? origType->getArrayNumElements() : 1;

IGC/Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantAnalysis.cpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2023 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -196,7 +196,7 @@ bool ProgramScopeConstantAnalysis::runOnModule(Module& M)
         offset = iSTD::Align(offset, (unsigned)m_DL->getPreferredAlign(globalVar).value());
 #endif
         inlineProgramScopeOffsets[globalVar] = offset;
-        offset += (unsigned)(m_DL->getTypeAllocSize(IGCLLVM::getNonOpaquePtrEltTy(globalVar->getType())));
+        offset += (unsigned)(m_DL->getTypeAllocSize(globalVar->getValueType()));
     }
 
     // Patch the offsets for usages of zero initialized globals after those offsets have been calculated in the previous step.

IGC/Compiler/Optimizer/PreCompiledFuncImport.cpp

@@ -1,6 +1,6 @@
 /*========================== begin_copyright_notice ============================
 
-Copyright (C) 2017-2023 Intel Corporation
+Copyright (C) 2017-2024 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -549,8 +549,9 @@ bool PreCompiledFuncImport::preProcessDouble()
             else if (Inst->getOpcode() == Instruction::FNeg)
             {
                 // check if Inst is double instruction or vector of double instructions
-                if (Inst->getType()->isDoubleTy() ||
-                    (Inst->getType()->isVectorTy() && IGCLLVM::getNonOpaquePtrEltTy(Inst->getType())->isDoubleTy()))
+                Type* instType = Inst->getType();
+                IGCLLVM::FixedVectorType* instVecType = dyn_cast<IGCLLVM::FixedVectorType>(instType);
+                if (instType->isDoubleTy() || (instVecType && instVecType->getElementType()->isDoubleTy()))
                 {
                     IGCLLVM::IRBuilder<> builder(Inst);
                     Value* fsub = nullptr;