[Autobackout][FuncReg]Revert of change: 0be8288

mbelicki · igcbot · commit fee0a7de8893 · 2024-02-01T13:52:11.000+01:00
Reduce usage of pointer element type in compute passes.

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/Compiler/Optimizer/BuiltInFuncImport.cpp b/IGC/Compiler/Optimizer/BuiltInFuncImport.cpp
@@ -28,7 +28,6 @@ SPDX-License-Identifier: MIT
 #include <llvm/Support/Error.h>
 #include <llvm/Support/MemoryBuffer.h>
 #include <llvm/Bitcode/BitcodeReader.h>
-#include "llvmWrapper/IR/DerivedTypes.h"
 #include "common/LLVMWarningsPop.hpp"
 #include <unordered_set>
 #include <unordered_map>
@@ -571,7 +570,8 @@ void BIImport::fixInvalidBitcasts(llvm::Module &M)
 
             // New bitcast
             PointerType *FinalBitCastType =
-                IGCLLVM::getWithSamePointeeType(DstPtrType, SrcPtrType->getAddressSpace());
+                PointerType::get(IGCLLVM::getNonOpaquePtrEltTy(DstPtrType),
+                                 SrcPtrType->getAddressSpace());
             BitCastInst *NewBitCastI = new BitCastInst(
                 BitCastI->getOperand(0), FinalBitCastType, "bcast", BitCastI);
 
@@ -888,7 +888,7 @@ bool BIImport::runOnModule(Module& M)
                     // Load function address from the table index
                     Value* FP = builder.CreateGEP(FPTablePtr, builder.getInt32(tableIndex));
                     FP = builder.CreateLoad(FP);
-                    IGC_ASSERT(FP->getType()->isPointerTy());
+                    IGC_ASSERT(FP->getType()->isPointerTy() && IGCLLVM::getNonOpaquePtrEltTy(FP->getType())->isFunctionTy());
                     // Call the loaded function address
                     SmallVector<Value*, 8> Args;
                     for (unsigned i = 1; i < IGCLLVM::getNumArgOperands(CI); i++)
@@ -1008,7 +1008,7 @@ void BIImport::removeFunctionBitcasts(Module& M)
                                         castInsts.push_back(newASC);
                                         destVal = newASC;
                                     }
-                                    if (!IGCLLVM::isOpaqueOrPointeeTypeEquals(srcType, destType))
+                                    if (IGCLLVM::getNonOpaquePtrEltTy(srcType) != IGCLLVM::getNonOpaquePtrEltTy(destType))
                                     {
                                         BitCastInst *newBT = new BitCastInst(destVal, srcType, destVal->getName() + ".bcast");
                                         castInsts.push_back(newBT);
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/AlignmentAnalysis/AlignmentAnalysis.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/AlignmentAnalysis/AlignmentAnalysis.cpp
@@ -132,7 +132,8 @@ auto AlignmentAnalysis::getAlignValue(Value* V) const
             // If the globalvariable uses the default alignment, pull it from the datalayout
             if (!align)
             {
-                return m_DL->getABITypeAlignment(GV->getValueType());
+                Type* gvType = GV->getType();
+                return m_DL->getABITypeAlignment(IGCLLVM::getNonOpaquePtrEltTy(gvType));
             }
             else
             {
@@ -224,7 +225,8 @@ alignment_t AlignmentAnalysis::visitAllocaInst(AllocaInst& I)
     // If the alloca uses the default alignment, pull it from the datalayout
     if (!newAlign)
     {
-        newAlign = m_DL->getABITypeAlignment(I.getAllocatedType());
+        Type* allocaType = I.getType();
+        newAlign = m_DL->getABITypeAlignment(IGCLLVM::getNonOpaquePtrEltTy(allocaType));
     }
 
     return newAlign;
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASPropagator.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASPropagator.cpp
@@ -7,8 +7,6 @@ SPDX-License-Identifier: MIT
 ============================= end_copyright_notice ===========================*/
 #include "GASPropagator.h"
 
-#include "llvmWrapper/IR/DerivedTypes.h"
-
 using namespace IGC;
 
 bool GASPropagator::isAddrSpaceResolvable(PHINode* PN, const Loop* L,
@@ -106,7 +104,7 @@ bool GASPropagator::visitAddrSpaceCastInst(AddrSpaceCastInst& I) {
         return false;
 
     Value* Src = TheVal;
-    if (!IGCLLVM::isOpaqueOrPointeeTypeEquals(SrcPtrTy, DstPtrTy)) {
+    if (IGCLLVM::getNonOpaquePtrEltTy(SrcPtrTy) != IGCLLVM::getNonOpaquePtrEltTy(DstPtrTy)) {
         BuilderType::InsertPointGuard Guard(IRB);
         IRB.SetInsertPoint(&I);
         Src = IRB.CreateBitCast(Src, DstPtrTy);
@@ -152,7 +150,7 @@ bool GASPropagator::visitGetElementPtrInst(GetElementPtrInst& I) {
     IRB.SetInsertPoint(I.getNextNode());
     // Push `getelementptr` forward by replacing this `bitcast` on GAS with the
     // one on non-GAS followed by a new `addrspacecast` to GAS.
-    Type* DstTy = I.getSourceElementType();
+    Type* DstTy = IGCLLVM::getNonOpaquePtrEltTy(DstPtrTy);
     PointerType* TransPtrTy =
         PointerType::get(DstTy, SrcPtrTy->getAddressSpace());
     TheUse->set(TheVal);
@@ -277,7 +275,7 @@ bool GASPropagator::visitSelect(SelectInst& I) {
 
     // Push 'addrspacecast' forward by changing the select return type to non-GAS pointer
     // followed by a new 'addrspacecast' to GAS
-    PointerType* TransPtrTy = IGCLLVM::getWithSamePointeeType(DstPtrTy, NonGASPtrTy->getAddressSpace());
+    PointerType* TransPtrTy = PointerType::get(IGCLLVM::getNonOpaquePtrEltTy(DstPtrTy), NonGASPtrTy->getAddressSpace());
     I.mutateType(TransPtrTy);
     Value* NewPtr = IRB.CreateAddrSpaceCast(&I, DstPtrTy);
 
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASResolving.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASResolving.cpp
@@ -10,7 +10,6 @@ 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
@@ -260,7 +259,7 @@ void GASResolving::convertLoadToGlobal(LoadInst* LI) const {
 
     PointerType* PtrTy = cast<PointerType>(LI->getType());
     IRB->SetInsertPoint(LI->getNextNode());
-    PointerType* GlobalPtrTy = IGCLLVM::getWithSamePointeeType(PtrTy, ADDRESS_SPACE_GLOBAL);
+    PointerType* GlobalPtrTy = PointerType::get(IGCLLVM::getNonOpaquePtrEltTy(PtrTy), ADDRESS_SPACE_GLOBAL);
     Value* GlobalAddr = IRB->CreateAddrSpaceCast(LI, GlobalPtrTy);
     Value* GenericCopyAddr = IRB->CreateAddrSpaceCast(GlobalAddr, PtrTy);
 
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASRetValuePropagator.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GASRetValuePropagator.cpp
@@ -17,7 +17,6 @@ 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"
@@ -153,10 +152,8 @@ PointerType* GASRetValuePropagator::getRetValueNonGASType(Function* F)
         originAddrSpace.emplace(AS);
     }
 
-    PointerType *retTy = cast<PointerType>(F->getReturnType());
-
     return originAddrSpace ?
-        IGCLLVM::getWithSamePointeeType(retTy, originAddrSpace.value()) :
+        PointerType::get(IGCLLVM::getNonOpaquePtrEltTy(F->getReturnType()), originAddrSpace.value()) :
         nullptr;
 }
 
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GenericAddressDynamicResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/GenericAddressDynamicResolution.cpp
@@ -16,7 +16,6 @@ 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>
@@ -273,7 +272,7 @@ void GenericAddressDynamicResolution::resolveGAS(Instruction& I, Value* pointerO
     {
         BasicBlock* BB = BasicBlock::Create(I.getContext(), BlockName, convergeBlock->getParent(), convergeBlock);
         builder.SetInsertPoint(BB);
-        PointerType* ptrType = IGCLLVM::getWithSamePointeeType(pointerType, addressSpace);
+        PointerType* ptrType = IGCLLVM::getNonOpaquePtrEltTy(pointerType)->getPointerTo(addressSpace);
         Value* ptr = builder.CreateAddrSpaceCast(pointerOperand, ptrType);
 
         if (LoadInst* LI = dyn_cast<LoadInst>(&I))
@@ -350,7 +349,7 @@ void GenericAddressDynamicResolution::resolveGASWithoutBranches(Instruction& I,
 
     Value* nonLocalLoad = nullptr;
 
-    PointerType* ptrType = IGCLLVM::getWithSamePointeeType(pointerType, ADDRESS_SPACE_GLOBAL);
+    PointerType* ptrType = IGCLLVM::getNonOpaquePtrEltTy(pointerType)->getPointerTo(ADDRESS_SPACE_GLOBAL);
     Value* globalPtr = builder.CreateAddrSpaceCast(pointerOperand, ptrType);
 
     if (LoadInst* LI = dyn_cast<LoadInst>(&I))
@@ -439,7 +438,7 @@ bool GenericAddressDynamicResolution::visitIntrinsicCall(CallInst& I)
         // If Block
         {
             IRBuilder<> ifBuilder(ifBlock);
-            PointerType *ptrType = IGCLLVM::getWithSamePointeeType(pointerType, targetAS);
+            PointerType* ptrType = IGCLLVM::getNonOpaquePtrEltTy(pointerType)->getPointerTo(targetAS);
             newPtr = ifBuilder.CreateAddrSpaceCast(arg, ptrType);
             ifBuilder.CreateBr(convergeBlock);
         }
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/StaticGASResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/GenericAddressResolution/StaticGASResolution.cpp
@@ -10,7 +10,6 @@ SPDX-License-Identifier: MIT
 
 #include "Compiler/CISACodeGen/ShaderCodeGen.hpp"
 #include "Compiler/InitializePasses.h"
-#include "llvmWrapper/IR/DerivedTypes.h"
 
 FunctionPass* IGC::createStaticGASResolution() { return new StaticGASResolution(); }
 
@@ -60,7 +59,8 @@ bool StaticGASResolution::runOnFunction(llvm::Function& F)
             if (!toSkip(Ptr))
             {
                 PointerType* PtrTy = cast<PointerType>(Ptr->getType());
-                PointerType *glbPtrTy = IGCLLVM::getWithSamePointeeType(PtrTy, ADDRESS_SPACE_GLOBAL);
+                Type* eltTy = IGCLLVM::getNonOpaquePtrEltTy(PtrTy);
+                PointerType* glbPtrTy = PointerType::get(eltTy, ADDRESS_SPACE_GLOBAL);
 
                 IRB.SetInsertPoint(I);
                 Value* NewPtr = IRB.CreateAddrSpaceCast(Ptr, glbPtrTy);
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/LocalBuffers/InlineLocalsResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/LocalBuffers/InlineLocalsResolution.cpp
@@ -519,7 +519,8 @@ void InlineLocalsResolution::computeOffsetList(Module& M, llvm::MapVector<Functi
             offsetMap[F][G] = (offset & 0xFFFF);
 
             // And the total size after this local is added
-            Type *varType = G->getValueType();
+            PointerType* ptrType = dyn_cast<PointerType>(G->getType());
+            Type* varType = IGCLLVM::getNonOpaquePtrEltTy(ptrType);
             if (G == m_pGV)
             {
                 // it is GetMemPoolPtr usage
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/NamedBarriers/NamedBarriersResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/NamedBarriers/NamedBarriersResolution.cpp
@@ -332,7 +332,7 @@ void NamedBarriersResolution::HandleNamedBarrierInitSW(CallInst& NBarrierInitCal
         m_NamedBarrierType->getPointerTo(SPIRAS_Local),
         Type::getInt32PtrTy(context, SPIRAS_Local)
     };
-    Type *BaseTy = m_NamedBarrierArray->getValueType();
+    Type *BaseTy = IGCLLVM::getNonOpaquePtrEltTy(m_NamedBarrierArray->getType());
     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
@@ -420,4 +420,4 @@ bool NamedBarriersResolution::NamedBarrierHWSupport()
 {
     bool hwSupport = m_GFX_CORE == IGFX_XE_HPC_CORE;
     return hwSupport;
-}
+}
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/PoisonFP64KernelsPass/PoisonFP64KernelsPass.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/PoisonFP64KernelsPass/PoisonFP64KernelsPass.cpp
@@ -90,7 +90,7 @@ bool PoisonFP64Kernels::runOnSCC(CallGraphSCC &SCC) {
     return modified;
 }
 
-static GlobalVariable *createPoisonMessage(Module *M, Function *Kernel) {
+static Constant *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));
 
-    GlobalVariable *PoisonMessage = createPoisonMessage(M, Kernel);
-    Type *MessageType = PoisonMessage->getValueType();
+    Constant *PoisonMessage = createPoisonMessage(M, Kernel);
+    Type *MessageType = IGCLLVM::getNonOpaquePtrEltTy(PoisonMessage->getType());
 
     std::vector<Value *> Indices = {
         ConstantInt::getSigned(Type::getInt32Ty(Ctx), 0),
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp
@@ -571,7 +571,7 @@ class TransposeHelperPrivateMem : public TransposeHelper
         IRB.SetInsertPoint(pLoad);
         if (!vectorIO && pLoad->getType()->isVectorTy())
         {
-            Type *scalarType = pLoad->getType()->getScalarType();
+            Type* scalarType = IGCLLVM::getNonOpaquePtrEltTy(pLoad->getPointerOperand()->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 = pStore->getValueOperand()->getType()->getScalarType();
+            Type* scalarType = IGCLLVM::getNonOpaquePtrEltTy(pStore->getPointerOperand()->getType())->getScalarType();
             IGC_ASSERT(nullptr != scalarType);
             Type* scalarptrTy = PointerType::get(scalarType, pStore->getPointerAddressSpace());
             IGC_ASSERT(scalarType->getPrimitiveSizeInBits() / 8 == elementSize);
@@ -997,7 +997,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 = pAI->getAllocatedType();
+                Type* allocaType = GetBaseType(IGCLLVM::getNonOpaquePtrEltTy(pAI->getType()));
                 if (VectorType* vectorType = dyn_cast<VectorType>(allocaType))
                 {
                     bool baseTypeIsSmall = (unsigned)(vectorType->getElementType()->getScalarSizeInBits()) < 32;
@@ -1011,7 +1011,7 @@ bool PrivateMemoryResolution::resolveAllocaInstructions(bool privateOnStack)
             {
                 auto DL = &m_currFunction->getParent()->getDataLayout();
                 bufferSize = (unsigned)DL->getTypeAllocSize(pTypeOfAccessedObject);
-                IGC_ASSERT(testTransposedMemory(pAI->getAllocatedType(), pTypeOfAccessedObject, bufferSize, (m_ModAllocaInfo->getConstBufferSize(pAI))));
+                IGC_ASSERT(testTransposedMemory(IGCLLVM::getNonOpaquePtrEltTy(pAI->getType()), pTypeOfAccessedObject, bufferSize, (m_ModAllocaInfo->getConstBufferSize(pAI))));
             }
             else
             {
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryToSLM.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryToSLM.cpp
@@ -192,7 +192,8 @@ namespace IGC
             unsigned int offset = 0;
             for (const auto &offsets : ModuleMD->FuncMD[F].localOffsets)
             {
-                Type* varType = offsets.m_Var->getValueType();
+                PointerType* ptrType = dyn_cast<PointerType>(offsets.m_Var->getType());
+                Type* varType = IGCLLVM::getNonOpaquePtrEltTy(ptrType);
                 offset = iSTD::Align(offset, IGCLLVM::getPreferredAlignValue(&DL, offsets.m_Var));
                 offset += (unsigned int) DL.getTypeAllocSize(varType);
             }
@@ -228,7 +229,7 @@ namespace IGC
 
                 if (m_ForceAll || isForcedBuffer)
                 {
-                    Type *origType = pAI->getAllocatedType();
+                    Type* origType = IGCLLVM::getNonOpaquePtrEltTy(pAI->getType());
                     bool isArray = origType->isArrayTy();
                     Type* eltType = isArray ? origType->getArrayElementType() : origType;
                     uint64_t numEltsPerThread = isArray ? origType->getArrayNumElements() : 1;
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantAnalysis.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantAnalysis.cpp
@@ -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(globalVar->getValueType()));
+        offset += (unsigned)(m_DL->getTypeAllocSize(IGCLLVM::getNonOpaquePtrEltTy(globalVar->getType())));
     }
 
     // Patch the offsets for usages of zero initialized globals after those offsets have been calculated in the previous step.
diff --git a/IGC/Compiler/Optimizer/PreCompiledFuncImport.cpp b/IGC/Compiler/Optimizer/PreCompiledFuncImport.cpp
@@ -549,9 +549,8 @@ bool PreCompiledFuncImport::preProcessDouble()
             else if (Inst->getOpcode() == Instruction::FNeg)
             {
                 // check if Inst is double instruction or vector of double instructions
-                Type *instType = Inst->getType();
-                IGCLLVM::FixedVectorType *instVecType = dyn_cast<IGCLLVM::FixedVectorType>(instType);
-                if (instType->isDoubleTy() || (instVecType && instVecType->getElementType()->isDoubleTy()))
+                if (Inst->getType()->isDoubleTy() ||
+                    (Inst->getType()->isVectorTy() && IGCLLVM::getNonOpaquePtrEltTy(Inst->getType())->isDoubleTy()))
                 {
                     IGCLLVM::IRBuilder<> builder(Inst);
                     Value* fsub = nullptr;
diff --git a/IGC/WrapperLLVM/include/llvmWrapper/IR/DerivedTypes.h b/IGC/WrapperLLVM/include/llvmWrapper/IR/DerivedTypes.h
@@ -15,8 +15,6 @@ SPDX-License-Identifier: MIT
 #include "llvm/IR/Module.h"
 #include "common/CommonMacros.h"
 
-#include "Type.h"
-
 namespace IGCLLVM
 {
 
@@ -72,23 +70,6 @@ namespace IGCLLVM
       return EltTy;
 #else
       return Ty->getWithNewBitWidth(NewBitWidth);
-#endif
-    }
-
-    inline llvm::PointerType *getWithSamePointeeType(llvm::PointerType *PT, unsigned AddressSpace) {
-#if LLVM_VERSION_MAJOR < 14
-        return llvm::PointerType::get(PT->getElementType(), AddressSpace);
-#else
-        return llvm::PointerType::getWithSamePointeeType(PT, AddressSpace);
-#endif
-    }
-
-    inline bool isOpaqueOrPointeeTypeEquals(llvm::Type *tyA, llvm::Type *tyB) {
-#if LLVM_VERSION_MAJOR < 14
-        return IGCLLVM::getNonOpaquePtrEltTy(tyA) == IGCLLVM::getNonOpaquePtrEltTy(tyB);
-#else
-        llvm::PointerType *pTyA = llvm::dyn_cast<llvm::PointerType>(tyA);
-        return pTyA && pTyA->isOpaqueOrPointeeTypeMatches(tyB);
 #endif
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,8 @@ auto AlignmentAnalysis::getAlignValue(Value* V) const`
`132`	`132`	`// If the globalvariable uses the default alignment, pull it from the datalayout`
`133`	`133`	`if (!align)`
`134`	`134`	`{`
`135`		`- return m_DL->getABITypeAlignment(GV->getValueType());`
	`135`	`+ Type* gvType = GV->getType();`
	`136`	`+ return m_DL->getABITypeAlignment(IGCLLVM::getNonOpaquePtrEltTy(gvType));`
`136`	`137`	`}`
`137`	`138`	`else`
`138`	`139`	`{`
`@@ -224,7 +225,8 @@ alignment_t AlignmentAnalysis::visitAllocaInst(AllocaInst& I)`
`224`	`225`	`// If the alloca uses the default alignment, pull it from the datalayout`
`225`	`226`	`if (!newAlign)`
`226`	`227`	`{`
`227`		`- newAlign = m_DL->getABITypeAlignment(I.getAllocatedType());`
	`228`	`+ Type* allocaType = I.getType();`
	`229`	`+ newAlign = m_DL->getABITypeAlignment(IGCLLVM::getNonOpaquePtrEltTy(allocaType));`
`228`	`230`	`}`
`229`	`231`
`230`	`232`	`return newAlign;`
Original file line number	Diff line number	Diff line change
`@@ -519,7 +519,8 @@ void InlineLocalsResolution::computeOffsetList(Module& M, llvm::MapVector<Functi`
`519`	`519`	`offsetMap[F][G] = (offset & 0xFFFF);`
`520`	`520`
`521`	`521`	`// And the total size after this local is added`
`522`		`- Type *varType = G->getValueType();`
	`522`	`+ PointerType* ptrType = dyn_cast<PointerType>(G->getType());`
	`523`	`+ Type* varType = IGCLLVM::getNonOpaquePtrEltTy(ptrType);`
`523`	`524`	`if (G == m_pGV)`
`524`	`525`	`{`
`525`	`526`	`// it is GetMemPoolPtr usage`