Index: clang/lib/CodeGen/CGAtomic.cpp =================================================================== --- clang/lib/CodeGen/CGAtomic.cpp +++ clang/lib/CodeGen/CGAtomic.cpp @@ -85,7 +85,7 @@ (C.toCharUnitsFromBits(OrigBFI.Offset) / lvalue.getAlignment()) * lvalue.getAlignment(); VoidPtrAddr = CGF.Builder.CreateConstGEP1_64( - VoidPtrAddr, OffsetInChars.getQuantity()); + CGF.Int8Ty, VoidPtrAddr, OffsetInChars.getQuantity()); auto Addr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast( VoidPtrAddr, CGF.Builder.getIntNTy(AtomicSizeInBits)->getPointerTo(), Index: clang/lib/CodeGen/CGBlocks.cpp =================================================================== --- clang/lib/CodeGen/CGBlocks.cpp +++ clang/lib/CodeGen/CGBlocks.cpp @@ -1373,7 +1373,7 @@ llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry", Init)); b.CreateAlignedStore(CGM.getNSConcreteGlobalBlock(), - b.CreateStructGEP(literal, 0), + b.CreateStructGEP(literal->getValueType(), literal, 0), CGM.getPointerAlign().getAsAlign()); b.CreateRetVoid(); // We can't use the normal LLVM global initialisation array, because we Index: clang/lib/CodeGen/CGBuilder.h =================================================================== --- clang/lib/CodeGen/CGBuilder.h +++ clang/lib/CodeGen/CGBuilder.h @@ -198,7 +198,7 @@ CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy->getElementType())); return Address( - CreateInBoundsGEP(Addr.getPointer(), + CreateInBoundsGEP(Addr.getElementType(), Addr.getPointer(), {getSize(CharUnits::Zero()), getSize(Index)}, Name), Addr.getAlignment().alignmentAtOffset(Index * EltSize)); } @@ -239,13 +239,15 @@ Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name = "") { assert(Addr.getElementType() == TypeCache.Int8Ty); - return Address(CreateInBoundsGEP(Addr.getPointer(), getSize(Offset), Name), + return Address(CreateInBoundsGEP(Addr.getElementType(), Addr.getPointer(), + getSize(Offset), Name), Addr.getAlignment().alignmentAtOffset(Offset)); } Address CreateConstByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name = "") { assert(Addr.getElementType() == TypeCache.Int8Ty); - return Address(CreateGEP(Addr.getPointer(), getSize(Offset), Name), + return Address(CreateGEP(Addr.getElementType(), Addr.getPointer(), + getSize(Offset), Name), Addr.getAlignment().alignmentAtOffset(Offset)); } Index: clang/lib/CodeGen/CGBuiltin.cpp =================================================================== --- clang/lib/CodeGen/CGBuiltin.cpp +++ clang/lib/CodeGen/CGBuiltin.cpp @@ -2635,7 +2635,8 @@ Builder.CreateMemCpy(Dest, Src, SizeVal, false); if (BuiltinID == Builtin::BImempcpy || BuiltinID == Builtin::BI__builtin_mempcpy) - return RValue::get(Builder.CreateInBoundsGEP(Dest.getPointer(), SizeVal)); + return RValue::get(Builder.CreateInBoundsGEP(Dest.getElementType(), + Dest.getPointer(), SizeVal)); else return RValue::get(Dest.getPointer()); } @@ -4059,7 +4060,8 @@ auto *Zero = llvm::ConstantInt::get(IntTy, 0); for (unsigned I = First; I < NumArgs; ++I) { auto *Index = llvm::ConstantInt::get(IntTy, I - First); - auto *GEP = Builder.CreateGEP(TmpPtr, {Zero, Index}); + auto *GEP = + Builder.CreateGEP(Tmp.getElementType(), TmpPtr, {Zero, Index}); if (I == First) ElemPtr = GEP; auto *V = @@ -8431,7 +8433,7 @@ for (unsigned I = 0; I < NumOpnds; ++I) Builder.CreateDefaultAlignedStore( IsBoolTy ? Builder.CreateZExt(Ops[I], EltTy) : Ops[I], - Builder.CreateGEP(Alloca.getPointer(), + Builder.CreateGEP(Alloca.getElementType(), Alloca.getPointer(), {Builder.getInt64(0), Builder.getInt64(I)})); SVETypeFlags TypeFlags(Builtin->TypeModifier); @@ -8439,8 +8441,9 @@ llvm::Type *OverloadedTy = getSVEVectorForElementType(EltTy); Function *F = CGM.getIntrinsic(Intrinsic::aarch64_sve_ld1rq, OverloadedTy); - Value *Alloca0 = Builder.CreateGEP( - Alloca.getPointer(), {Builder.getInt64(0), Builder.getInt64(0)}); + Value *Alloca0 = + Builder.CreateGEP(Alloca.getElementType(), Alloca.getPointer(), + {Builder.getInt64(0), Builder.getInt64(0)}); Value *LD1RQ = Builder.CreateCall(F, {Pred, Alloca0}); if (!IsBoolTy) @@ -14108,7 +14111,7 @@ Ops[0] = Builder.CreateBitCast(Ops[0], Int8PtrTy); }else { Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy); - Ops[0] = Builder.CreateGEP(Ops[1], Ops[0]); + Ops[0] = Builder.CreateGEP(Int8Ty, Ops[1], Ops[0]); Ops.pop_back(); } @@ -14176,7 +14179,7 @@ Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy); }else { Ops[2] = Builder.CreateBitCast(Ops[2], Int8PtrTy); - Ops[1] = Builder.CreateGEP(Ops[2], Ops[1]); + Ops[1] = Builder.CreateGEP(Int8Ty, Ops[2], Ops[1]); Ops.pop_back(); } @@ -14565,7 +14568,7 @@ auto *DP = EmitAMDGPUDispatchPtr(CGF); // Indexing the HSA kernel_dispatch_packet struct. auto *Offset = llvm::ConstantInt::get(CGF.Int32Ty, XOffset + Index * 2); - auto *GEP = CGF.Builder.CreateGEP(DP, Offset); + auto *GEP = CGF.Builder.CreateGEP(CGF.Int8Ty, DP, Offset); auto *DstTy = CGF.Int16Ty->getPointerTo(GEP->getType()->getPointerAddressSpace()); auto *Cast = CGF.Builder.CreateBitCast(GEP, DstTy); @@ -15839,7 +15842,7 @@ Builder.CreateAlignedStore( Builder.CreateBitCast(Builder.CreateExtractValue(Result, i), Dst.getElementType()), - Builder.CreateGEP(Dst.getPointer(), + Builder.CreateGEP(Dst.getElementType(), Dst.getPointer(), llvm::ConstantInt::get(IntTy, i)), CharUnits::fromQuantity(4)); } @@ -15876,7 +15879,8 @@ SmallVector Values = {Dst}; for (unsigned i = 0; i < II.NumResults; ++i) { Value *V = Builder.CreateAlignedLoad( - Builder.CreateGEP(Src.getPointer(), llvm::ConstantInt::get(IntTy, i)), + Builder.CreateGEP(Src.getElementType(), Src.getPointer(), + llvm::ConstantInt::get(IntTy, i)), CharUnits::fromQuantity(4)); Values.push_back(Builder.CreateBitCast(V, ParamType)); } @@ -15939,7 +15943,7 @@ // Load A for (unsigned i = 0; i < MI.NumEltsA; ++i) { Value *V = Builder.CreateAlignedLoad( - Builder.CreateGEP(SrcA.getPointer(), + Builder.CreateGEP(SrcA.getElementType(), SrcA.getPointer(), llvm::ConstantInt::get(IntTy, i)), CharUnits::fromQuantity(4)); Values.push_back(Builder.CreateBitCast(V, AType)); @@ -15948,7 +15952,7 @@ llvm::Type *BType = Intrinsic->getFunctionType()->getParamType(MI.NumEltsA); for (unsigned i = 0; i < MI.NumEltsB; ++i) { Value *V = Builder.CreateAlignedLoad( - Builder.CreateGEP(SrcB.getPointer(), + Builder.CreateGEP(SrcB.getElementType(), SrcB.getPointer(), llvm::ConstantInt::get(IntTy, i)), CharUnits::fromQuantity(4)); Values.push_back(Builder.CreateBitCast(V, BType)); @@ -15958,7 +15962,7 @@ Intrinsic->getFunctionType()->getParamType(MI.NumEltsA + MI.NumEltsB); for (unsigned i = 0; i < MI.NumEltsC; ++i) { Value *V = Builder.CreateAlignedLoad( - Builder.CreateGEP(SrcC.getPointer(), + Builder.CreateGEP(SrcC.getElementType(), SrcC.getPointer(), llvm::ConstantInt::get(IntTy, i)), CharUnits::fromQuantity(4)); Values.push_back(Builder.CreateBitCast(V, CType)); @@ -15968,7 +15972,8 @@ for (unsigned i = 0; i < MI.NumEltsD; ++i) Builder.CreateAlignedStore( Builder.CreateBitCast(Builder.CreateExtractValue(Result, i), DType), - Builder.CreateGEP(Dst.getPointer(), llvm::ConstantInt::get(IntTy, i)), + Builder.CreateGEP(Dst.getElementType(), Dst.getPointer(), + llvm::ConstantInt::get(IntTy, i)), CharUnits::fromQuantity(4)); return Result; } @@ -16052,9 +16057,10 @@ // can use an inbounds GEP to enable better optimization. Value *Base = EmitCastToVoidPtr(Args.Src); if (getLangOpts().isSignedOverflowDefined()) - Result = Builder.CreateGEP(Base, Difference, "aligned_result"); + Result = Builder.CreateGEP(Builder.getInt8Ty(), Base, Difference, + "aligned_result"); else - Result = EmitCheckedInBoundsGEP(Base, Difference, + Result = EmitCheckedInBoundsGEP(Builder.getInt8Ty(), Base, Difference, /*SignedIndices=*/true, /*isSubtraction=*/!AlignUp, E->getExprLoc(), "aligned_result"); Index: clang/lib/CodeGen/CGCUDANV.cpp =================================================================== --- clang/lib/CodeGen/CGCUDANV.cpp +++ clang/lib/CodeGen/CGCUDANV.cpp @@ -265,7 +265,8 @@ llvm::Value* VarPtr = CGF.GetAddrOfLocalVar(Args[i]).getPointer(); llvm::Value *VoidVarPtr = CGF.Builder.CreatePointerCast(VarPtr, VoidPtrTy); CGF.Builder.CreateDefaultAlignedStore( - VoidVarPtr, CGF.Builder.CreateConstGEP1_32(KernelArgs.getPointer(), i)); + VoidVarPtr, CGF.Builder.CreateConstGEP1_32(KernelArgs.getElementType(), + KernelArgs.getPointer(), i)); } llvm::BasicBlock *EndBlock = CGF.createBasicBlock("setup.end"); Index: clang/lib/CodeGen/CGCXX.cpp =================================================================== --- clang/lib/CodeGen/CGCXX.cpp +++ clang/lib/CodeGen/CGCXX.cpp @@ -252,8 +252,8 @@ "No kext in Microsoft ABI"); CodeGenModule &CGM = CGF.CGM; llvm::Value *VTable = CGM.getCXXABI().getAddrOfVTable(RD, CharUnits()); - Ty = Ty->getPointerTo()->getPointerTo(); - VTable = CGF.Builder.CreateBitCast(VTable, Ty); + Ty = Ty->getPointerTo(); + VTable = CGF.Builder.CreateBitCast(VTable, Ty->getPointerTo()); assert(VTable && "BuildVirtualCall = kext vtbl pointer is null"); uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD); const VTableLayout &VTLayout = CGM.getItaniumVTableContext().getVTableLayout(RD); @@ -262,7 +262,7 @@ VTableIndex += VTLayout.getVTableOffset(AddressPoint.VTableIndex) + AddressPoint.AddressPointIndex; llvm::Value *VFuncPtr = - CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfnkxt"); + CGF.Builder.CreateConstInBoundsGEP1_64(Ty, VTable, VTableIndex, "vfnkxt"); llvm::Value *VFunc = CGF.Builder.CreateAlignedLoad( VFuncPtr, llvm::Align(CGF.PointerAlignInBytes)); CGCallee Callee(GD, VFunc); Index: clang/lib/CodeGen/CGClass.cpp =================================================================== --- clang/lib/CodeGen/CGClass.cpp +++ clang/lib/CodeGen/CGClass.cpp @@ -271,7 +271,7 @@ llvm::Value *ptr = addr.getPointer(); unsigned AddrSpace = ptr->getType()->getPointerAddressSpace(); ptr = CGF.Builder.CreateBitCast(ptr, CGF.Int8Ty->getPointerTo(AddrSpace)); - ptr = CGF.Builder.CreateInBoundsGEP(ptr, baseOffset, "add.ptr"); + ptr = CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, ptr, baseOffset, "add.ptr"); // If we have a virtual component, the alignment of the result will // be relative only to the known alignment of that vbase. @@ -433,8 +433,8 @@ // Apply the offset. llvm::Value *Value = Builder.CreateBitCast(BaseAddr.getPointer(), Int8PtrTy); - Value = Builder.CreateInBoundsGEP(Value, Builder.CreateNeg(NonVirtualOffset), - "sub.ptr"); + Value = Builder.CreateInBoundsGEP( + Int8Ty, Value, Builder.CreateNeg(NonVirtualOffset), "sub.ptr"); // Just cast. Value = Builder.CreateBitCast(Value, DerivedPtrTy); @@ -494,13 +494,13 @@ if (CGM.getCXXABI().NeedsVTTParameter(CurGD)) { // A VTT parameter was passed to the constructor, use it. VTT = LoadCXXVTT(); - VTT = Builder.CreateConstInBoundsGEP1_64(VTT, SubVTTIndex); } else { // We're the complete constructor, so get the VTT by name. VTT = CGM.getVTables().GetAddrOfVTT(RD); - VTT = Builder.CreateConstInBoundsGEP2_64(VTT, 0, SubVTTIndex); + VTT = Builder.CreateBitCast(VTT, Int8PtrPtrTy); } + VTT = Builder.CreateConstInBoundsGEP1_64(Int8PtrTy, VTT, SubVTTIndex); return VTT; } @@ -1736,6 +1736,7 @@ .getQuantity()); llvm::Value *OffsetPtr = CGF.Builder.CreateGEP( + CGF.Int8Ty, CGF.Builder.CreateBitCast(CGF.LoadCXXThis(), CGF.Int8PtrTy), OffsetSizePtr); @@ -1961,8 +1962,9 @@ // Find the end of the array. llvm::Value *arrayBegin = arrayBase.getPointer(); - llvm::Value *arrayEnd = Builder.CreateInBoundsGEP(arrayBegin, numElements, - "arrayctor.end"); + llvm::Type *arrayEltTy = arrayBase.getElementType(); + llvm::Value *arrayEnd = Builder.CreateInBoundsGEP( + arrayEltTy, arrayBegin, numElements, "arrayctor.end"); // Enter the loop, setting up a phi for the current location to initialize. llvm::BasicBlock *entryBB = Builder.GetInsertBlock(); @@ -2020,9 +2022,8 @@ } // Go to the next element. - llvm::Value *next = - Builder.CreateInBoundsGEP(cur, llvm::ConstantInt::get(SizeTy, 1), - "arrayctor.next"); + llvm::Value *next = Builder.CreateInBoundsGEP( + arrayEltTy, cur, llvm::ConstantInt::get(SizeTy, 1), "arrayctor.next"); cur->addIncoming(next, Builder.GetInsertBlock()); // Check whether that's the end of the loop. Index: clang/lib/CodeGen/CGDecl.cpp =================================================================== --- clang/lib/CodeGen/CGDecl.cpp +++ clang/lib/CodeGen/CGDecl.cpp @@ -1739,8 +1739,8 @@ llvm::Value *BaseSizeInChars = llvm::ConstantInt::get(IntPtrTy, EltSize.getQuantity()); Address Begin = Builder.CreateElementBitCast(Loc, Int8Ty, "vla.begin"); - llvm::Value *End = - Builder.CreateInBoundsGEP(Begin.getPointer(), SizeVal, "vla.end"); + llvm::Value *End = Builder.CreateInBoundsGEP(Int8Ty, Begin.getPointer(), + SizeVal, "vla.end"); llvm::BasicBlock *OriginBB = Builder.GetInsertBlock(); EmitBlock(LoopBB); llvm::PHINode *Cur = Builder.CreatePHI(Begin.getType(), 2, "vla.cur"); @@ -2140,8 +2140,9 @@ } llvm::Value *begin = addr.getPointer(); - llvm::Value *end = Builder.CreateInBoundsGEP(begin, length); - emitArrayDestroy(begin, end, type, elementAlign, destroyer, + llvm::Value *end = + Builder.CreateInBoundsGEP(addr.getElementType(), begin, length); + emitArrayDestroy(begin, end, type, elementAlign, addr.getElementType(), destroyer, checkZeroLength, useEHCleanupForArray); } @@ -2159,6 +2160,7 @@ llvm::Value *end, QualType elementType, CharUnits elementAlign, + llvm::Type *elementMemType, Destroyer *destroyer, bool checkZeroLength, bool useEHCleanup) { @@ -2184,8 +2186,8 @@ // Shift the address back by one element. llvm::Value *negativeOne = llvm::ConstantInt::get(SizeTy, -1, true); - llvm::Value *element = Builder.CreateInBoundsGEP(elementPast, negativeOne, - "arraydestroy.element"); + llvm::Value *element = Builder.CreateInBoundsGEP( + elementMemType, elementPast, negativeOne, "arraydestroy.element"); if (useEHCleanup) pushRegularPartialArrayCleanup(begin, element, elementType, elementAlign, @@ -2214,25 +2216,29 @@ CodeGenFunction::Destroyer *destroyer) { // If the element type is itself an array, drill down. unsigned arrayDepth = 0; - while (const ArrayType *arrayType = CGF.getContext().getAsArrayType(type)) { + QualType scalarType = type; + while (const ArrayType *arrayType = + CGF.getContext().getAsArrayType(scalarType)) { // VLAs don't require a GEP index to walk into. if (!isa(arrayType)) arrayDepth++; - type = arrayType->getElementType(); + scalarType = arrayType->getElementType(); } if (arrayDepth) { llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0); - SmallVector gepIndices(arrayDepth+1, zero); - begin = CGF.Builder.CreateInBoundsGEP(begin, gepIndices, "pad.arraybegin"); - end = CGF.Builder.CreateInBoundsGEP(end, gepIndices, "pad.arrayend"); + begin = CGF.Builder.CreateInBoundsGEP(CGF.ConvertTypeForMem(type), begin, + gepIndices, "pad.arraybegin"); + end = CGF.Builder.CreateInBoundsGEP(CGF.ConvertTypeForMem(type), end, + gepIndices, "pad.arrayend"); } // Destroy the array. We don't ever need an EH cleanup because we // assume that we're in an EH cleanup ourselves, so a throwing // destructor causes an immediate terminate. - CGF.emitArrayDestroy(begin, end, type, elementAlign, destroyer, + CGF.emitArrayDestroy(begin, end, scalarType, elementAlign, + CGF.ConvertTypeForMem(scalarType), destroyer, /*checkZeroLength*/ true, /*useEHCleanup*/ false); } Index: clang/lib/CodeGen/CGExpr.cpp =================================================================== --- clang/lib/CodeGen/CGExpr.cpp +++ clang/lib/CodeGen/CGExpr.cpp @@ -849,9 +849,9 @@ llvm::ConstantInt::get(IntPtrTy, CacheSize-1)); llvm::Value *Indices[] = { Builder.getInt32(0), Slot }; - llvm::Value *CacheVal = - Builder.CreateAlignedLoad(Builder.CreateInBoundsGEP(Cache, Indices), - getPointerAlign()); + llvm::Value *CacheVal = Builder.CreateAlignedLoad( + Builder.CreateInBoundsGEP(HashTable, Cache, Indices), + getPointerAlign()); // If the hash isn't in the cache, call a runtime handler to perform the // hard work of checking whether the vptr is for an object of the right @@ -3507,6 +3507,7 @@ } static llvm::Value *emitArraySubscriptGEP(CodeGenFunction &CGF, + llvm::Type *ty, llvm::Value *ptr, ArrayRef indices, bool inbounds, @@ -3514,11 +3515,11 @@ SourceLocation loc, const llvm::Twine &name = "arrayidx") { if (inbounds) { - return CGF.EmitCheckedInBoundsGEP(ptr, indices, signedIndices, + return CGF.EmitCheckedInBoundsGEP(ty, ptr, indices, signedIndices, CodeGenFunction::NotSubtraction, loc, name); } else { - return CGF.Builder.CreateGEP(ptr, indices, name); + return CGF.Builder.CreateGEP(ty, ptr, indices, name); } } @@ -3611,9 +3612,9 @@ auto LastIndex = dyn_cast(indices.back()); if (!LastIndex || (!CGF.IsInPreservedAIRegion && !IsPreserveAIArrayBase(CGF, Base))) { - eltPtr = emitArraySubscriptGEP( - CGF, addr.getPointer(), indices, inbounds, signedIndices, - loc, name); + eltPtr = + emitArraySubscriptGEP(CGF, addr.getElementType(), addr.getPointer(), + indices, inbounds, signedIndices, loc, name); } else { // Remember the original array subscript for bpf target unsigned idx = LastIndex->getZExtValue(); @@ -3738,8 +3739,8 @@ CharUnits EltAlign = getArrayElementAlign(Addr.getAlignment(), Idx, InterfaceSize); llvm::Value *EltPtr = - emitArraySubscriptGEP(*this, Addr.getPointer(), ScaledIdx, false, - SignedIndices, E->getExprLoc()); + emitArraySubscriptGEP(*this, Addr.getElementType(), Addr.getPointer(), + ScaledIdx, false, SignedIndices, E->getExprLoc()); Addr = Address(EltPtr, EltAlign); // Cast back. Index: clang/lib/CodeGen/CGExprAgg.cpp =================================================================== --- clang/lib/CodeGen/CGExprAgg.cpp +++ clang/lib/CodeGen/CGExprAgg.cpp @@ -417,8 +417,8 @@ LValue Start = CGF.EmitLValueForFieldInitialization(DestLV, *Field); llvm::Value *Zero = llvm::ConstantInt::get(CGF.PtrDiffTy, 0); llvm::Value *IdxStart[] = { Zero, Zero }; - llvm::Value *ArrayStart = - Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxStart, "arraystart"); + llvm::Value *ArrayStart = Builder.CreateInBoundsGEP( + ArrayPtr.getElementType(), ArrayPtr.getPointer(), IdxStart, "arraystart"); CGF.EmitStoreThroughLValue(RValue::get(ArrayStart), Start); ++Field; @@ -434,8 +434,8 @@ ArrayType->getElementType())) { // End pointer. llvm::Value *IdxEnd[] = { Zero, Size }; - llvm::Value *ArrayEnd = - Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxEnd, "arrayend"); + llvm::Value *ArrayEnd = Builder.CreateInBoundsGEP( + ArrayPtr.getElementType(), ArrayPtr.getPointer(), IdxEnd, "arrayend"); CGF.EmitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength); } else if (Ctx.hasSameType(Field->getType(), Ctx.getSizeType())) { // Length. @@ -479,13 +479,15 @@ QualType elementType = CGF.getContext().getAsArrayType(ArrayQTy)->getElementType(); + llvm::Type *gepType = CGF.ConvertTypeForMem(elementType); // DestPtr is an array*. Construct an elementType* by drilling // down a level. llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0); llvm::Value *indices[] = { zero, zero }; llvm::Value *begin = - Builder.CreateInBoundsGEP(DestPtr.getPointer(), indices, "arrayinit.begin"); + Builder.CreateInBoundsGEP(DestPtr.getElementType(), DestPtr.getPointer(), + indices, "arrayinit.begin"); CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType); CharUnits elementAlign = @@ -552,7 +554,8 @@ for (uint64_t i = 0; i != NumInitElements; ++i) { // Advance to the next element. if (i > 0) { - element = Builder.CreateInBoundsGEP(element, one, "arrayinit.element"); + element = + Builder.CreateInBoundsGEP(gepType, element, one, "arrayinit.element"); // Tell the cleanup that it needs to destroy up to this // element. TODO: some of these stores can be trivially @@ -581,14 +584,15 @@ // Advance to the start of the rest of the array. if (NumInitElements) { - element = Builder.CreateInBoundsGEP(element, one, "arrayinit.start"); + element = + Builder.CreateInBoundsGEP(gepType, element, one, "arrayinit.start"); if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit); } // Compute the end of the array. - llvm::Value *end = Builder.CreateInBoundsGEP(begin, - llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements), - "arrayinit.end"); + llvm::Value *end = Builder.CreateInBoundsGEP( + gepType, begin, llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements), + "arrayinit.end"); llvm::BasicBlock *entryBB = Builder.GetInsertBlock(); llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body"); @@ -617,7 +621,7 @@ // Move on to the next element. llvm::Value *nextElement = - Builder.CreateInBoundsGEP(currentElement, one, "arrayinit.next"); + Builder.CreateInBoundsGEP(gepType, currentElement, one, "arrayinit.next"); // Tell the EH cleanup that we finished with the last element. if (endOfInit.isValid()) Builder.CreateStore(nextElement, endOfInit); @@ -1662,8 +1666,9 @@ // destPtr is an array*. Construct an elementType* by drilling down a level. llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0); llvm::Value *indices[] = {zero, zero}; - llvm::Value *begin = Builder.CreateInBoundsGEP(destPtr.getPointer(), indices, - "arrayinit.begin"); + llvm::Value *begin = + Builder.CreateInBoundsGEP(destPtr.getElementType(), destPtr.getPointer(), + indices, "arrayinit.begin"); // Prepare to special-case multidimensional array initialization: we avoid // emitting multiple destructor loops in that case. @@ -1673,6 +1678,7 @@ QualType elementType = CGF.getContext().getAsArrayType(E->getType())->getElementType(); + llvm::Type *gepType = CGF.ConvertTypeForMem(elementType); CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType); CharUnits elementAlign = destPtr.getAlignment().alignmentOfArrayElement(elementSize); @@ -1685,7 +1691,7 @@ llvm::PHINode *index = Builder.CreatePHI(zero->getType(), 2, "arrayinit.index"); index->addIncoming(zero, entryBB); - llvm::Value *element = Builder.CreateInBoundsGEP(begin, index); + llvm::Value *element = Builder.CreateInBoundsGEP(gepType, begin, index); // Prepare for a cleanup. QualType::DestructionKind dtorKind = elementType.isDestructedType(); Index: clang/lib/CodeGen/CGExprCXX.cpp =================================================================== --- clang/lib/CodeGen/CGExprCXX.cpp +++ clang/lib/CodeGen/CGExprCXX.cpp @@ -1048,9 +1048,9 @@ cast(ILE->getType()->getAsArrayTypeUnsafe()) ->getSize().getZExtValue(); CurPtr = - Address(Builder.CreateInBoundsGEP(CurPtr.getPointer(), - Builder.getSize(InitListElements), - "string.init.end"), + Address(Builder.CreateInBoundsGEP( + CurPtr.getElementType(), CurPtr.getPointer(), + Builder.getSize(InitListElements), "string.init.end"), CurPtr.getAlignment().alignmentAtOffset(InitListElements * ElementSize)); @@ -1107,9 +1107,9 @@ StoreAnyExprIntoOneUnit(*this, ILE->getInit(i), ILE->getInit(i)->getType(), CurPtr, AggValueSlot::DoesNotOverlap); - CurPtr = Address(Builder.CreateInBoundsGEP(CurPtr.getPointer(), - Builder.getSize(1), - "array.exp.next"), + CurPtr = Address(Builder.CreateInBoundsGEP( + CurPtr.getElementType(), CurPtr.getPointer(), + Builder.getSize(1), "array.exp.next"), StartAlign.alignmentAtOffset((i + 1) * ElementSize)); } @@ -1225,8 +1225,9 @@ llvm::BasicBlock *ContBB = createBasicBlock("new.loop.end"); // Find the end of the array, hoisted out of the loop. - llvm::Value *EndPtr = - Builder.CreateInBoundsGEP(BeginPtr.getPointer(), NumElements, "array.end"); + llvm::Value *EndPtr = Builder.CreateInBoundsGEP(BeginPtr.getElementType(), + BeginPtr.getPointer(), + NumElements, "array.end"); // If the number of elements isn't constant, we have to now check if there is // anything left to initialize. @@ -2033,13 +2034,14 @@ deletedPtr.getAlignment().alignmentOfArrayElement(elementSize); llvm::Value *arrayBegin = deletedPtr.getPointer(); - llvm::Value *arrayEnd = - CGF.Builder.CreateInBoundsGEP(arrayBegin, numElements, "delete.end"); + llvm::Value *arrayEnd = CGF.Builder.CreateInBoundsGEP( + deletedPtr.getElementType(), arrayBegin, numElements, "delete.end"); // Note that it is legal to allocate a zero-length array, and we // can never fold the check away because the length should always // come from a cookie. CGF.emitArrayDestroy(arrayBegin, arrayEnd, elementType, elementAlign, + deletedPtr.getElementType(), CGF.getDestroyer(dtorKind), /*checkZeroLength*/ true, CGF.needsEHCleanup(dtorKind)); @@ -2097,7 +2099,8 @@ GEP.push_back(Zero); } - Ptr = Address(Builder.CreateInBoundsGEP(Ptr.getPointer(), GEP, "del.first"), + Ptr = Address(Builder.CreateInBoundsGEP(Ptr.getElementType(), + Ptr.getPointer(), GEP, "del.first"), Ptr.getAlignment()); } Index: clang/lib/CodeGen/CGExprScalar.cpp =================================================================== --- clang/lib/CodeGen/CGExprScalar.cpp +++ clang/lib/CodeGen/CGExprScalar.cpp @@ -2550,12 +2550,13 @@ if (const VariableArrayType *vla = CGF.getContext().getAsVariableArrayType(type)) { llvm::Value *numElts = CGF.getVLASize(vla).NumElts; + llvm::Type *eltType = CGF.ConvertTypeForMem(vla->getElementType()); if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize"); if (CGF.getLangOpts().isSignedOverflowDefined()) - value = Builder.CreateGEP(value, numElts, "vla.inc"); + value = Builder.CreateGEP(eltType, value, numElts, "vla.inc"); else value = CGF.EmitCheckedInBoundsGEP( - value, numElts, /*SignedIndices=*/false, isSubtraction, + eltType, value, numElts, /*SignedIndices=*/false, isSubtraction, E->getExprLoc(), "vla.inc"); // Arithmetic on function pointers (!) is just +-1. @@ -2564,22 +2565,23 @@ value = CGF.EmitCastToVoidPtr(value); if (CGF.getLangOpts().isSignedOverflowDefined()) - value = Builder.CreateGEP(value, amt, "incdec.funcptr"); + value = Builder.CreateGEP(CGF.Int8Ty, value, amt, "incdec.funcptr"); else - value = CGF.EmitCheckedInBoundsGEP(value, amt, /*SignedIndices=*/false, - isSubtraction, E->getExprLoc(), - "incdec.funcptr"); + value = CGF.EmitCheckedInBoundsGEP( + CGF.Int8Ty, value, amt, /*SignedIndices=*/false, isSubtraction, + E->getExprLoc(), "incdec.funcptr"); value = Builder.CreateBitCast(value, input->getType()); // For everything else, we can just do a simple increment. } else { llvm::Value *amt = Builder.getInt32(amount); + llvm::Type *eltTy = CGF.ConvertTypeForMem(type); if (CGF.getLangOpts().isSignedOverflowDefined()) - value = Builder.CreateGEP(value, amt, "incdec.ptr"); + value = Builder.CreateGEP(eltTy, value, amt, "incdec.ptr"); else - value = CGF.EmitCheckedInBoundsGEP(value, amt, /*SignedIndices=*/false, - isSubtraction, E->getExprLoc(), - "incdec.ptr"); + value = CGF.EmitCheckedInBoundsGEP( + eltTy, value, amt, /*SignedIndices=*/false, isSubtraction, + E->getExprLoc(), "incdec.ptr"); } // Vector increment/decrement. @@ -2688,9 +2690,9 @@ llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity()); if (CGF.getLangOpts().isSignedOverflowDefined()) - value = Builder.CreateGEP(value, sizeValue, "incdec.objptr"); + value = Builder.CreateGEP(CGF.Int8Ty, value, sizeValue, "incdec.objptr"); else - value = CGF.EmitCheckedInBoundsGEP(value, sizeValue, + value = CGF.EmitCheckedInBoundsGEP(CGF.Int8Ty, value, sizeValue, /*SignedIndices=*/false, isSubtraction, E->getExprLoc(), "incdec.objptr"); value = Builder.CreateBitCast(value, input->getType()); @@ -3390,7 +3392,7 @@ index = CGF.Builder.CreateMul(index, objectSize); Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy); - result = CGF.Builder.CreateGEP(result, index, "add.ptr"); + result = CGF.Builder.CreateGEP(CGF.Int8Ty, result, index, "add.ptr"); return CGF.Builder.CreateBitCast(result, pointer->getType()); } @@ -3399,6 +3401,7 @@ = CGF.getContext().getAsVariableArrayType(elementType)) { // The element count here is the total number of non-VLA elements. llvm::Value *numElements = CGF.getVLASize(vla).NumElts; + llvm::Type *elementTy = CGF.ConvertTypeForMem(vla->getElementType()); // Effectively, the multiply by the VLA size is part of the GEP. // GEP indexes are signed, and scaling an index isn't permitted to @@ -3406,12 +3409,12 @@ // multiply. We suppress this if overflow is not undefined behavior. if (CGF.getLangOpts().isSignedOverflowDefined()) { index = CGF.Builder.CreateMul(index, numElements, "vla.index"); - pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr"); + pointer = CGF.Builder.CreateGEP(elementTy, pointer, index, "add.ptr"); } else { index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index"); - pointer = - CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction, - op.E->getExprLoc(), "add.ptr"); + pointer = CGF.EmitCheckedInBoundsGEP(elementTy, pointer, index, isSigned, + isSubtraction, op.E->getExprLoc(), + "add.ptr"); } return pointer; } @@ -3421,15 +3424,17 @@ // future proof. if (elementType->isVoidType() || elementType->isFunctionType()) { Value *result = CGF.EmitCastToVoidPtr(pointer); - result = CGF.Builder.CreateGEP(result, index, "add.ptr"); + result = CGF.Builder.CreateGEP(CGF.Int8Ty, result, index, "add.ptr"); return CGF.Builder.CreateBitCast(result, pointer->getType()); } + llvm::Type *gepTy = CGF.ConvertTypeForMem(elementType); if (CGF.getLangOpts().isSignedOverflowDefined()) - return CGF.Builder.CreateGEP(pointer, index, "add.ptr"); + return CGF.Builder.CreateGEP(gepTy, pointer, index, "add.ptr"); - return CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction, - op.E->getExprLoc(), "add.ptr"); + return CGF.EmitCheckedInBoundsGEP(gepTy, pointer, index, isSigned, + isSubtraction, op.E->getExprLoc(), + "add.ptr"); } // Construct an fmuladd intrinsic to represent a fused mul-add of MulOp and @@ -4904,11 +4909,10 @@ return {TotalOffset, OffsetOverflows}; } -Value * -CodeGenFunction::EmitCheckedInBoundsGEP(Value *Ptr, ArrayRef IdxList, - bool SignedIndices, bool IsSubtraction, - SourceLocation Loc, const Twine &Name) { - Value *GEPVal = Builder.CreateInBoundsGEP(Ptr, IdxList, Name); +Value *CodeGenFunction::EmitCheckedInBoundsGEP( + llvm::Type *Ty, Value *Ptr, ArrayRef IdxList, bool SignedIndices, + bool IsSubtraction, SourceLocation Loc, const Twine &Name) { + Value *GEPVal = Builder.CreateInBoundsGEP(Ty, Ptr, IdxList, Name); // If the pointer overflow sanitizer isn't enabled, do nothing. if (!SanOpts.has(SanitizerKind::PointerOverflow)) Index: clang/lib/CodeGen/CGNonTrivialStruct.cpp =================================================================== --- clang/lib/CodeGen/CGNonTrivialStruct.cpp +++ clang/lib/CodeGen/CGNonTrivialStruct.cpp @@ -367,8 +367,8 @@ llvm::Value *SizeInBytes = CGF.Builder.CreateNUWMul(BaseEltSizeVal, NumElts); Address BC = CGF.Builder.CreateBitCast(DstAddr, CGF.CGM.Int8PtrTy); - llvm::Value *DstArrayEnd = - CGF.Builder.CreateInBoundsGEP(BC.getPointer(), SizeInBytes); + llvm::Value *DstArrayEnd = CGF.Builder.CreateInBoundsGEP( + BC.getElementType(), BC.getPointer(), SizeInBytes); DstArrayEnd = CGF.Builder.CreateBitCast(DstArrayEnd, CGF.CGM.Int8PtrPtrTy, "dstarray.end"); llvm::BasicBlock *PreheaderBB = CGF.Builder.GetInsertBlock(); Index: clang/lib/CodeGen/CGObjC.cpp =================================================================== --- clang/lib/CodeGen/CGObjC.cpp +++ clang/lib/CodeGen/CGObjC.cpp @@ -1832,7 +1832,7 @@ // Fetch the value at the current index from the buffer. llvm::Value *CurrentItemPtr = - Builder.CreateGEP(EnumStateItems, index, "currentitem.ptr"); + Builder.CreateGEP(Int8PtrTy, EnumStateItems, index, "currentitem.ptr"); llvm::Value *CurrentItem = Builder.CreateAlignedLoad(CurrentItemPtr, getPointerAlign()); Index: clang/lib/CodeGen/CGObjCGNU.cpp =================================================================== --- clang/lib/CodeGen/CGObjCGNU.cpp +++ clang/lib/CodeGen/CGObjCGNU.cpp @@ -952,7 +952,7 @@ /// Generate the name of a symbol for a reference to a class. Accesses to /// classes should be indirected via this. - typedef std::pair> EarlyInitPair; + typedef std::pair> EarlyInitPair; std::vector EarlyInitList; std::string SymbolForClassRef(StringRef Name, bool isWeak) { @@ -1114,7 +1114,7 @@ ObjCStrGV->setVisibility(llvm::GlobalValue::HiddenVisibility); } if (CGM.getTriple().isOSBinFormatCOFF()) { - std::pair v{ObjCStrGV, 0}; + std::pair v{ObjCStrGV, 0}; EarlyInitList.emplace_back(Sym, v); } llvm::Constant *ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStrGV, IdTy); @@ -1652,12 +1652,14 @@ &CGM.getModule()); llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry", Init)); + llvm_unreachable("Wibble"); for (const auto &lateInit : EarlyInitList) { auto *global = TheModule.getGlobalVariable(lateInit.first); if (global) { b.CreateAlignedStore( global, - b.CreateStructGEP(lateInit.second.first, lateInit.second.second), + b.CreateStructGEP(lateInit.second.first->getValueType(), + lateInit.second.first, lateInit.second.second), CGM.getPointerAlign().getAsAlign()); } } @@ -1952,7 +1954,7 @@ } if (SuperClass) { - std::pair v{classStruct, 1}; + std::pair v{classStruct, 1}; EarlyInitList.emplace_back(std::string(SuperClass->getName()), std::move(v)); } Index: clang/lib/CodeGen/CGObjCRuntime.cpp =================================================================== --- clang/lib/CodeGen/CGObjCRuntime.cpp +++ clang/lib/CodeGen/CGObjCRuntime.cpp @@ -64,7 +64,7 @@ Ivar->getUsageType(ObjectPtrTy).withCVRQualifiers(CVRQualifiers); llvm::Type *LTy = CGF.CGM.getTypes().ConvertTypeForMem(IvarTy); llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue, CGF.Int8PtrTy); - V = CGF.Builder.CreateInBoundsGEP(V, Offset, "add.ptr"); + V = CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, V, Offset, "add.ptr"); if (!Ivar->isBitField()) { V = CGF.Builder.CreateBitCast(V, llvm::PointerType::getUnqual(LTy)); Index: clang/lib/CodeGen/CGOpenMPRuntime.cpp =================================================================== --- clang/lib/CodeGen/CGOpenMPRuntime.cpp +++ clang/lib/CodeGen/CGOpenMPRuntime.cpp @@ -684,11 +684,14 @@ CGF.Builder.CreateElementBitCast(SrcAddr, DestAddr.getElementType()); llvm::Value *SrcBegin = nullptr; + llvm::Type *SrcType = SrcAddr.getElementType(); if (DRD) SrcBegin = SrcAddr.getPointer(); llvm::Value *DestBegin = DestAddr.getPointer(); + llvm::Type *DestType = DestAddr.getElementType(); // Cast from pointer to array type to pointer to single element. - llvm::Value *DestEnd = CGF.Builder.CreateGEP(DestBegin, NumElements); + llvm::Value *DestEnd = + CGF.Builder.CreateGEP(DestAddr.getElementType(), DestBegin, NumElements); // The basic structure here is a while-do loop. llvm::BasicBlock *BodyBB = CGF.createBasicBlock("omp.arrayinit.body"); llvm::BasicBlock *DoneBB = CGF.createBasicBlock("omp.arrayinit.done"); @@ -733,13 +736,13 @@ if (DRD) { // Shift the address forward by one element. llvm::Value *SrcElementNext = CGF.Builder.CreateConstGEP1_32( - SrcElementPHI, /*Idx0=*/1, "omp.arraycpy.dest.element"); + SrcType, SrcElementPHI, /*Idx0=*/1, "omp.arraycpy.dest.element"); SrcElementPHI->addIncoming(SrcElementNext, CGF.Builder.GetInsertBlock()); } // Shift the address forward by one element. llvm::Value *DestElementNext = CGF.Builder.CreateConstGEP1_32( - DestElementPHI, /*Idx0=*/1, "omp.arraycpy.dest.element"); + DestType, DestElementPHI, /*Idx0=*/1, "omp.arraycpy.dest.element"); // Check whether we've reached the end. llvm::Value *Done = CGF.Builder.CreateICmpEQ(DestElementNext, DestEnd, "omp.arraycpy.done"); @@ -1006,7 +1009,9 @@ CGF.Builder.CreatePointerBitCastOrAddrSpaceCast( PrivateAddr.getPointer(), SharedAddresses[N].first.getAddress(CGF).getType()); - llvm::Value *Ptr = CGF.Builder.CreateGEP(PrivatePointer, Adjustment); + llvm::Value *Ptr = CGF.Builder.CreateGEP( + SharedAddresses[N].first.getAddress(CGF).getElementType(), + PrivatePointer, Adjustment); return castToBase(CGF, OrigVD->getType(), SharedAddresses[N].first.getType(), OriginalBaseLValue.getAddress(CGF).getType(), @@ -4153,8 +4158,9 @@ dyn_cast(E->IgnoreParenImpCasts())) { LValue UpAddrLVal = CGF.EmitOMPArraySectionExpr(ASE, /*IsLowerBound=*/false); - llvm::Value *UpAddr = - CGF.Builder.CreateConstGEP1_32(UpAddrLVal.getPointer(CGF), /*Idx0=*/1); + llvm::Value *UpAddr = CGF.Builder.CreateConstGEP1_32( + UpAddrLVal.getAddress(CGF).getElementType(), UpAddrLVal.getPointer(CGF), + /*Idx0=*/1); llvm::Value *LowIntPtr = CGF.Builder.CreatePtrToInt(Addr, CGF.SizeTy); llvm::Value *UpIntPtr = CGF.Builder.CreatePtrToInt(UpAddr, CGF.SizeTy); SizeVal = CGF.Builder.CreateNUWSub(UpIntPtr, LowIntPtr); @@ -4462,7 +4468,8 @@ std::tie(Addr, Size) = getPointerAndSize(CGF, E); llvm::Value *Idx = CGF.EmitLoadOfScalar(PosLVal, E->getExprLoc()); LValue Base = CGF.MakeAddrLValue( - Address(CGF.Builder.CreateGEP(AffinitiesArray.getPointer(), Idx), + Address(CGF.Builder.CreateGEP(AffinitiesArray.getElementType(), + AffinitiesArray.getPointer(), Idx), AffinitiesArray.getAlignment()), KmpTaskAffinityInfoTy); // affs[i].base_addr = &; @@ -4629,7 +4636,7 @@ Base = CGF.MakeAddrLValue(Addr, KmpDependInfoTy, Base.getBaseInfo(), Base.getTBAAInfo()); llvm::Value *DepObjAddr = CGF.Builder.CreateGEP( - Addr.getPointer(), + Addr.getElementType(), Addr.getPointer(), llvm::ConstantInt::get(CGF.IntPtrTy, -1, /*isSigned=*/true)); LValue NumDepsBase = CGF.MakeAddrLValue( Address(DepObjAddr, Addr.getAlignment()), KmpDependInfoTy, @@ -4669,7 +4676,8 @@ LValue &PosLVal = *Pos.get(); llvm::Value *Idx = CGF.EmitLoadOfScalar(PosLVal, E->getExprLoc()); Base = CGF.MakeAddrLValue( - Address(CGF.Builder.CreateGEP(DependenciesArray.getPointer(), Idx), + Address(CGF.Builder.CreateGEP(DependenciesArray.getElementType(), + DependenciesArray.getPointer(), Idx), DependenciesArray.getAlignment()), KmpDependInfoTy); } @@ -4729,7 +4737,7 @@ Base = CGF.MakeAddrLValue(Addr, KmpDependInfoTy, Base.getBaseInfo(), Base.getTBAAInfo()); llvm::Value *DepObjAddr = CGF.Builder.CreateGEP( - Addr.getPointer(), + Addr.getElementType(), Addr.getPointer(), llvm::ConstantInt::get(CGF.IntPtrTy, -1, /*isSigned=*/true)); LValue NumDepsBase = CGF.MakeAddrLValue( Address(DepObjAddr, Addr.getAlignment()), KmpDependInfoTy, @@ -4790,7 +4798,7 @@ // Get number of elements in a single depobj. llvm::Value *DepObjAddr = CGF.Builder.CreateGEP( - Addr.getPointer(), + Addr.getElementType(), Addr.getPointer(), llvm::ConstantInt::get(CGF.IntPtrTy, -1, /*isSigned=*/true)); LValue NumDepsBase = CGF.MakeAddrLValue( Address(DepObjAddr, Addr.getAlignment()), KmpDependInfoTy, @@ -4807,7 +4815,8 @@ CGF.Builder.CreateIntCast(NumDeps, CGF.SizeTy, /*isSigned=*/false)); llvm::Value *Pos = CGF.EmitLoadOfScalar(PosLVal, E->getExprLoc()); Address DepAddr = - Address(CGF.Builder.CreateGEP(DependenciesArray.getPointer(), Pos), + Address(CGF.Builder.CreateGEP(DependenciesArray.getElementType(), + DependenciesArray.getPointer(), Pos), DependenciesArray.getAlignment()); CGF.Builder.CreateMemCpy(DepAddr, Base.getAddress(CGF), Size); @@ -5035,7 +5044,7 @@ Address Addr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast( Base.getAddress(CGF), CGF.ConvertTypeForMem(KmpDependInfoPtrTy)); llvm::Value *DepObjAddr = CGF.Builder.CreateGEP( - Addr.getPointer(), + Addr.getElementType(), Addr.getPointer(), llvm::ConstantInt::get(CGF.IntPtrTy, -1, /*isSigned=*/true)); DepObjAddr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(DepObjAddr, CGF.VoidPtrTy); @@ -5065,7 +5074,8 @@ Address Begin = Base.getAddress(CGF); // Cast from pointer to array type to pointer to single element. - llvm::Value *End = CGF.Builder.CreateGEP(Begin.getPointer(), NumDeps); + llvm::Value *End = CGF.Builder.CreateGEP(Begin.getElementType(), + Begin.getPointer(), NumDeps); // The basic structure here is a while-do loop. llvm::BasicBlock *BodyBB = CGF.createBasicBlock("omp.body"); llvm::BasicBlock *DoneBB = CGF.createBasicBlock("omp.done"); @@ -5328,7 +5338,8 @@ llvm::Value *RHSBegin = RHSAddr.getPointer(); llvm::Value *LHSBegin = LHSAddr.getPointer(); // Cast from pointer to array type to pointer to single element. - llvm::Value *LHSEnd = CGF.Builder.CreateGEP(LHSBegin, NumElements); + llvm::Value *LHSEnd = + CGF.Builder.CreateGEP(LHSAddr.getElementType(), LHSBegin, NumElements); // The basic structure here is a while-do loop. llvm::BasicBlock *BodyBB = CGF.createBasicBlock("omp.arraycpy.body"); llvm::BasicBlock *DoneBB = CGF.createBasicBlock("omp.arraycpy.done"); @@ -5365,10 +5376,12 @@ Scope.ForceCleanup(); // Shift the address forward by one element. - llvm::Value *LHSElementNext = CGF.Builder.CreateConstGEP1_32( - LHSElementPHI, /*Idx0=*/1, "omp.arraycpy.dest.element"); - llvm::Value *RHSElementNext = CGF.Builder.CreateConstGEP1_32( - RHSElementPHI, /*Idx0=*/1, "omp.arraycpy.src.element"); + llvm::Value *LHSElementNext = + CGF.Builder.CreateConstGEP1_32(LHSAddr.getElementType(), LHSElementPHI, + /*Idx0=*/1, "omp.arraycpy.dest.element"); + llvm::Value *RHSElementNext = + CGF.Builder.CreateConstGEP1_32(RHSAddr.getElementType(), RHSElementPHI, + /*Idx0=*/1, "omp.arraycpy.src.element"); // Check whether we've reached the end. llvm::Value *Done = CGF.Builder.CreateICmpEQ(LHSElementNext, LHSEnd, "omp.arraycpy.done"); @@ -6076,7 +6089,7 @@ llvm::Value *Idxs[] = {llvm::ConstantInt::get(CGM.SizeTy, /*V=*/0), llvm::ConstantInt::get(CGM.SizeTy, Cnt)}; llvm::Value *GEP = CGF.EmitCheckedInBoundsGEP( - TaskRedInput.getPointer(), Idxs, + TaskRedInput.getElementType(), TaskRedInput.getPointer(), Idxs, /*SignedIndices=*/false, /*IsSubtraction=*/false, Loc, ".rd_input.gep."); LValue ElemLVal = CGF.MakeNaturalAlignAddrLValue(GEP, RDType); @@ -8014,7 +8027,8 @@ CombinedInfo.Mappers.push_back(nullptr); // Size is (addr of {highest+1} element) - (addr of lowest element) llvm::Value *HB = PartialStruct.HighestElem.second.getPointer(); - llvm::Value *HAddr = CGF.Builder.CreateConstGEP1_32(HB, /*Idx0=*/1); + llvm::Type *HBType = PartialStruct.HighestElem.second.getElementType(); + llvm::Value *HAddr = CGF.Builder.CreateConstGEP1_32(HBType, HB, /*Idx0=*/1); llvm::Value *CLAddr = CGF.Builder.CreatePointerCast(LB, CGF.VoidPtrTy); llvm::Value *CHAddr = CGF.Builder.CreatePointerCast(HAddr, CGF.VoidPtrTy); llvm::Value *Diff = CGF.Builder.CreatePtrDiff(CHAddr, CLAddr); @@ -9106,7 +9120,8 @@ llvm::Value *PtrBegin = MapperCGF.Builder.CreateBitCast( MapperCGF.GetAddrOfLocalVar(&BeginArg).getPointer(), CGM.getTypes().ConvertTypeForMem(C.getPointerType(PtrTy))); - llvm::Value *PtrEnd = MapperCGF.Builder.CreateGEP(PtrBegin, Size); + llvm::Type *EltTy = CGM.getTypes().ConvertTypeForMem(PtrTy); + llvm::Value *PtrEnd = MapperCGF.Builder.CreateGEP(EltTy, PtrBegin, Size); llvm::Value *MapType = MapperCGF.EmitLoadOfScalar( MapperCGF.GetAddrOfLocalVar(&TypeArg), /*Volatile=*/false, C.getPointerType(Int64Ty), Loc); @@ -9290,7 +9305,7 @@ // Update the pointer to point to the next element that needs to be mapped, // and check whether we have mapped all elements. llvm::Value *PtrNext = MapperCGF.Builder.CreateConstGEP1_32( - PtrPHI, /*Idx0=*/1, "omp.arraymap.next"); + EltTy, PtrPHI, /*Idx0=*/1, "omp.arraymap.next"); PtrPHI->addIncoming(PtrNext, LastBB); llvm::Value *IsDone = MapperCGF.Builder.CreateICmpEQ(PtrNext, PtrEnd, "omp.arraymap.isdone"); Index: clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp =================================================================== --- clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp +++ clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp @@ -2330,6 +2330,7 @@ VarTy = Rec.second.FD->getType(); } else { llvm::Value *Ptr = CGF.Builder.CreateInBoundsGEP( + VarAddr.getAddress(CGF).getElementType(), VarAddr.getAddress(CGF).getPointer(), {Bld.getInt32(0), getNVPTXLaneID(CGF)}); VarTy = @@ -3314,14 +3315,16 @@ Address ElemPtr = Address(ElemPtrPtr, Align); ElemPtr = Bld.CreateElementBitCast(ElemPtr, CopyType); if (NumIters > 1) { - ElemPtr = Address(Bld.CreateGEP(ElemPtr.getPointer(), Cnt), - ElemPtr.getAlignment()); + ElemPtr = Address( + Bld.CreateGEP(ElemPtr.getElementType(), ElemPtr.getPointer(), Cnt), + ElemPtr.getAlignment()); } // Get pointer to location in transfer medium. // MediumPtr = &medium[warp_id] llvm::Value *MediumPtrVal = Bld.CreateInBoundsGEP( - TransferMedium, {llvm::Constant::getNullValue(CGM.Int64Ty), WarpID}); + TransferMedium->getValueType(), TransferMedium, + {llvm::Constant::getNullValue(CGM.Int64Ty), WarpID}); Address MediumPtr(MediumPtrVal, Align); // Casting to actual data type. // MediumPtr = (CopyType*)MediumPtrAddr; @@ -3366,7 +3369,7 @@ // SrcMediumPtr = &medium[tid] llvm::Value *SrcMediumPtrVal = Bld.CreateInBoundsGEP( - TransferMedium, + TransferMedium->getValueType(), TransferMedium, {llvm::Constant::getNullValue(CGM.Int64Ty), ThreadID}); Address SrcMediumPtr(SrcMediumPtrVal, Align); // SrcMediumVal = *SrcMediumPtr; @@ -3379,7 +3382,8 @@ Address TargetElemPtr = Address(TargetElemPtrVal, Align); TargetElemPtr = Bld.CreateElementBitCast(TargetElemPtr, CopyType); if (NumIters > 1) { - TargetElemPtr = Address(Bld.CreateGEP(TargetElemPtr.getPointer(), Cnt), + TargetElemPtr = Address(Bld.CreateGEP(TargetElemPtr.getElementType(), + TargetElemPtr.getPointer(), Cnt), TargetElemPtr.getAlignment()); } @@ -3708,7 +3712,8 @@ LValue GlobLVal = CGF.EmitLValueForField( CGF.MakeNaturalAlignAddrLValue(BufferArrPtr, StaticTy), FD); llvm::Value *BufferPtr = - Bld.CreateInBoundsGEP(GlobLVal.getPointer(CGF), Idxs); + Bld.CreateInBoundsGEP(GlobLVal.getAddress(CGF).getElementType(), + GlobLVal.getPointer(CGF), Idxs); GlobLVal.setAddress(Address(BufferPtr, GlobLVal.getAlignment())); switch (CGF.getEvaluationKind(Private->getType())) { case TEK_Scalar: { @@ -3806,7 +3811,8 @@ LValue GlobLVal = CGF.EmitLValueForField( CGF.MakeNaturalAlignAddrLValue(BufferArrPtr, StaticTy), FD); llvm::Value *BufferPtr = - Bld.CreateInBoundsGEP(GlobLVal.getPointer(CGF), Idxs); + Bld.CreateInBoundsGEP(GlobLVal.getAddress(CGF).getElementType(), + GlobLVal.getPointer(CGF), Idxs); llvm::Value *Ptr = CGF.EmitCastToVoidPtr(BufferPtr); CGF.EmitStoreOfScalar(Ptr, Elem, /*Volatile=*/false, C.VoidPtrTy); if ((*IPriv)->getType()->isVariablyModifiedType()) { @@ -3911,7 +3917,8 @@ LValue GlobLVal = CGF.EmitLValueForField( CGF.MakeNaturalAlignAddrLValue(BufferArrPtr, StaticTy), FD); llvm::Value *BufferPtr = - Bld.CreateInBoundsGEP(GlobLVal.getPointer(CGF), Idxs); + Bld.CreateInBoundsGEP(GlobLVal.getAddress(CGF).getElementType(), + GlobLVal.getPointer(CGF), Idxs); GlobLVal.setAddress(Address(BufferPtr, GlobLVal.getAlignment())); switch (CGF.getEvaluationKind(Private->getType())) { case TEK_Scalar: { @@ -4008,7 +4015,8 @@ LValue GlobLVal = CGF.EmitLValueForField( CGF.MakeNaturalAlignAddrLValue(BufferArrPtr, StaticTy), FD); llvm::Value *BufferPtr = - Bld.CreateInBoundsGEP(GlobLVal.getPointer(CGF), Idxs); + Bld.CreateInBoundsGEP(GlobLVal.getAddress(CGF).getElementType(), + GlobLVal.getPointer(CGF), Idxs); llvm::Value *Ptr = CGF.EmitCastToVoidPtr(BufferPtr); CGF.EmitStoreOfScalar(Ptr, Elem, /*Volatile=*/false, C.VoidPtrTy); if ((*IPriv)->getType()->isVariablyModifiedType()) { Index: clang/lib/CodeGen/CGStmtOpenMP.cpp =================================================================== --- clang/lib/CodeGen/CGStmtOpenMP.cpp +++ clang/lib/CodeGen/CGStmtOpenMP.cpp @@ -674,7 +674,8 @@ llvm::Value *SrcBegin = SrcAddr.getPointer(); llvm::Value *DestBegin = DestAddr.getPointer(); // Cast from pointer to array type to pointer to single element. - llvm::Value *DestEnd = Builder.CreateGEP(DestBegin, NumElements); + llvm::Value *DestEnd = + Builder.CreateGEP(DestAddr.getElementType(), DestBegin, NumElements); // The basic structure here is a while-do loop. llvm::BasicBlock *BodyBB = createBasicBlock("omp.arraycpy.body"); llvm::BasicBlock *DoneBB = createBasicBlock("omp.arraycpy.done"); @@ -706,10 +707,12 @@ CopyGen(DestElementCurrent, SrcElementCurrent); // Shift the address forward by one element. - llvm::Value *DestElementNext = Builder.CreateConstGEP1_32( - DestElementPHI, /*Idx0=*/1, "omp.arraycpy.dest.element"); - llvm::Value *SrcElementNext = Builder.CreateConstGEP1_32( - SrcElementPHI, /*Idx0=*/1, "omp.arraycpy.src.element"); + llvm::Value *DestElementNext = + Builder.CreateConstGEP1_32(DestAddr.getElementType(), DestElementPHI, + /*Idx0=*/1, "omp.arraycpy.dest.element"); + llvm::Value *SrcElementNext = + Builder.CreateConstGEP1_32(SrcAddr.getElementType(), SrcElementPHI, + /*Idx0=*/1, "omp.arraycpy.src.element"); // Check whether we've reached the end. llvm::Value *Done = Builder.CreateICmpEQ(DestElementNext, DestEnd, "omp.arraycpy.done"); Index: clang/lib/CodeGen/CGValue.h =================================================================== --- clang/lib/CodeGen/CGValue.h +++ clang/lib/CodeGen/CGValue.h @@ -470,13 +470,11 @@ /// An aggregate value slot. class AggValueSlot { /// The address. - llvm::Value *Addr; + Address Addr = Address::invalid(); // Qualifiers Qualifiers Quals; - unsigned Alignment; - /// DestructedFlag - This is set to true if some external code is /// responsible for setting up a destructor for the slot. Otherwise /// the code which constructs it should push the appropriate cleanup. @@ -555,11 +553,9 @@ IsSanitizerChecked_t isChecked = IsNotSanitizerChecked) { AggValueSlot AV; if (addr.isValid()) { - AV.Addr = addr.getPointer(); - AV.Alignment = addr.getAlignment().getQuantity(); + AV.Addr = addr; } else { - AV.Addr = nullptr; - AV.Alignment = 0; + AV.Addr = Address::invalid(); } AV.Quals = quals; AV.DestructedFlag = isDestructed; @@ -609,19 +605,19 @@ } llvm::Value *getPointer() const { - return Addr; + return Addr.isValid() ? Addr.getPointer() : nullptr; } Address getAddress() const { - return Address(Addr, getAlignment()); + return Addr; } bool isIgnored() const { - return Addr == nullptr; + return !Addr.isValid(); } CharUnits getAlignment() const { - return CharUnits::fromQuantity(Alignment); + return Addr.getAlignment(); } IsAliased_t isPotentiallyAliased() const { Index: clang/lib/CodeGen/CodeGenFunction.h =================================================================== --- clang/lib/CodeGen/CodeGenFunction.h +++ clang/lib/CodeGen/CodeGenFunction.h @@ -1925,7 +1925,7 @@ const VarDecl *VD); void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, QualType elementType, CharUnits elementAlign, - Destroyer *destroyer, + llvm::Type *elementMemType, Destroyer *destroyer, bool checkZeroLength, bool useEHCleanup); Destroyer *getDestroyer(QualType::DestructionKind destructionKind); @@ -4375,7 +4375,8 @@ /// \p SignedIndices indicates whether any of the GEP indices are signed. /// \p IsSubtraction indicates whether the expression used to form the GEP /// is a subtraction. - llvm::Value *EmitCheckedInBoundsGEP(llvm::Value *Ptr, + llvm::Value *EmitCheckedInBoundsGEP(llvm::Type *Ty, + llvm::Value *Ptr, ArrayRef IdxList, bool SignedIndices, bool IsSubtraction, Index: clang/lib/CodeGen/CodeGenFunction.cpp =================================================================== --- clang/lib/CodeGen/CodeGenFunction.cpp +++ clang/lib/CodeGen/CodeGenFunction.cpp @@ -1687,8 +1687,8 @@ Address begin = Builder.CreateElementBitCast(dest, CGF.Int8Ty, "vla.begin"); - llvm::Value *end = - Builder.CreateInBoundsGEP(begin.getPointer(), sizeInChars, "vla.end"); + llvm::Value *end = Builder.CreateInBoundsGEP( + begin.getElementType(), begin.getPointer(), sizeInChars, "vla.end"); llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock(); llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop"); @@ -1895,8 +1895,9 @@ addr = Builder.CreateElementBitCast(addr, baseType, "array.begin"); } else { // Create the actual GEP. - addr = Address(Builder.CreateInBoundsGEP(addr.getPointer(), - gepIndices, "array.begin"), + addr = Address(Builder.CreateInBoundsGEP(addr.getElementType(), + addr.getPointer(), gepIndices, + "array.begin"), addr.getAlignment()); } Index: clang/lib/CodeGen/ItaniumCXXABI.cpp =================================================================== --- clang/lib/CodeGen/ItaniumCXXABI.cpp +++ clang/lib/CodeGen/ItaniumCXXABI.cpp @@ -647,7 +647,7 @@ // for consistency. llvm::Value *This = ThisAddr.getPointer(); llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy()); - Ptr = Builder.CreateInBoundsGEP(Ptr, Adj); + Ptr = Builder.CreateInBoundsGEP(CGF.Int8Ty, Ptr, Adj); This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted"); ThisPtrForCall = This; @@ -670,12 +670,12 @@ CGF.EmitBlock(FnVirtual); // Cast the adjusted this to a pointer to vtable pointer and load. - llvm::Type *VTableTy = Builder.getInt8PtrTy(); + llvm::Type *VTableTy = Builder.getInt8Ty(); CharUnits VTablePtrAlign = CGF.CGM.getDynamicOffsetAlignment(ThisAddr.getAlignment(), RD, CGF.getPointerAlign()); - llvm::Value *VTable = - CGF.GetVTablePtr(Address(This, VTablePtrAlign), VTableTy, RD); + llvm::Value *VTable = CGF.GetVTablePtr(Address(This, VTablePtrAlign), + VTableTy->getPointerTo(), RD); // Apply the offset. // On ARM64, to reserve extra space in virtual member function pointers, @@ -716,7 +716,7 @@ } if (ShouldEmitVFEInfo) { - llvm::Value *VFPAddr = Builder.CreateGEP(VTable, VTableOffset); + llvm::Value *VFPAddr = Builder.CreateGEP(VTableTy, VTable, VTableOffset); // If doing VFE, load from the vtable with a type.checked.load intrinsic // call. Note that we use the GEP to calculate the address to load from @@ -734,7 +734,8 @@ // When not doing VFE, emit a normal load, as it allows more // optimisations than type.checked.load. if (ShouldEmitCFICheck || ShouldEmitWPDInfo) { - llvm::Value *VFPAddr = Builder.CreateGEP(VTable, VTableOffset); + llvm::Value *VFPAddr = + Builder.CreateGEP(VTableTy, VTable, VTableOffset); CheckResult = Builder.CreateCall( CGM.getIntrinsic(llvm::Intrinsic::type_test), {Builder.CreateBitCast(VFPAddr, CGF.Int8PtrTy), TypeId}); @@ -747,7 +748,8 @@ {VTable, VTableOffset}); VirtualFn = CGF.Builder.CreateBitCast(VirtualFn, FTy->getPointerTo()); } else { - llvm::Value *VFPAddr = CGF.Builder.CreateGEP(VTable, VTableOffset); + llvm::Value *VFPAddr = + CGF.Builder.CreateGEP(VTableTy, VTable, VTableOffset); VFPAddr = CGF.Builder.CreateBitCast( VFPAddr, FTy->getPointerTo()->getPointerTo()); VirtualFn = CGF.Builder.CreateAlignedLoad( @@ -854,8 +856,8 @@ Base = Builder.CreateElementBitCast(Base, CGF.Int8Ty); // Apply the offset, which we assume is non-null. - llvm::Value *Addr = - Builder.CreateInBoundsGEP(Base.getPointer(), MemPtr, "memptr.offset"); + llvm::Value *Addr = Builder.CreateInBoundsGEP( + Base.getElementType(), Base.getPointer(), MemPtr, "memptr.offset"); // Cast the address to the appropriate pointer type, adopting the // address space of the base pointer. @@ -1249,14 +1251,15 @@ // Track back to entry -2 and pull out the offset there. llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64( - VTable, -2, "complete-offset.ptr"); + CGF.IntPtrTy, VTable, -2, "complete-offset.ptr"); llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign()); // Apply the offset. llvm::Value *CompletePtr = CGF.Builder.CreateBitCast(Ptr.getPointer(), CGF.Int8PtrTy); - CompletePtr = CGF.Builder.CreateInBoundsGEP(CompletePtr, Offset); + CompletePtr = + CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, CompletePtr, Offset); // If we're supposed to call the global delete, make sure we do so // even if the destructor throws. @@ -1461,7 +1464,8 @@ Value = CGF.Builder.CreateBitCast(Value, StdTypeInfoPtrTy->getPointerTo()); } else { // Load the type info. - Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL); + Value = + CGF.Builder.CreateConstInBoundsGEP1_64(StdTypeInfoPtrTy, Value, -1ULL); } return CGF.Builder.CreateAlignedLoad(Value, CGF.getPointerAlign()); } @@ -1529,7 +1533,7 @@ // Get the offset-to-top from the vtable. OffsetToTop = - CGF.Builder.CreateConstInBoundsGEP1_32(/*Type=*/nullptr, VTable, -2U); + CGF.Builder.CreateConstInBoundsGEP1_32(CGM.Int32Ty, VTable, -2U); OffsetToTop = CGF.Builder.CreateAlignedLoad( OffsetToTop, CharUnits::fromQuantity(4), "offset.to.top"); } else { @@ -1541,14 +1545,15 @@ CGF.GetVTablePtr(ThisAddr, PtrDiffLTy->getPointerTo(), ClassDecl); // Get the offset-to-top from the vtable. - OffsetToTop = CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL); + OffsetToTop = + CGF.Builder.CreateConstInBoundsGEP1_64(PtrDiffLTy, VTable, -2ULL); OffsetToTop = CGF.Builder.CreateAlignedLoad( OffsetToTop, CGF.getPointerAlign(), "offset.to.top"); } // Finally, add the offset to the pointer. llvm::Value *Value = ThisAddr.getPointer(); Value = CGF.EmitCastToVoidPtr(Value); - Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop); + Value = CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, Value, OffsetToTop); return CGF.Builder.CreateBitCast(Value, DestLTy); } @@ -1569,9 +1574,9 @@ CharUnits VBaseOffsetOffset = CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(ClassDecl, BaseClassDecl); - llvm::Value *VBaseOffsetPtr = - CGF.Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset.getQuantity(), - "vbase.offset.ptr"); + llvm::Value *VBaseOffsetPtr = CGF.Builder.CreateConstGEP1_64( + CGM.Int8Ty, VTablePtr, VBaseOffsetOffset.getQuantity(), + "vbase.offset.ptr"); llvm::Value *VBaseOffset; if (CGM.getItaniumVTableContext().isRelativeLayout()) { @@ -1827,7 +1832,8 @@ /// Load the VTT. llvm::Value *VTT = CGF.LoadCXXVTT(); if (VirtualPointerIndex) - VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex); + VTT = CGF.Builder.CreateConstInBoundsGEP1_64(CGF.Int8PtrTy, VTT, + VirtualPointerIndex); // And load the address point from the VTT. return CGF.Builder.CreateAlignedLoad(VTT, CGF.getPointerAlign()); @@ -1902,8 +1908,8 @@ } else { VTable = CGF.Builder.CreateBitCast(VTable, Ty->getPointerTo()->getPointerTo()); - llvm::Value *VTableSlotPtr = - CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn"); + llvm::Value *VTableSlotPtr = CGF.Builder.CreateConstInBoundsGEP1_64( + Ty->getPointerTo(), VTable, VTableIndex, "vfn"); VFuncLoad = CGF.Builder.CreateAlignedLoad(VTableSlotPtr, CGF.getPointerAlign()); } @@ -2043,8 +2049,8 @@ llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr); llvm::Value *Offset; - llvm::Value *OffsetPtr = - CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment); + llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64( + CGF.Int8Ty, VTablePtr, VirtualAdjustment); if (CGF.CGM.getItaniumVTableContext().isRelativeLayout()) { // Load the adjustment offset from the vtable as a 32-bit int. OffsetPtr = @@ -2062,7 +2068,8 @@ Offset = CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign()); } // Adjust our pointer. - ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getPointer(), Offset); + ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getElementType(), + V.getPointer(), Offset); } else { ResultPtr = V.getPointer(); } @@ -2070,8 +2077,8 @@ // In a derived-to-base conversion, the non-virtual adjustment is // applied second. if (NonVirtualAdjustment && IsReturnAdjustment) { - ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ResultPtr, - NonVirtualAdjustment); + ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64( + V.getElementType(), ResultPtr, NonVirtualAdjustment); } // Cast back to the original type. @@ -4271,22 +4278,23 @@ // we have to skip past in order to reach the exception data. unsigned HeaderSize = CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException(); - AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize); - - // However, if we're catching a pointer-to-record type that won't - // work, because the personality function might have adjusted - // the pointer. There's actually no way for us to fully satisfy - // the language/ABI contract here: we can't use Exn because it - // might have the wrong adjustment, but we can't use the by-value - // pointer because it's off by a level of abstraction. - // - // The current solution is to dump the adjusted pointer into an - // alloca, which breaks language semantics (because changing the - // pointer doesn't change the exception) but at least works. - // The better solution would be to filter out non-exact matches - // and rethrow them, but this is tricky because the rethrow - // really needs to be catchable by other sites at this landing - // pad. The best solution is to fix the personality function. + AdjustedExn = + CGF.Builder.CreateConstGEP1_32(CGF.Int8Ty, Exn, HeaderSize); + + // However, if we're catching a pointer-to-record type that won't + // work, because the personality function might have adjusted + // the pointer. There's actually no way for us to fully satisfy + // the language/ABI contract here: we can't use Exn because it + // might have the wrong adjustment, but we can't use the by-value + // pointer because it's off by a level of abstraction. + // + // The current solution is to dump the adjusted pointer into an + // alloca, which breaks language semantics (because changing the + // pointer doesn't change the exception) but at least works. + // The better solution would be to filter out non-exact matches + // and rethrow them, but this is tricky because the rethrow + // really needs to be catchable by other sites at this landing + // pad. The best solution is to fix the personality function. } else { // Pull the pointer for the reference type off. llvm::Type *PtrTy = Index: clang/lib/CodeGen/MicrosoftCXXABI.cpp =================================================================== --- clang/lib/CodeGen/MicrosoftCXXABI.cpp +++ clang/lib/CodeGen/MicrosoftCXXABI.cpp @@ -928,7 +928,8 @@ llvm::Value *Offset = GetVirtualBaseClassOffset(CGF, Value, SrcDecl, PolymorphicBase); - llvm::Value *Ptr = CGF.Builder.CreateInBoundsGEP(Value.getPointer(), Offset); + llvm::Value *Ptr = CGF.Builder.CreateInBoundsGEP(Value.getElementType(), + Value.getPointer(), Offset); CharUnits VBaseAlign = CGF.CGM.getVBaseAlignment(Value.getAlignment(), SrcDecl, PolymorphicBase); return std::make_tuple(Address(Ptr, VBaseAlign), Offset, PolymorphicBase); @@ -1206,9 +1207,10 @@ if (!Int8This) Int8This = Builder.CreateBitCast(getThisValue(CGF), CGF.Int8Ty->getPointerTo(AS)); - llvm::Value *VtorDispPtr = Builder.CreateInBoundsGEP(Int8This, VBaseOffset); + llvm::Value *VtorDispPtr = + Builder.CreateInBoundsGEP(CGF.Int8Ty, Int8This, VBaseOffset); // vtorDisp is always the 32-bits before the vbase in the class layout. - VtorDispPtr = Builder.CreateConstGEP1_32(VtorDispPtr, -4); + VtorDispPtr = Builder.CreateConstGEP1_32(CGF.Int8Ty, VtorDispPtr, -4); VtorDispPtr = Builder.CreateBitCast( VtorDispPtr, CGF.Int32Ty->getPointerTo(AS), "vtordisp.ptr"); @@ -1442,8 +1444,8 @@ const CXXRecordDecl *VBase = ML.VBase; llvm::Value *VBaseOffset = GetVirtualBaseClassOffset(CGF, Result, Derived, VBase); - llvm::Value *VBasePtr = - CGF.Builder.CreateInBoundsGEP(Result.getPointer(), VBaseOffset); + llvm::Value *VBasePtr = CGF.Builder.CreateInBoundsGEP( + Result.getElementType(), Result.getPointer(), VBaseOffset); CharUnits VBaseAlign = CGF.CGM.getVBaseAlignment(Result.getAlignment(), Derived, VBase); Result = Address(VBasePtr, VBaseAlign); @@ -1895,12 +1897,13 @@ SourceLocation Loc) { CGBuilderTy &Builder = CGF.Builder; - Ty = Ty->getPointerTo()->getPointerTo(); + Ty = Ty->getPointerTo(); Address VPtr = adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true); auto *MethodDecl = cast(GD.getDecl()); - llvm::Value *VTable = CGF.GetVTablePtr(VPtr, Ty, MethodDecl->getParent()); + llvm::Value *VTable = + CGF.GetVTablePtr(VPtr, Ty->getPointerTo(), MethodDecl->getParent()); MicrosoftVTableContext &VFTContext = CGM.getMicrosoftVTableContext(); MethodVFTableLocation ML = VFTContext.getMethodVFTableLocation(GD); @@ -1927,7 +1930,7 @@ CGF.EmitTypeMetadataCodeForVCall(getObjectWithVPtr(), VTable, Loc); llvm::Value *VFuncPtr = - Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn"); + Builder.CreateConstInBoundsGEP1_64(Ty, VTable, ML.Index, "vfn"); VFunc = Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign()); } @@ -2056,11 +2059,12 @@ // Load the vfptr and then callee from the vftable. The callee should have // adjusted 'this' so that the vfptr is at offset zero. + llvm::Type *VTableTy = ThunkTy->getPointerTo(); llvm::Value *VTable = CGF.GetVTablePtr( - getThisAddress(CGF), ThunkTy->getPointerTo()->getPointerTo(), MD->getParent()); + getThisAddress(CGF), VTableTy->getPointerTo(), MD->getParent()); llvm::Value *VFuncPtr = - CGF.Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn"); + CGF.Builder.CreateConstInBoundsGEP1_64(VTableTy, VTable, ML.Index, "vfn"); llvm::Value *Callee = CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign()); @@ -2177,7 +2181,7 @@ CharUnits::fromQuantity(TA.Virtual.Microsoft.VtordispOffset)); VtorDispPtr = CGF.Builder.CreateElementBitCast(VtorDispPtr, CGF.Int32Ty); llvm::Value *VtorDisp = CGF.Builder.CreateLoad(VtorDispPtr, "vtordisp"); - V = CGF.Builder.CreateGEP(This.getPointer(), + V = CGF.Builder.CreateGEP(This.getElementType(), This.getPointer(), CGF.Builder.CreateNeg(VtorDisp)); // Unfortunately, having applied the vtordisp means that we no @@ -2195,7 +2199,7 @@ GetVBaseOffsetFromVBPtr(CGF, Address(V, CGF.getPointerAlign()), -TA.Virtual.Microsoft.VBPtrOffset, TA.Virtual.Microsoft.VBOffsetOffset, &VBPtr); - V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset); + V = CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, VBPtr, VBaseOffset); } } @@ -2203,7 +2207,7 @@ // Non-virtual adjustment might result in a pointer outside the allocated // object, e.g. if the final overrider class is laid out after the virtual // base that declares a method in the most derived class. - V = CGF.Builder.CreateConstGEP1_32(V, TA.NonVirtual); + V = CGF.Builder.CreateConstGEP1_32(CGF.Int8Ty, V, TA.NonVirtual); } // Don't need to bitcast back, the call CodeGen will handle this. @@ -2227,7 +2231,7 @@ llvm::Value *VBaseOffset = GetVBaseOffsetFromVBPtr(CGF, Ret, RA.Virtual.Microsoft.VBPtrOffset, IntSize * RA.Virtual.Microsoft.VBIndex, &VBPtr); - V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset); + V = CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, VBPtr, VBaseOffset); } if (RA.NonVirtual) @@ -2992,8 +2996,8 @@ CGBuilderTy &Builder = CGF.Builder; // Load the vbtable pointer from the vbptr in the instance. This = Builder.CreateElementBitCast(This, CGM.Int8Ty); - llvm::Value *VBPtr = - Builder.CreateInBoundsGEP(This.getPointer(), VBPtrOffset, "vbptr"); + llvm::Value *VBPtr = Builder.CreateInBoundsGEP( + This.getElementType(), This.getPointer(), VBPtrOffset, "vbptr"); if (VBPtrOut) *VBPtrOut = VBPtr; VBPtr = Builder.CreateBitCast(VBPtr, CGM.Int32Ty->getPointerTo(0)->getPointerTo(This.getAddressSpace())); @@ -3014,7 +3018,8 @@ "vbtindex", /*isExact=*/true); // Load an i32 offset from the vb-table. - llvm::Value *VBaseOffs = Builder.CreateInBoundsGEP(VBTable, VBTableIndex); + llvm::Value *VBaseOffs = + Builder.CreateInBoundsGEP(CGF.Int32Ty, VBTable, VBTableIndex); VBaseOffs = Builder.CreateBitCast(VBaseOffs, CGM.Int32Ty->getPointerTo(0)); return Builder.CreateAlignedLoad(VBaseOffs, CharUnits::fromQuantity(4), "vbase_offs"); @@ -3064,7 +3069,7 @@ llvm::Value *VBPtr = nullptr; llvm::Value *VBaseOffs = GetVBaseOffsetFromVBPtr(CGF, Base, VBPtrOffset, VBTableOffset, &VBPtr); - llvm::Value *AdjustedBase = Builder.CreateInBoundsGEP(VBPtr, VBaseOffs); + llvm::Value *AdjustedBase = Builder.CreateInBoundsGEP(CGF.Int8Ty, VBPtr, VBaseOffs); // Merge control flow with the case where we didn't have to adjust. if (VBaseAdjustBB) { @@ -3116,7 +3121,7 @@ Addr = Builder.CreateBitCast(Addr, CGF.Int8Ty->getPointerTo(AS)); // Apply the offset, which we assume is non-null. - Addr = Builder.CreateInBoundsGEP(Addr, FieldOffset, "memptr.offset"); + Addr = Builder.CreateInBoundsGEP(CGF.Int8Ty, Addr, FieldOffset, "memptr.offset"); // Cast the address to the appropriate pointer type, adopting the address // space of the base pointer. @@ -3278,9 +3283,9 @@ Mapping->getAggregateElement(cast(VBIndex)); } else { llvm::Value *Idxs[] = {getZeroInt(), VBIndex}; - VirtualBaseAdjustmentOffset = - Builder.CreateAlignedLoad(Builder.CreateInBoundsGEP(VDispMap, Idxs), - CharUnits::fromQuantity(4)); + VirtualBaseAdjustmentOffset = Builder.CreateAlignedLoad( + Builder.CreateInBoundsGEP(CGM.Int8Ty, VDispMap, Idxs), + CharUnits::fromQuantity(4)); } DstVBIndexEqZero = @@ -3410,7 +3415,7 @@ if (NonVirtualBaseAdjustment) { // Apply the adjustment and cast back to the original struct type. llvm::Value *Ptr = Builder.CreateBitCast(ThisPtrForCall, CGF.Int8PtrTy); - Ptr = Builder.CreateInBoundsGEP(Ptr, NonVirtualBaseAdjustment); + Ptr = Builder.CreateInBoundsGEP(CGF.Int8Ty, Ptr, NonVirtualBaseAdjustment); ThisPtrForCall = Builder.CreateBitCast(Ptr, ThisPtrForCall->getType(), "this.adjusted"); } Index: clang/lib/CodeGen/TargetInfo.cpp =================================================================== --- clang/lib/CodeGen/TargetInfo.cpp +++ clang/lib/CodeGen/TargetInfo.cpp @@ -3937,8 +3937,8 @@ uint64_t SizeInBytes = (CGF.getContext().getTypeSize(Ty) + 7) / 8; llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int32Ty, (SizeInBytes + 7) & ~7); - overflow_arg_area = CGF.Builder.CreateGEP(overflow_arg_area, Offset, - "overflow_arg_area.next"); + overflow_arg_area = CGF.Builder.CreateGEP(CGF.Int8Ty, overflow_arg_area, + Offset, "overflow_arg_area.next"); CGF.Builder.CreateStore(overflow_arg_area, overflow_arg_area_p); // AMD64-ABI 3.5.7p5: Step 11. Return the fetched type. @@ -4032,8 +4032,10 @@ "Unexpected ABI info for mixed regs"); llvm::Type *PTyLo = llvm::PointerType::getUnqual(TyLo); llvm::Type *PTyHi = llvm::PointerType::getUnqual(TyHi); - llvm::Value *GPAddr = CGF.Builder.CreateGEP(RegSaveArea, gp_offset); - llvm::Value *FPAddr = CGF.Builder.CreateGEP(RegSaveArea, fp_offset); + llvm::Value *GPAddr = + CGF.Builder.CreateGEP(CGF.Int8Ty, RegSaveArea, gp_offset); + llvm::Value *FPAddr = + CGF.Builder.CreateGEP(CGF.Int8Ty, RegSaveArea, fp_offset); llvm::Value *RegLoAddr = TyLo->isFPOrFPVectorTy() ? FPAddr : GPAddr; llvm::Value *RegHiAddr = TyLo->isFPOrFPVectorTy() ? GPAddr : FPAddr; @@ -4052,7 +4054,7 @@ RegAddr = CGF.Builder.CreateElementBitCast(Tmp, LTy); } else if (neededInt) { - RegAddr = Address(CGF.Builder.CreateGEP(RegSaveArea, gp_offset), + RegAddr = Address(CGF.Builder.CreateGEP(CGF.Int8Ty, RegSaveArea, gp_offset), CharUnits::fromQuantity(8)); RegAddr = CGF.Builder.CreateElementBitCast(RegAddr, LTy); @@ -4071,7 +4073,7 @@ } } else if (neededSSE == 1) { - RegAddr = Address(CGF.Builder.CreateGEP(RegSaveArea, fp_offset), + RegAddr = Address(CGF.Builder.CreateGEP(CGF.Int8Ty, RegSaveArea, fp_offset), CharUnits::fromQuantity(16)); RegAddr = CGF.Builder.CreateElementBitCast(RegAddr, LTy); } else { @@ -4082,8 +4084,9 @@ // to assume that the slots are 16-byte aligned, since the stack is // naturally 16-byte aligned and the prologue is expected to store // all the SSE registers to the RSA. - Address RegAddrLo = Address(CGF.Builder.CreateGEP(RegSaveArea, fp_offset), - CharUnits::fromQuantity(16)); + Address RegAddrLo = + Address(CGF.Builder.CreateGEP(CGF.Int8Ty, RegSaveArea, fp_offset), + CharUnits::fromQuantity(16)); Address RegAddrHi = CGF.Builder.CreateConstInBoundsByteGEP(RegAddrLo, CharUnits::fromQuantity(16)); @@ -5907,7 +5910,7 @@ Address reg_top_p = CGF.Builder.CreateStructGEP(VAListAddr, reg_top_index, "reg_top_p"); reg_top = CGF.Builder.CreateLoad(reg_top_p, "reg_top"); - Address BaseAddr(CGF.Builder.CreateInBoundsGEP(reg_top, reg_offs), + Address BaseAddr(CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, reg_top, reg_offs), CharUnits::fromQuantity(IsFPR ? 16 : 8)); Address RegAddr = Address::invalid(); llvm::Type *MemTy = CGF.ConvertTypeForMem(Ty); @@ -6005,8 +6008,8 @@ StackSize = TySize.alignTo(StackSlotSize); llvm::Value *StackSizeC = CGF.Builder.getSize(StackSize); - llvm::Value *NewStack = - CGF.Builder.CreateInBoundsGEP(OnStackPtr, StackSizeC, "new_stack"); + llvm::Value *NewStack = CGF.Builder.CreateInBoundsGEP( + CGF.Int8Ty, OnStackPtr, StackSizeC, "new_stack"); // Write the new value of __stack for the next call to va_arg CGF.Builder.CreateStore(NewStack, stack_p); @@ -7324,9 +7327,9 @@ CGF.Builder.CreateElementBitCast(OverflowArgArea, DirectTy, "mem_addr"); // Update overflow_arg_area_ptr pointer - llvm::Value *NewOverflowArgArea = - CGF.Builder.CreateGEP(OverflowArgArea.getPointer(), PaddedSizeV, - "overflow_arg_area"); + llvm::Value *NewOverflowArgArea = CGF.Builder.CreateGEP( + OverflowArgArea.getElementType(), OverflowArgArea.getPointer(), + PaddedSizeV, "overflow_arg_area"); CGF.Builder.CreateStore(NewOverflowArgArea, OverflowArgAreaPtr); return MemAddr; @@ -7375,9 +7378,9 @@ CGF.Builder.CreateStructGEP(VAListAddr, 3, "reg_save_area_ptr"); llvm::Value *RegSaveArea = CGF.Builder.CreateLoad(RegSaveAreaPtr, "reg_save_area"); - Address RawRegAddr(CGF.Builder.CreateGEP(RegSaveArea, RegOffset, - "raw_reg_addr"), - PaddedSize); + Address RawRegAddr( + CGF.Builder.CreateGEP(CGF.Int8Ty, RegSaveArea, RegOffset, "raw_reg_addr"), + PaddedSize); Address RegAddr = CGF.Builder.CreateElementBitCast(RawRegAddr, DirectTy, "reg_addr"); @@ -7403,9 +7406,9 @@ CGF.Builder.CreateElementBitCast(RawMemAddr, DirectTy, "mem_addr"); // Update overflow_arg_area_ptr pointer - llvm::Value *NewOverflowArgArea = - CGF.Builder.CreateGEP(OverflowArgArea.getPointer(), PaddedSizeV, - "overflow_arg_area"); + llvm::Value *NewOverflowArgArea = CGF.Builder.CreateGEP( + OverflowArgArea.getElementType(), OverflowArgArea.getPointer(), + PaddedSizeV, "overflow_arg_area"); CGF.Builder.CreateStore(NewOverflowArgArea, OverflowArgAreaPtr); CGF.EmitBranch(ContBlock); @@ -8260,7 +8263,7 @@ // Add offset to the current pointer to access the argument. __overflow_area_pointer = - CGF.Builder.CreateGEP(__overflow_area_pointer, Offset); + CGF.Builder.CreateGEP(CGF.Int8Ty, __overflow_area_pointer, Offset); llvm::Value *AsInt = CGF.Builder.CreatePtrToInt(__overflow_area_pointer, CGF.Int32Ty); @@ -8282,9 +8285,10 @@ // Round up to the minimum stack alignment for varargs which is 4 bytes. uint64_t Offset = llvm::alignTo(CGF.getContext().getTypeSize(Ty) / 8, 4); - __overflow_area_pointer = CGF.Builder.CreateGEP( - __overflow_area_pointer, llvm::ConstantInt::get(CGF.Int32Ty, Offset), - "__overflow_area_pointer.next"); + __overflow_area_pointer = + CGF.Builder.CreateGEP(CGF.Int8Ty, __overflow_area_pointer, + llvm::ConstantInt::get(CGF.Int32Ty, Offset), + "__overflow_area_pointer.next"); CGF.Builder.CreateStore(__overflow_area_pointer, __overflow_area_pointer_p); return AddrTyped; @@ -8314,7 +8318,7 @@ uint64_t Offset = llvm::alignTo(CGF.getContext().getTypeSize(Ty) / 8, 4); llvm::Value *NextAddr = Builder.CreateGEP( - Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset), "ap.next"); + CGF.Int8Ty, Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset), "ap.next"); Builder.CreateStore(NextAddr, VAListAddrAsBPP); return AddrTyped; @@ -8386,7 +8390,7 @@ } llvm::Value *__new_saved_reg_area_pointer = - CGF.Builder.CreateGEP(__current_saved_reg_area_pointer, + CGF.Builder.CreateGEP(CGF.Int8Ty, __current_saved_reg_area_pointer, llvm::ConstantInt::get(CGF.Int32Ty, ArgSize), "__new_saved_reg_area_pointer"); @@ -8441,9 +8445,10 @@ // Get the pointer for next argument in overflow area and store it // to overflow area pointer. - llvm::Value *__new_overflow_area_pointer = CGF.Builder.CreateGEP( - __overflow_area_pointer, llvm::ConstantInt::get(CGF.Int32Ty, ArgSize), - "__overflow_area_pointer.next"); + llvm::Value *__new_overflow_area_pointer = + CGF.Builder.CreateGEP(CGF.Int8Ty, __overflow_area_pointer, + llvm::ConstantInt::get(CGF.Int32Ty, ArgSize), + "__overflow_area_pointer.next"); CGF.Builder.CreateStore(__new_overflow_area_pointer, __overflow_area_pointer_p); Index: clang/test/CodeGenCXX/inheriting-constructor.cpp =================================================================== --- clang/test/CodeGenCXX/inheriting-constructor.cpp +++ clang/test/CodeGenCXX/inheriting-constructor.cpp @@ -95,7 +95,7 @@ // constructor, which takes no arguments other than the this pointer and VTT. // ITANIUM_LABEL: define linkonce_odr void @_ZN14noninline_virt1CCI1NS_1AEEiO1QPvU17pass_object_size0( // ITANIUM: call void @_ZN14noninline_virt1AC2EiO1QPvU17pass_object_size0({{.*}} %{{.*}}, i32 %{{.*}}, %{{.*}}* {{.*}}, i8* %{{.*}}, i{{32|64}} %{{.*}}) - // ITANIUM: call void @_ZN14noninline_virt1BCI2NS_1AEEiO1QPvU17pass_object_size0(%{{.*}}* %{{.*}}, i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @_ZTTN14noninline_virt1CE, i64 0, i64 1)) + // ITANIUM: call void @_ZN14noninline_virt1BCI2NS_1AEEiO1QPvU17pass_object_size0(%{{.*}}* %{{.*}}, i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @_ZTTN14noninline_virt1CE, i32 0, i64 1)) // ITANIUM: store {{.*}} @_ZTVN14noninline_virt1CE // C constructor forwards to B constructor and A constructor. We pass the args @@ -363,7 +363,7 @@ // ITANIUM: %[[A_CAST:.*]] = getelementptr {{.*}} %[[B_CAST]], i{{32|64}} {{12|16}} // ITANIUM: %[[A:.*]] = bitcast {{.*}} %[[A_CAST]] // ITANIUM: call void ({{.*}}, ...) @_ZN11inline_virt1AC2E1QiS1_OS1_z(%{{.*}}* %[[A]], {{.*}}, i32 2, {{.*}}, {{.*}}, i32 5, i32 6) - // ITANIUM: call void @_ZN11inline_virt1BCI2NS_1AEE1QiS1_OS1_z({{[^,]*}}, i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @_ZTTN11inline_virt1CE, i64 0, i64 1)) + // ITANIUM: call void @_ZN11inline_virt1BCI2NS_1AEE1QiS1_OS1_z({{[^,]*}}, i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @_ZTTN11inline_virt1CE, i32 0, i64 1)) // ITANIUM: store {{.*}} @_ZTVN11inline_virt1CE // ITANIUM: call void @_ZN1QD1Ev( // ITANIUM: call void @_ZN1QD1Ev( Index: llvm/include/llvm/IR/IRBuilder.h =================================================================== --- llvm/include/llvm/IR/IRBuilder.h +++ llvm/include/llvm/IR/IRBuilder.h @@ -1612,17 +1612,23 @@ } // Deprecated [opaque pointer types] - LoadInst *CreateLoad(Value *Ptr, const char *Name) { + LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr, const char *Name), + "specify loaded type explicitly, preferably not " + "derived directly from getElementType()") { return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name); } // Deprecated [opaque pointer types] - LoadInst *CreateLoad(Value *Ptr, const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr, const Twine &Name = ""), + "specify loaded type explicitly, preferably not " + "derived directly from getElementType()") { return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name); } // Deprecated [opaque pointer types] - LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const Twine &Name = ""), + "specify loaded type explicitly, preferably not " + "derived directly from getElementType()") { return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, isVolatile, Name); } @@ -1749,8 +1755,10 @@ return Insert(new AtomicRMWInst(Op, Ptr, Val, Alignment, Ordering, SSID)); } - Value *CreateGEP(Value *Ptr, ArrayRef IdxList, - const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(Value *CreateGEP(Value *Ptr, ArrayRef IdxList, + const Twine &Name = ""), + "specify GEP indexed type directly, preferably" + "not derived from getElementType()") { return CreateGEP(nullptr, Ptr, IdxList, Name); } @@ -1768,8 +1776,10 @@ return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name); } - Value *CreateInBoundsGEP(Value *Ptr, ArrayRef IdxList, - const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(Value *CreateInBoundsGEP(Value *Ptr, ArrayRef IdxList, + const Twine &Name = ""), + "specify GEP indexed type directly, preferably" + "not derived from getElementType()") { return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name); } @@ -1788,7 +1798,9 @@ return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name); } - Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = ""), + "specify GEP indexed type directly, preferably" + "not derived from getElementType()") { return CreateGEP(nullptr, Ptr, Idx, Name); } @@ -1807,7 +1819,9 @@ return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name); } - Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = ""), + "specify GEP indexed type directly, preferably" + "not derived from getElementType()") { return CreateConstGEP1_32(nullptr, Ptr, Idx0, Name); } @@ -1867,7 +1881,9 @@ return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name); } - Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = ""), + "specify GEP indexed type directly, preferably" + "not derived from getElementType()") { return CreateConstGEP1_64(nullptr, Ptr, Idx0, Name); } @@ -1881,8 +1897,10 @@ return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name); } - Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0, - const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0, + const Twine &Name = ""), + "specify GEP indexed type directly, preferably" + "not derived from getElementType()") { return CreateConstInBoundsGEP1_64(nullptr, Ptr, Idx0, Name); } @@ -1917,8 +1935,10 @@ return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name); } - Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, - const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, + const Twine &Name = ""), + "specify GEP indexed type directly, preferably" + "not derived from getElementType()") { return CreateConstInBoundsGEP2_64(nullptr, Ptr, Idx0, Idx1, Name); } @@ -1927,7 +1947,9 @@ return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name); } - Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") { + LLVM_ATTRIBUTE_DEPRECATED(Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = ""), + "specify GEP indexed type directly, preferably" + "not derived from getElementType()") { return CreateConstInBoundsGEP2_32(nullptr, Ptr, 0, Idx, Name); } Index: llvm/lib/CodeGen/CodeGenPrepare.cpp =================================================================== --- llvm/lib/CodeGen/CodeGenPrepare.cpp +++ llvm/lib/CodeGen/CodeGenPrepare.cpp @@ -5375,9 +5375,12 @@ // If the final index isn't a vector, emit a scalar GEP containing all ops // and a vector GEP with all zeroes final index. if (!Ops[FinalIndex]->getType()->isVectorTy()) { - NewAddr = Builder.CreateGEP(Ops[0], makeArrayRef(Ops).drop_front()); + Type *GEPTy = GEP->getSourceElementType(); + NewAddr = Builder.CreateGEP(GEPTy, Ops[0], makeArrayRef(Ops).drop_front()); auto *IndexTy = FixedVectorType::get(ScalarIndexTy, NumElts); - NewAddr = Builder.CreateGEP(NewAddr, Constant::getNullValue(IndexTy)); + NewAddr = Builder.CreateGEP(GetElementPtrInst::getIndexedType( + GEPTy, makeArrayRef(Ops).drop_front()), + NewAddr, Constant::getNullValue(IndexTy)); } else { Value *Base = Ops[0]; Value *Index = Ops[FinalIndex]; @@ -5386,11 +5389,15 @@ if (Ops.size() != 2) { // Replace the last index with 0. Ops[FinalIndex] = Constant::getNullValue(ScalarIndexTy); - Base = Builder.CreateGEP(Base, makeArrayRef(Ops).drop_front()); + Base = Builder.CreateGEP(GEP->getSourceElementType(), Base, + makeArrayRef(Ops).drop_front()); } // Now create the GEP with scalar pointer and vector index. - NewAddr = Builder.CreateGEP(Base, Index); + NewAddr = Builder.CreateGEP( + GetElementPtrInst::getIndexedType(GEP->getSourceElementType(), + makeArrayRef(Ops).drop_front()), + Base, Index); } MemoryInst->replaceUsesOfWith(Ptr, NewAddr); Index: llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp =================================================================== --- llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp +++ llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp @@ -489,11 +489,11 @@ AllocaInst *PrivTIDAddr = Builder.CreateAlloca(Int32, nullptr, "tid.addr.local"); - Instruction *PrivTID = Builder.CreateLoad(PrivTIDAddr, "tid"); + Instruction *PrivTID = Builder.CreateLoad(Int32, PrivTIDAddr, "tid"); // Add some fake uses for OpenMP provided arguments. - ToBeDeleted.push_back(Builder.CreateLoad(TIDAddr, "tid.addr.use")); - ToBeDeleted.push_back(Builder.CreateLoad(ZeroAddr, "zero.addr.use")); + ToBeDeleted.push_back(Builder.CreateLoad(Int32, TIDAddr, "tid.addr.use")); + ToBeDeleted.push_back(Builder.CreateLoad(Int32, ZeroAddr, "zero.addr.use")); // ThenBB // | @@ -573,7 +573,7 @@ // Initialize the local TID stack location with the argument value. Builder.SetInsertPoint(PrivTID); Function::arg_iterator OutlinedAI = OutlinedFn.arg_begin(); - Builder.CreateStore(Builder.CreateLoad(OutlinedAI), PrivTIDAddr); + Builder.CreateStore(Builder.CreateLoad(Int32, OutlinedAI), PrivTIDAddr); // If no "if" clause was present we do not need the call created during // outlining, otherwise we reuse it in the serialized parallel region. Index: llvm/lib/Target/AArch64/AArch64StackTagging.cpp =================================================================== --- llvm/lib/Target/AArch64/AArch64StackTagging.cpp +++ llvm/lib/Target/AArch64/AArch64StackTagging.cpp @@ -233,7 +233,7 @@ << ") zero\n"); Value *Ptr = BasePtr; if (Offset) - Ptr = IRB.CreateConstGEP1_32(Ptr, Offset); + Ptr = IRB.CreateConstGEP1_32(IRB.getInt8Ty(), Ptr, Offset); IRB.CreateCall(SetTagZeroFn, {Ptr, ConstantInt::get(IRB.getInt64Ty(), Size)}); } @@ -243,7 +243,7 @@ << ") undef\n"); Value *Ptr = BasePtr; if (Offset) - Ptr = IRB.CreateConstGEP1_32(Ptr, Offset); + Ptr = IRB.CreateConstGEP1_32(IRB.getInt8Ty(), Ptr, Offset); IRB.CreateCall(SetTagFn, {Ptr, ConstantInt::get(IRB.getInt64Ty(), Size)}); } @@ -252,7 +252,7 @@ LLVM_DEBUG(dbgs() << " " << *A << "\n " << *B << "\n"); Value *Ptr = BasePtr; if (Offset) - Ptr = IRB.CreateConstGEP1_32(Ptr, Offset); + Ptr = IRB.CreateConstGEP1_32(IRB.getInt8Ty(), Ptr, Offset); IRB.CreateCall(StgpFn, {Ptr, A, B}); } Index: llvm/lib/Transforms/IPO/AttributorAttributes.cpp =================================================================== --- llvm/lib/Transforms/IPO/AttributorAttributes.cpp +++ llvm/lib/Transforms/IPO/AttributorAttributes.cpp @@ -220,13 +220,17 @@ } // Create a GEP if we collected indices above. - if (Indices.size()) - Ptr = IRB.CreateGEP(Ptr, Indices, GEPName); + if (Indices.size()) { + // FIXME: bad to get pointee type from pointer, but harmless given what went + // on above to derive Indices. + Ptr = IRB.CreateGEP(Ptr->getType()->getPointerElementType(), Ptr, Indices, + GEPName); + } // If an offset is left we use byte-wise adjustment. if (Offset) { Ptr = IRB.CreateBitCast(Ptr, IRB.getInt8PtrTy()); - Ptr = IRB.CreateGEP(Ptr, IRB.getInt32(Offset), + Ptr = IRB.CreateGEP(IRB.getInt8Ty(), Ptr, IRB.getInt32(Offset), GEPName + ".b" + Twine(Offset)); } Index: llvm/lib/Transforms/InstCombine/InstructionCombining.cpp =================================================================== --- llvm/lib/Transforms/InstCombine/InstructionCombining.cpp +++ llvm/lib/Transforms/InstCombine/InstructionCombining.cpp @@ -1807,11 +1807,13 @@ // Propagate 'inbounds' and metadata from existing instructions. // Note: using IRBuilder to create the constants for efficiency. SmallVector IndexC(GEP.idx_begin(), GEP.idx_end()); + auto GEPTy = GEP.getSourceElementType(); bool IsInBounds = GEP.isInBounds(); - Value *NewTrueC = IsInBounds ? Builder.CreateInBoundsGEP(TrueC, IndexC) - : Builder.CreateGEP(TrueC, IndexC); - Value *NewFalseC = IsInBounds ? Builder.CreateInBoundsGEP(FalseC, IndexC) - : Builder.CreateGEP(FalseC, IndexC); + Value *NewTrueC = IsInBounds ? Builder.CreateInBoundsGEP(GEPTy, TrueC, IndexC) + : Builder.CreateGEP(GEPTy, TrueC, IndexC); + Value *NewFalseC = IsInBounds + ? Builder.CreateInBoundsGEP(GEPTy, FalseC, IndexC) + : Builder.CreateGEP(GEPTy, FalseC, IndexC); return SelectInst::Create(Cond, NewTrueC, NewFalseC, "", nullptr, Sel); } Index: llvm/lib/Transforms/Scalar/SROA.cpp =================================================================== --- llvm/lib/Transforms/Scalar/SROA.cpp +++ llvm/lib/Transforms/Scalar/SROA.cpp @@ -3469,20 +3469,21 @@ SmallVector Index(GEPI.idx_begin(), GEPI.idx_end()); bool IsInBounds = GEPI.isInBounds(); + auto GEPTy = GEPI.getSourceElementType(); Value *True = Sel->getTrueValue(); Value *NTrue = - IsInBounds - ? Builder.CreateInBoundsGEP(True, Index, - True->getName() + ".sroa.gep") - : Builder.CreateGEP(True, Index, True->getName() + ".sroa.gep"); + IsInBounds ? Builder.CreateInBoundsGEP(GEPTy, True, Index, + True->getName() + ".sroa.gep") + : Builder.CreateGEP(GEPTy, True, Index, + True->getName() + ".sroa.gep"); Value *False = Sel->getFalseValue(); Value *NFalse = - IsInBounds - ? Builder.CreateInBoundsGEP(False, Index, - False->getName() + ".sroa.gep") - : Builder.CreateGEP(False, Index, False->getName() + ".sroa.gep"); + IsInBounds ? Builder.CreateInBoundsGEP(GEPTy, False, Index, + False->getName() + ".sroa.gep") + : Builder.CreateGEP(GEPTy, False, Index, + False->getName() + ".sroa.gep"); Value *NSel = Builder.CreateSelect(Sel->getCondition(), NTrue, NFalse, Sel->getName() + ".sroa.sel"); @@ -3526,13 +3527,14 @@ PHINode *NewPN = PHIBuilder.CreatePHI(GEPI.getType(), PHI->getNumIncomingValues(), PHI->getName() + ".sroa.phi"); + auto GEPTy = GEPI.getSourceElementType(); for (unsigned I = 0, E = PHI->getNumIncomingValues(); I != E; ++I) { Instruction *In = cast(PHI->getIncomingValue(I)); IRBuilderTy B(In->getParent(), std::next(In->getIterator())); Value *NewVal = IsInBounds - ? B.CreateInBoundsGEP(In, Index, In->getName() + ".sroa.gep") - : B.CreateGEP(In, Index, In->getName() + ".sroa.gep"); + ? B.CreateInBoundsGEP(GEPTy, In, Index, In->getName() + ".sroa.gep") + : B.CreateGEP(GEPTy, In, Index, In->getName() + ".sroa.gep"); NewPN->addIncoming(NewVal, PHI->getIncomingBlock(I)); } Index: llvm/lib/Transforms/Utils/AMDGPUEmitPrintf.cpp =================================================================== --- llvm/lib/Transforms/Utils/AMDGPUEmitPrintf.cpp +++ llvm/lib/Transforms/Utils/AMDGPUEmitPrintf.cpp @@ -137,11 +137,11 @@ auto PtrPhi = Builder.CreatePHI(Str->getType(), 2); PtrPhi->addIncoming(Str, Prev); - auto PtrNext = Builder.CreateGEP(PtrPhi, One); + auto PtrNext = Builder.CreateGEP(Builder.getInt8Ty(), PtrPhi, One); PtrPhi->addIncoming(PtrNext, While); // Condition for the while loop. - auto Data = Builder.CreateLoad(PtrPhi); + auto Data = Builder.CreateLoad(Builder.getInt8Ty(), PtrPhi); auto Cmp = Builder.CreateICmpEQ(Data, CharZero); Builder.CreateCondBr(Cmp, WhileDone, While); Index: llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp =================================================================== --- llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp +++ llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp @@ -1784,7 +1784,8 @@ else { assert(Inst->getType()->isPointerTy()); Tmp = cast( - Builder.CreateGEP(Inst, Builder.getInt32(1), "tmp.lcssa.user")); + Builder.CreateGEP(Inst->getType()->getPointerElementType(), Inst, + Builder.getInt32(1), "tmp.lcssa.user")); } V = fixupLCSSAFormFor(Tmp, 0); Index: llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp =================================================================== --- llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp +++ llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp @@ -328,7 +328,8 @@ Builder.CreateStore(F->arg_begin(), PrivAI); Builder.restoreIP(CodeGenIP); - Value *PrivLoad = Builder.CreateLoad(PrivAI, "local.use"); + Value *PrivLoad = + Builder.CreateLoad(F->arg_begin()->getType(), PrivAI, "local.use"); Value *Cmp = Builder.CreateICmpNE(F->arg_begin(), PrivLoad); Instruction *ThenTerm, *ElseTerm; SplitBlockAndInsertIfThenElse(Cmp, CodeGenIP.getBlock()->getTerminator(), @@ -626,7 +627,8 @@ Builder.CreateStore(F->arg_begin(), PrivAI); Builder.restoreIP(CodeGenIP); - Value *PrivLoad = Builder.CreateLoad(PrivAI, "local.use"); + Value *PrivLoad = + Builder.CreateLoad(F->arg_begin()->getType(), PrivAI, "local.use"); Value *Cmp = Builder.CreateICmpNE(F->arg_begin(), PrivLoad); Instruction *ThenTerm, *ElseTerm; SplitBlockAndInsertIfThenElse(Cmp, CodeGenIP.getBlock()->getTerminator(), @@ -864,7 +866,8 @@ EntryBB = ThenBB->getUniquePredecessor(); // simple instructions for body - Value *PrivLoad = Builder.CreateLoad(PrivAI, "local.use"); + Value *PrivLoad = + Builder.CreateLoad(F->arg_begin()->getType(), PrivAI, "local.use"); Builder.CreateICmpNE(F->arg_begin(), PrivLoad); }; @@ -934,7 +937,8 @@ // body begin Builder.restoreIP(CodeGenIP); Builder.CreateStore(F->arg_begin(), PrivAI); - Value *PrivLoad = Builder.CreateLoad(PrivAI, "local.use"); + Value *PrivLoad = + Builder.CreateLoad(F->arg_begin()->getType(), PrivAI, "local.use"); Builder.CreateICmpNE(F->arg_begin(), PrivLoad); };