Index: llvm/lib/Bitcode/Reader/BitcodeReader.cpp =================================================================== --- llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -4404,7 +4404,7 @@ unsigned Align; if (Error Err = parseAlignmentValue(Record[OpNum], Align)) return Err; - I = new LoadInst(Op, "", Record[OpNum+1], Align, Ordering, SSID); + I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align, Ordering, SSID); InstructionList.push_back(I); break; Index: llvm/lib/CodeGen/AtomicExpandPass.cpp =================================================================== --- llvm/lib/CodeGen/AtomicExpandPass.cpp +++ llvm/lib/CodeGen/AtomicExpandPass.cpp @@ -381,7 +381,7 @@ Addr->getType()->getPointerAddressSpace()); Value *NewAddr = Builder.CreateBitCast(Addr, PT); - auto *NewLI = Builder.CreateLoad(NewAddr); + auto *NewLI = Builder.CreateLoad(NewTy, NewAddr); NewLI->setAlignment(LI->getAlignment()); NewLI->setVolatile(LI->isVolatile()); NewLI->setAtomic(LI->getOrdering(), LI->getSyncScopeID()); @@ -1769,8 +1769,8 @@ // from call} Type *FinalResultTy = I->getType(); Value *V = UndefValue::get(FinalResultTy); - Value *ExpectedOut = - Builder.CreateAlignedLoad(AllocaCASExpected, AllocaAlignment); + Value *ExpectedOut = Builder.CreateAlignedLoad( + CASExpected->getType(), AllocaCASExpected, AllocaAlignment); Builder.CreateLifetimeEnd(AllocaCASExpected_i8, SizeVal64); V = Builder.CreateInsertValue(V, ExpectedOut, 0); V = Builder.CreateInsertValue(V, Result, 1); @@ -1780,7 +1780,8 @@ if (UseSizedLibcall) V = Builder.CreateBitOrPointerCast(Result, I->getType()); else { - V = Builder.CreateAlignedLoad(AllocaResult, AllocaAlignment); + V = Builder.CreateAlignedLoad(I->getType(), AllocaResult, + AllocaAlignment); Builder.CreateLifetimeEnd(AllocaResult_i8, SizeVal64); } I->replaceAllUsesWith(V); Index: llvm/lib/CodeGen/GCRootLowering.cpp =================================================================== --- llvm/lib/CodeGen/GCRootLowering.cpp +++ llvm/lib/CodeGen/GCRootLowering.cpp @@ -213,7 +213,7 @@ } case Intrinsic::gcread: { // Replace a read barrier with a simple load. - Value *Ld = new LoadInst(CI->getArgOperand(1), "", CI); + Value *Ld = new LoadInst(CI->getType(), CI->getArgOperand(1), "", CI); Ld->takeName(CI); CI->replaceAllUsesWith(Ld); CI->eraseFromParent(); Index: llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp =================================================================== --- llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp +++ llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp @@ -1218,7 +1218,7 @@ "interleaved.wide.ptrcast"); // Create the wide load and update the MemorySSA. - auto LI = Builder.CreateAlignedLoad(CI, InsertionPoint->getAlignment(), + auto LI = Builder.CreateAlignedLoad(ILTy, CI, InsertionPoint->getAlignment(), "interleaved.wide.load"); auto MSSAU = MemorySSAUpdater(&MSSA); MemoryUse *MSSALoad = cast(MSSAU.createMemoryAccessBefore( Index: llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp =================================================================== --- llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp +++ llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp @@ -44,7 +44,7 @@ Value *OffsetPtr = B.CreateGEP(Int8Ty, CI->getArgOperand(0), CI->getArgOperand(1)); Value *OffsetPtrI32 = B.CreateBitCast(OffsetPtr, Int32PtrTy); - Value *OffsetI32 = B.CreateAlignedLoad(OffsetPtrI32, 4); + Value *OffsetI32 = B.CreateAlignedLoad(Int32Ty, OffsetPtrI32, 4); Value *ResultPtr = B.CreateGEP(Int8Ty, CI->getArgOperand(0), OffsetI32); Index: llvm/lib/CodeGen/SafeStack.cpp =================================================================== --- llvm/lib/CodeGen/SafeStack.cpp +++ llvm/lib/CodeGen/SafeStack.cpp @@ -371,7 +371,7 @@ if (!StackGuardVar) StackGuardVar = F.getParent()->getOrInsertGlobal("__stack_chk_guard", StackPtrTy); - return IRB.CreateLoad(StackGuardVar, "StackGuard"); + return IRB.CreateLoad(StackPtrTy, StackGuardVar, "StackGuard"); } void SafeStack::findInsts(Function &F, @@ -452,7 +452,8 @@ ++NumUnsafeStackRestorePoints; IRB.SetInsertPoint(I->getNextNode()); - Value *CurrentTop = DynamicTop ? IRB.CreateLoad(DynamicTop) : StaticTop; + Value *CurrentTop = + DynamicTop ? IRB.CreateLoad(StackPtrTy, DynamicTop) : StaticTop; IRB.CreateStore(CurrentTop, UnsafeStackPtr); } @@ -461,7 +462,7 @@ void SafeStack::checkStackGuard(IRBuilder<> &IRB, Function &F, ReturnInst &RI, AllocaInst *StackGuardSlot, Value *StackGuard) { - Value *V = IRB.CreateLoad(StackGuardSlot); + Value *V = IRB.CreateLoad(StackPtrTy, StackGuardSlot); Value *Cmp = IRB.CreateICmpNE(StackGuard, V); auto SuccessProb = BranchProbabilityInfo::getBranchProbStackProtector(true); @@ -659,7 +660,8 @@ uint64_t TySize = DL.getTypeAllocSize(Ty); Value *Size = IRB.CreateMul(ArraySize, ConstantInt::get(IntPtrTy, TySize)); - Value *SP = IRB.CreatePtrToInt(IRB.CreateLoad(UnsafeStackPtr), IntPtrTy); + Value *SP = IRB.CreatePtrToInt(IRB.CreateLoad(StackPtrTy, UnsafeStackPtr), + IntPtrTy); SP = IRB.CreateSub(SP, Size); // Align the SP value to satisfy the AllocaInst, type and stack alignments. @@ -697,7 +699,7 @@ if (II->getIntrinsicID() == Intrinsic::stacksave) { IRBuilder<> IRB(II); - Instruction *LI = IRB.CreateLoad(UnsafeStackPtr); + Instruction *LI = IRB.CreateLoad(StackPtrTy, UnsafeStackPtr); LI->takeName(II); II->replaceAllUsesWith(LI); II->eraseFromParent(); @@ -792,7 +794,7 @@ // Load the current stack pointer (we'll also use it as a base pointer). // FIXME: use a dedicated register for it ? Instruction *BasePointer = - IRB.CreateLoad(UnsafeStackPtr, false, "unsafe_stack_ptr"); + IRB.CreateLoad(StackPtrTy, UnsafeStackPtr, false, "unsafe_stack_ptr"); assert(BasePointer->getType() == StackPtrTy); AllocaInst *StackGuardSlot = nullptr; Index: llvm/lib/CodeGen/ScalarizeMaskedMemIntrin.cpp =================================================================== --- llvm/lib/CodeGen/ScalarizeMaskedMemIntrin.cpp +++ llvm/lib/CodeGen/ScalarizeMaskedMemIntrin.cpp @@ -143,7 +143,7 @@ // Short-cut if the mask is all-true. if (isa(Mask) && cast(Mask)->isAllOnesValue()) { - Value *NewI = Builder.CreateAlignedLoad(Ptr, AlignVal); + Value *NewI = Builder.CreateAlignedLoad(VecType, Ptr, AlignVal); CI->replaceAllUsesWith(NewI); CI->eraseFromParent(); return; @@ -166,7 +166,7 @@ continue; Value *Gep = Builder.CreateInBoundsGEP(EltTy, FirstEltPtr, Builder.getInt32(Idx)); - LoadInst *Load = Builder.CreateAlignedLoad(Gep, AlignVal); + LoadInst *Load = Builder.CreateAlignedLoad(EltTy, Gep, AlignVal); VResult = Builder.CreateInsertElement(VResult, Load, Builder.getInt32(Idx)); } @@ -198,7 +198,7 @@ Value *Gep = Builder.CreateInBoundsGEP(EltTy, FirstEltPtr, Builder.getInt32(Idx)); - LoadInst *Load = Builder.CreateAlignedLoad(Gep, AlignVal); + LoadInst *Load = Builder.CreateAlignedLoad(EltTy, Gep, AlignVal); Value *NewVResult = Builder.CreateInsertElement(VResult, Load, Builder.getInt32(Idx)); @@ -366,6 +366,7 @@ Value *Src0 = CI->getArgOperand(3); VectorType *VecType = cast(CI->getType()); + Type *EltTy = VecType->getElementType(); IRBuilder<> Builder(CI->getContext()); Instruction *InsertPt = CI; @@ -387,7 +388,7 @@ Value *Ptr = Builder.CreateExtractElement(Ptrs, Builder.getInt32(Idx), "Ptr" + Twine(Idx)); LoadInst *Load = - Builder.CreateAlignedLoad(Ptr, AlignVal, "Load" + Twine(Idx)); + Builder.CreateAlignedLoad(EltTy, Ptr, AlignVal, "Load" + Twine(Idx)); VResult = Builder.CreateInsertElement( VResult, Load, Builder.getInt32(Idx), "Res" + Twine(Idx)); } @@ -418,7 +419,7 @@ Value *Ptr = Builder.CreateExtractElement(Ptrs, Builder.getInt32(Idx), "Ptr" + Twine(Idx)); LoadInst *Load = - Builder.CreateAlignedLoad(Ptr, AlignVal, "Load" + Twine(Idx)); + Builder.CreateAlignedLoad(EltTy, Ptr, AlignVal, "Load" + Twine(Idx)); Value *NewVResult = Builder.CreateInsertElement(VResult, Load, Builder.getInt32(Idx), "Res" + Twine(Idx)); Index: llvm/lib/CodeGen/ShadowStackGCLowering.cpp =================================================================== --- llvm/lib/CodeGen/ShadowStackGCLowering.cpp +++ llvm/lib/CodeGen/ShadowStackGCLowering.cpp @@ -312,7 +312,8 @@ AtEntry.SetInsertPoint(IP->getParent(), IP); // Initialize the map pointer and load the current head of the shadow stack. - Instruction *CurrentHead = AtEntry.CreateLoad(Head, "gc_currhead"); + Instruction *CurrentHead = + AtEntry.CreateLoad(StackEntryTy->getPointerTo(), Head, "gc_currhead"); Instruction *EntryMapPtr = CreateGEP(Context, AtEntry, ConcreteStackEntryTy, StackEntry, 0, 1, "gc_frame.map"); AtEntry.CreateStore(FrameMap, EntryMapPtr); @@ -353,7 +354,8 @@ Instruction *EntryNextPtr2 = CreateGEP(Context, *AtExit, ConcreteStackEntryTy, StackEntry, 0, 0, "gc_frame.next"); - Value *SavedHead = AtExit->CreateLoad(EntryNextPtr2, "gc_savedhead"); + Value *SavedHead = AtExit->CreateLoad(StackEntryTy->getPointerTo(), + EntryNextPtr2, "gc_savedhead"); AtExit->CreateStore(SavedHead, Head); } Index: llvm/lib/CodeGen/SjLjEHPrepare.cpp =================================================================== --- llvm/lib/CodeGen/SjLjEHPrepare.cpp +++ llvm/lib/CodeGen/SjLjEHPrepare.cpp @@ -189,14 +189,16 @@ Builder.CreateConstGEP2_32(FunctionContextTy, FuncCtx, 0, 2, "__data"); // The exception values come back in context->__data[0]. + Type *Int32Ty = Type::getInt32Ty(F.getContext()); Value *ExceptionAddr = Builder.CreateConstGEP2_32(doubleUnderDataTy, FCData, 0, 0, "exception_gep"); - Value *ExnVal = Builder.CreateLoad(ExceptionAddr, true, "exn_val"); + Value *ExnVal = Builder.CreateLoad(Int32Ty, ExceptionAddr, true, "exn_val"); ExnVal = Builder.CreateIntToPtr(ExnVal, Builder.getInt8PtrTy()); Value *SelectorAddr = Builder.CreateConstGEP2_32(doubleUnderDataTy, FCData, 0, 1, "exn_selector_gep"); - Value *SelVal = Builder.CreateLoad(SelectorAddr, true, "exn_selector_val"); + Value *SelVal = + Builder.CreateLoad(Int32Ty, SelectorAddr, true, "exn_selector_val"); substituteLPadValues(LPI, ExnVal, SelVal); } Index: llvm/lib/CodeGen/StackProtector.cpp =================================================================== --- llvm/lib/CodeGen/StackProtector.cpp +++ llvm/lib/CodeGen/StackProtector.cpp @@ -322,7 +322,7 @@ IRBuilder<> &B, bool *SupportsSelectionDAGSP = nullptr) { if (Value *Guard = TLI->getIRStackGuard(B)) - return B.CreateLoad(Guard, true, "StackGuard"); + return B.CreateLoad(B.getInt8PtrTy(), Guard, true, "StackGuard"); // Use SelectionDAG SSP handling, since there isn't an IR guard. // @@ -417,7 +417,7 @@ // Generate the function-based epilogue instrumentation. // The target provides a guard check function, generate a call to it. IRBuilder<> B(RI); - LoadInst *Guard = B.CreateLoad(AI, true, "Guard"); + LoadInst *Guard = B.CreateLoad(B.getInt8PtrTy(), AI, true, "Guard"); CallInst *Call = B.CreateCall(GuardCheck, {Guard}); Call->setAttributes(GuardCheck->getAttributes()); Call->setCallingConv(GuardCheck->getCallingConv()); @@ -472,7 +472,7 @@ // Generate the stack protector instructions in the old basic block. IRBuilder<> B(BB); Value *Guard = getStackGuard(TLI, M, B); - LoadInst *LI2 = B.CreateLoad(AI, true); + LoadInst *LI2 = B.CreateLoad(B.getInt8PtrTy(), AI, true); Value *Cmp = B.CreateICmpEQ(Guard, LI2); auto SuccessProb = BranchProbabilityInfo::getBranchProbStackProtector(true); Index: llvm/lib/CodeGen/WasmEHPrepare.cpp =================================================================== --- llvm/lib/CodeGen/WasmEHPrepare.cpp +++ llvm/lib/CodeGen/WasmEHPrepare.cpp @@ -379,7 +379,8 @@ PersCI->setDoesNotThrow(); // Pseudocode: int selector = __wasm.landingpad_context.selector; - Instruction *Selector = IRB.CreateLoad(SelectorField, "selector"); + Instruction *Selector = + IRB.CreateLoad(IRB.getInt32Ty(), SelectorField, "selector"); // Replace the return value from wasm.get.ehselector() with the selector value // loaded from __wasm_lpad_context.selector. Index: llvm/lib/CodeGen/WinEHPrepare.cpp =================================================================== --- llvm/lib/CodeGen/WinEHPrepare.cpp +++ llvm/lib/CodeGen/WinEHPrepare.cpp @@ -1079,7 +1079,8 @@ SpillSlot = new AllocaInst(PN->getType(), DL->getAllocaAddrSpace(), nullptr, Twine(PN->getName(), ".wineh.spillslot"), &F.getEntryBlock().front()); - Value *V = new LoadInst(SpillSlot, Twine(PN->getName(), ".wineh.reload"), + Value *V = new LoadInst(PN->getType(), SpillSlot, + Twine(PN->getName(), ".wineh.reload"), &*PHIBlock->getFirstInsertionPt()); PN->replaceAllUsesWith(V); return SpillSlot; @@ -1221,13 +1222,15 @@ Value *&Load = Loads[IncomingBlock]; // Insert the load into the predecessor block if (!Load) - Load = new LoadInst(SpillSlot, Twine(V->getName(), ".wineh.reload"), + Load = new LoadInst(V->getType(), SpillSlot, + Twine(V->getName(), ".wineh.reload"), /*Volatile=*/false, IncomingBlock->getTerminator()); U.set(Load); } else { // Reload right before the old use. - auto *Load = new LoadInst(SpillSlot, Twine(V->getName(), ".wineh.reload"), + auto *Load = new LoadInst(V->getType(), SpillSlot, + Twine(V->getName(), ".wineh.reload"), /*Volatile=*/false, UsingInst); U.set(Load); } Index: llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp =================================================================== --- llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp +++ llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp @@ -235,14 +235,13 @@ assert(F.isDeclaration() && "Can't turn a definition into a stub."); assert(F.getParent() && "Function isn't in a module."); Module &M = *F.getParent(); - FunctionType *FTy = F.getFunctionType(); BasicBlock *EntryBlock = BasicBlock::Create(M.getContext(), "entry", &F); IRBuilder<> Builder(EntryBlock); - LoadInst *ImplAddr = Builder.CreateLoad(&ImplPointer); + LoadInst *ImplAddr = Builder.CreateLoad(F.getType(), &ImplPointer); std::vector CallArgs; for (auto &A : F.args()) CallArgs.push_back(&A); - CallInst *Call = Builder.CreateCall(FTy, ImplAddr, CallArgs); + CallInst *Call = Builder.CreateCall(F.getFunctionType(), ImplAddr, CallArgs); Call->setTailCall(); Call->setAttributes(F.getAttributes()); if (F.getReturnType()->isVoidTy()) Index: llvm/lib/FuzzMutate/RandomIRBuilder.cpp =================================================================== --- llvm/lib/FuzzMutate/RandomIRBuilder.cpp +++ llvm/lib/FuzzMutate/RandomIRBuilder.cpp @@ -53,7 +53,8 @@ IP = ++I->getIterator(); assert(IP != BB.end() && "guaranteed by the findPointer"); } - auto *NewLoad = new LoadInst(Ptr, "L", &*IP); + auto *NewLoad = new LoadInst( + cast(Ptr->getType())->getElementType(), Ptr, "L", &*IP); // Only sample this load if it really matches the descriptor if (Pred.matches(Srcs, NewLoad)) Index: llvm/lib/IR/AutoUpgrade.cpp =================================================================== --- llvm/lib/IR/AutoUpgrade.cpp +++ llvm/lib/IR/AutoUpgrade.cpp @@ -1152,16 +1152,16 @@ static Value *UpgradeMaskedLoad(IRBuilder<> &Builder, Value *Ptr, Value *Passthru, Value *Mask, bool Aligned) { + Type *ValTy = Passthru->getType(); // Cast the pointer to the right type. - Ptr = Builder.CreateBitCast(Ptr, - llvm::PointerType::getUnqual(Passthru->getType())); + Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(ValTy)); unsigned Align = Aligned ? cast(Passthru->getType())->getBitWidth() / 8 : 1; // If the mask is all ones just emit a regular store. if (const auto *C = dyn_cast(Mask)) if (C->isAllOnesValue()) - return Builder.CreateAlignedLoad(Ptr, Align); + return Builder.CreateAlignedLoad(ValTy, Ptr, Align); // Convert the mask from an integer type to a vector of i1. unsigned NumElts = Passthru->getType()->getVectorNumElements(); @@ -2176,7 +2176,7 @@ Type *VT = VectorType::get(EltTy, NumSrcElts); Value *Op = Builder.CreatePointerCast(CI->getArgOperand(0), PointerType::getUnqual(VT)); - Value *Load = Builder.CreateAlignedLoad(Op, 1); + Value *Load = Builder.CreateAlignedLoad(VT, Op, 1); if (NumSrcElts == 2) Rep = Builder.CreateShuffleVector(Load, UndefValue::get(Load->getType()), { 0, 1, 0, 1 }); @@ -2922,7 +2922,7 @@ // Convert the type of the pointer to a pointer to the stored type. Value *BC = Builder.CreateBitCast(Ptr, PointerType::getUnqual(VTy), "cast"); - LoadInst *LI = Builder.CreateAlignedLoad(BC, VTy->getBitWidth() / 8); + LoadInst *LI = Builder.CreateAlignedLoad(VTy, BC, VTy->getBitWidth() / 8); LI->setMetadata(M->getMDKindID("nontemporal"), Node); Rep = LI; } else if (IsX86 && Index: llvm/lib/Target/AArch64/AArch64PromoteConstant.cpp =================================================================== --- llvm/lib/Target/AArch64/AArch64PromoteConstant.cpp +++ llvm/lib/Target/AArch64/AArch64PromoteConstant.cpp @@ -493,7 +493,8 @@ for (const auto &IPI : InsertPts) { // Create the load of the global variable. IRBuilder<> Builder(IPI.first); - LoadInst *LoadedCst = Builder.CreateLoad(&PromotedGV); + LoadInst *LoadedCst = + Builder.CreateLoad(PromotedGV.getValueType(), &PromotedGV); LLVM_DEBUG(dbgs() << "**********\n"); LLVM_DEBUG(dbgs() << "New def: "); LLVM_DEBUG(LoadedCst->print(dbgs())); Index: llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp =================================================================== --- llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp +++ llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp @@ -806,7 +806,7 @@ Type *I32Ty = Builder.getInt32Ty(); Type *PT = PointerType::get(I32Ty, I.getPointerAddressSpace()); Value *BitCast= Builder.CreateBitCast(I.getPointerOperand(), PT); - LoadInst *WidenLoad = Builder.CreateLoad(BitCast); + LoadInst *WidenLoad = Builder.CreateLoad(I32Ty, BitCast); WidenLoad->copyMetadata(I); // If we have range metadata, we need to convert the type, and not make Index: llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp =================================================================== --- llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp +++ llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp @@ -1357,12 +1357,12 @@ if (!isSin) { // CI->cos, UI->sin B.SetInsertPoint(&*ItOld); UI->replaceAllUsesWith(&*Call); - Instruction *Reload = B.CreateLoad(Alloc); + Instruction *Reload = B.CreateLoad(Alloc->getAllocatedType(), Alloc); CI->replaceAllUsesWith(Reload); UI->eraseFromParent(); CI->eraseFromParent(); } else { // CI->sin, UI->cos - Instruction *Reload = B.CreateLoad(Alloc); + Instruction *Reload = B.CreateLoad(Alloc->getAllocatedType(), Alloc); UI->replaceAllUsesWith(Reload); CI->replaceAllUsesWith(Call); UI->eraseFromParent(); Index: llvm/lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp =================================================================== --- llvm/lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp +++ llvm/lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp @@ -131,6 +131,7 @@ KernArgBaseAlign); Value *ArgPtr; + Type *AdjustedArgTy; if (DoShiftOpt) { // FIXME: Handle aggregate types // Since we don't have sub-dword scalar loads, avoid doing an extload by // loading earlier than the argument address, and extracting the relevant @@ -143,25 +144,25 @@ KernArgSegment, AlignDownOffset, Arg.getName() + ".kernarg.offset.align.down"); - ArgPtr = Builder.CreateBitCast(ArgPtr, - Builder.getInt32Ty()->getPointerTo(AS), - ArgPtr->getName() + ".cast"); + AdjustedArgTy = Builder.getInt32Ty(); } else { ArgPtr = Builder.CreateConstInBoundsGEP1_64( KernArgSegment, EltOffset, Arg.getName() + ".kernarg.offset"); - ArgPtr = Builder.CreateBitCast(ArgPtr, ArgTy->getPointerTo(AS), - ArgPtr->getName() + ".cast"); + AdjustedArgTy = ArgTy; } if (IsV3 && Size >= 32) { V4Ty = VectorType::get(VT->getVectorElementType(), 4); // Use the hack that clang uses to avoid SelectionDAG ruining v3 loads - ArgPtr = Builder.CreateBitCast(ArgPtr, V4Ty->getPointerTo(AS)); + AdjustedArgTy = V4Ty; } - LoadInst *Load = Builder.CreateAlignedLoad(ArgPtr, AdjustedAlign); + ArgPtr = Builder.CreateBitCast(ArgPtr, AdjustedArgTy->getPointerTo(AS), + ArgPtr->getName() + ".cast"); + LoadInst *Load = + Builder.CreateAlignedLoad(AdjustedArgTy, ArgPtr, AdjustedAlign); Load->setMetadata(LLVMContext::MD_invariant_load, MDNode::get(Ctx, {})); MDBuilder MDB(Ctx); Index: llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp =================================================================== --- llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp +++ llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp @@ -245,10 +245,10 @@ // 32-bit and extract sequence is already present, and it is probably easier // to CSE this. The loads should be mergable later anyway. Value *GEPXY = Builder.CreateConstInBoundsGEP1_64(CastDispatchPtr, 1); - LoadInst *LoadXY = Builder.CreateAlignedLoad(GEPXY, 4); + LoadInst *LoadXY = Builder.CreateAlignedLoad(I32Ty, GEPXY, 4); Value *GEPZU = Builder.CreateConstInBoundsGEP1_64(CastDispatchPtr, 2); - LoadInst *LoadZU = Builder.CreateAlignedLoad(GEPZU, 4); + LoadInst *LoadZU = Builder.CreateAlignedLoad(I32Ty, GEPZU, 4); MDNode *MD = MDNode::get(Mod->getContext(), None); LoadXY->setMetadata(LLVMContext::MD_invariant_load, MD); @@ -426,7 +426,7 @@ Value *Index = calculateVectorIndex(Ptr, GEPVectorIdx); Value *BitCast = Builder.CreateBitCast(Alloca, VecPtrTy); - Value *VecValue = Builder.CreateLoad(BitCast); + Value *VecValue = Builder.CreateLoad(VectorTy, BitCast); Value *ExtractElement = Builder.CreateExtractElement(VecValue, Index); Inst->replaceAllUsesWith(ExtractElement); Inst->eraseFromParent(); @@ -441,7 +441,7 @@ Value *Ptr = SI->getPointerOperand(); Value *Index = calculateVectorIndex(Ptr, GEPVectorIdx); Value *BitCast = Builder.CreateBitCast(Alloca, VecPtrTy); - Value *VecValue = Builder.CreateLoad(BitCast); + Value *VecValue = Builder.CreateLoad(VectorTy, BitCast); Value *NewVecValue = Builder.CreateInsertElement(VecValue, SI->getValueOperand(), Index); Index: llvm/lib/Target/ARM/ARMParallelDSP.cpp =================================================================== --- llvm/lib/Target/ARM/ARMParallelDSP.cpp +++ llvm/lib/Target/ARM/ARMParallelDSP.cpp @@ -688,12 +688,12 @@ } static LoadInst *CreateLoadIns(IRBuilder &IRB, LoadInst &BaseLoad, - const Type *LoadTy) { + Type *LoadTy) { const unsigned AddrSpace = BaseLoad.getPointerAddressSpace(); Value *VecPtr = IRB.CreateBitCast(BaseLoad.getPointerOperand(), LoadTy->getPointerTo(AddrSpace)); - return IRB.CreateAlignedLoad(VecPtr, BaseLoad.getAlignment()); + return IRB.CreateAlignedLoad(LoadTy, VecPtr, BaseLoad.getAlignment()); } Instruction *ARMParallelDSP::CreateSMLADCall(LoadInst *VecLd0, LoadInst *VecLd1, @@ -709,7 +709,7 @@ ++BasicBlock::iterator(InsertAfter)); // Replace the reduction chain with an intrinsic call - const Type *Ty = IntegerType::get(M->getContext(), 32); + Type *Ty = IntegerType::get(M->getContext(), 32); LoadInst *NewLd0 = CreateLoadIns(Builder, VecLd0[0], Ty); LoadInst *NewLd1 = CreateLoadIns(Builder, VecLd1[0], Ty); Value* Args[] = { NewLd0, NewLd1, Acc }; Index: llvm/lib/Target/NVPTX/NVPTXLowerArgs.cpp =================================================================== --- llvm/lib/Target/NVPTX/NVPTXLowerArgs.cpp +++ llvm/lib/Target/NVPTX/NVPTXLowerArgs.cpp @@ -169,7 +169,8 @@ Value *ArgInParam = new AddrSpaceCastInst( Arg, PointerType::get(StructType, ADDRESS_SPACE_PARAM), Arg->getName(), FirstInst); - LoadInst *LI = new LoadInst(ArgInParam, Arg->getName(), FirstInst); + LoadInst *LI = + new LoadInst(StructType, ArgInParam, Arg->getName(), FirstInst); new StoreInst(LI, AllocA, FirstInst); } Index: llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp =================================================================== --- llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp +++ llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp @@ -445,7 +445,8 @@ // Post-invoke // %__THREW__.val = __THREW__; __THREW__ = 0; - Value *Threw = IRB.CreateLoad(ThrewGV, ThrewGV->getName() + ".val"); + Value *Threw = + IRB.CreateLoad(IRB.getInt32Ty(), ThrewGV, ThrewGV->getName() + ".val"); IRB.CreateStore(IRB.getInt32(0), ThrewGV); return Threw; } @@ -548,8 +549,8 @@ BasicBlock *ElseBB1 = BasicBlock::Create(C, "if.else1", F); BasicBlock *EndBB1 = BasicBlock::Create(C, "if.end", F); Value *ThrewCmp = IRB.CreateICmpNE(Threw, IRB.getInt32(0)); - Value *ThrewValue = - IRB.CreateLoad(ThrewValueGV, ThrewValueGV->getName() + ".val"); + Value *ThrewValue = IRB.CreateLoad(IRB.getInt32Ty(), ThrewValueGV, + ThrewValueGV->getName() + ".val"); Value *ThrewValueCmp = IRB.CreateICmpNE(ThrewValue, IRB.getInt32(0)); Value *Cmp1 = IRB.CreateAnd(ThrewCmp, ThrewValueCmp, "cmp1"); IRB.CreateCondBr(Cmp1, ThenBB1, ElseBB1); @@ -561,8 +562,8 @@ BasicBlock *EndBB2 = BasicBlock::Create(C, "if.end2", F); Value *ThrewInt = IRB.CreateIntToPtr(Threw, Type::getInt32PtrTy(C), Threw->getName() + ".i32p"); - Value *LoadedThrew = - IRB.CreateLoad(ThrewInt, ThrewInt->getName() + ".loaded"); + Value *LoadedThrew = IRB.CreateLoad(IRB.getInt32Ty(), ThrewInt, + ThrewInt->getName() + ".loaded"); Value *ThenLabel = IRB.CreateCall( TestSetjmpF, {LoadedThrew, SetjmpTable, SetjmpTableSize}, "label"); Value *Cmp2 = IRB.CreateICmpEQ(ThenLabel, IRB.getInt32(0)); Index: llvm/lib/Target/X86/X86ISelLowering.cpp =================================================================== --- llvm/lib/Target/X86/X86ISelLowering.cpp +++ llvm/lib/Target/X86/X86ISelLowering.cpp @@ -25249,7 +25249,6 @@ // We must restrict the ordering to avoid generating loads with Release or // ReleaseAcquire orderings. auto Order = AtomicCmpXchgInst::getStrongestFailureOrdering(AI->getOrdering()); - auto Ptr = AI->getPointerOperand(); // Before the load we need a fence. Here is an example lifted from // http://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf showing why a fence @@ -25284,8 +25283,9 @@ Builder.CreateCall(MFence, {}); // Finally we can emit the atomic load. - LoadInst *Loaded = Builder.CreateAlignedLoad(Ptr, - AI->getType()->getPrimitiveSizeInBits()); + LoadInst *Loaded = + Builder.CreateAlignedLoad(AI->getType(), AI->getPointerOperand(), + AI->getType()->getPrimitiveSizeInBits()); Loaded->setAtomic(Order, SSID); AI->replaceAllUsesWith(Loaded); AI->eraseFromParent(); Index: llvm/lib/Target/X86/X86InterleavedAccess.cpp =================================================================== --- llvm/lib/Target/X86/X86InterleavedAccess.cpp +++ llvm/lib/Target/X86/X86InterleavedAccess.cpp @@ -193,7 +193,7 @@ // Decompose the load instruction. LoadInst *LI = cast(VecInst); - Type *VecBasePtrTy = SubVecTy->getPointerTo(LI->getPointerAddressSpace()); + Type *VecBaseTy, *VecBasePtrTy; Value *VecBasePtr; unsigned int NumLoads = NumSubVectors; // In the case of stride 3 with a vector of 32 elements load the information @@ -201,18 +201,21 @@ // [0,1...,VF/2-1,VF/2+VF,VF/2+VF+1,...,2VF-1] unsigned VecLength = DL.getTypeSizeInBits(VecWidth); if (VecLength == 768 || VecLength == 1536) { - Type *VecTran = - VectorType::get(Type::getInt8Ty(LI->getContext()), 16)->getPointerTo(); - VecBasePtr = Builder.CreateBitCast(LI->getPointerOperand(), VecTran); + VecBaseTy = VectorType::get(Type::getInt8Ty(LI->getContext()), 16); + VecBasePtrTy = VecBaseTy->getPointerTo(LI->getPointerAddressSpace()); + VecBasePtr = Builder.CreateBitCast(LI->getPointerOperand(), VecBasePtrTy); NumLoads = NumSubVectors * (VecLength / 384); - } else + } else { + VecBaseTy = SubVecTy; + VecBasePtrTy = VecBaseTy->getPointerTo(LI->getPointerAddressSpace()); VecBasePtr = Builder.CreateBitCast(LI->getPointerOperand(), VecBasePtrTy); + } // Generate N loads of T type. for (unsigned i = 0; i < NumLoads; i++) { // TODO: Support inbounds GEP. Value *NewBasePtr = Builder.CreateGEP(VecBasePtr, Builder.getInt32(i)); Instruction *NewLoad = - Builder.CreateAlignedLoad(NewBasePtr, LI->getAlignment()); + Builder.CreateAlignedLoad(VecBaseTy, NewBasePtr, LI->getAlignment()); DecomposedVectors.push_back(NewLoad); } } Index: llvm/lib/Target/X86/X86WinEHState.cpp =================================================================== --- llvm/lib/Target/X86/X86WinEHState.cpp +++ llvm/lib/Target/X86/X86WinEHState.cpp @@ -432,7 +432,7 @@ // Next = [fs:00] Constant *FSZero = Constant::getNullValue(LinkTy->getPointerTo()->getPointerTo(257)); - Value *Next = Builder.CreateLoad(FSZero); + Value *Next = Builder.CreateLoad(LinkTy->getPointerTo(), FSZero); Builder.CreateStore(Next, Builder.CreateStructGEP(LinkTy, Link, 0)); // [fs:00] = Link Builder.CreateStore(Link, FSZero); @@ -447,8 +447,8 @@ } Type *LinkTy = getEHLinkRegistrationType(); // [fs:00] = Link->Next - Value *Next = - Builder.CreateLoad(Builder.CreateStructGEP(LinkTy, Link, 0)); + Value *Next = Builder.CreateLoad(LinkTy->getPointerTo(), + Builder.CreateStructGEP(LinkTy, Link, 0)); Constant *FSZero = Constant::getNullValue(LinkTy->getPointerTo()->getPointerTo(257)); Builder.CreateStore(Next, FSZero); @@ -783,7 +783,7 @@ if (InCleanup) { Value *StateField = Builder.CreateStructGEP(nullptr, RegNode, StateFieldIndex); - State = Builder.CreateLoad(StateField); + State = Builder.CreateLoad(Builder.getInt32Ty(), StateField); } else { State = Builder.getInt32(getStateForCallSite(BlockColors, FuncInfo, CS)); } Index: llvm/lib/Transforms/Coroutines/CoroCleanup.cpp =================================================================== --- llvm/lib/Transforms/Coroutines/CoroCleanup.cpp +++ llvm/lib/Transforms/Coroutines/CoroCleanup.cpp @@ -49,7 +49,7 @@ Builder.SetInsertPoint(SubFn); auto *FramePtr = Builder.CreateBitCast(FrameRaw, FramePtrTy); auto *Gep = Builder.CreateConstInBoundsGEP2_32(FrameTy, FramePtr, 0, Index); - auto *Load = Builder.CreateLoad(Gep); + auto *Load = Builder.CreateLoad(FrameTy->getElementType(Index), Gep); SubFn->replaceAllUsesWith(Load); } Index: llvm/lib/Transforms/Coroutines/CoroEarly.cpp =================================================================== --- llvm/lib/Transforms/Coroutines/CoroEarly.cpp +++ llvm/lib/Transforms/Coroutines/CoroEarly.cpp @@ -97,7 +97,7 @@ Builder.SetInsertPoint(II); auto *BCI = Builder.CreateBitCast(Operand, FramePtrTy); auto *Gep = Builder.CreateConstInBoundsGEP1_32(FrameTy, BCI, 0); - auto *Load = Builder.CreateLoad(Gep); + auto *Load = Builder.CreateLoad(FrameTy, Gep); auto *Cond = Builder.CreateICmpEQ(Load, NullPtr); II->replaceAllUsesWith(Cond); Index: llvm/lib/Transforms/Coroutines/CoroFrame.cpp =================================================================== --- llvm/lib/Transforms/Coroutines/CoroFrame.cpp +++ llvm/lib/Transforms/Coroutines/CoroFrame.cpp @@ -471,10 +471,10 @@ static Instruction *insertSpills(SpillInfo &Spills, coro::Shape &Shape) { auto *CB = Shape.CoroBegin; IRBuilder<> Builder(CB->getNextNode()); - PointerType *FramePtrTy = Shape.FrameTy->getPointerTo(); + StructType *FrameTy = Shape.FrameTy; + PointerType *FramePtrTy = FrameTy->getPointerTo(); auto *FramePtr = cast(Builder.CreateBitCast(CB, FramePtrTy, "FramePtr")); - Type *FrameTy = FramePtrTy->getElementType(); Value *CurrentValue = nullptr; BasicBlock *CurrentBlock = nullptr; @@ -501,7 +501,7 @@ Twine(".reload.addr")); return isa(CurrentValue) ? G - : Builder.CreateLoad(G, + : Builder.CreateLoad(FrameTy->getElementType(Index), G, CurrentValue->getName() + Twine(".reload")); }; Index: llvm/lib/Transforms/Coroutines/CoroSplit.cpp =================================================================== --- llvm/lib/Transforms/Coroutines/CoroSplit.cpp +++ llvm/lib/Transforms/Coroutines/CoroSplit.cpp @@ -93,7 +93,7 @@ auto *FrameTy = Shape.FrameTy; auto *GepIndex = Builder.CreateConstInBoundsGEP2_32( FrameTy, FramePtr, 0, coro::Shape::IndexField, "index.addr"); - auto *Index = Builder.CreateLoad(GepIndex, "index"); + auto *Index = Builder.CreateLoad(Shape.getIndexType(), GepIndex, "index"); auto *Switch = Builder.CreateSwitch(Index, UnreachBB, Shape.CoroSuspends.size()); Shape.ResumeSwitch = Switch; @@ -229,7 +229,8 @@ Builder.SetInsertPoint(OldSwitchBB->getTerminator()); auto *GepIndex = Builder.CreateConstInBoundsGEP2_32(Shape.FrameTy, FramePtr, 0, 0, "ResumeFn.addr"); - auto *Load = Builder.CreateLoad(GepIndex); + auto *Load = Builder.CreateLoad( + Shape.FrameTy->getElementType(coro::Shape::ResumeField), GepIndex); auto *NullPtr = ConstantPointerNull::get(cast(Load->getType())); auto *Cond = Builder.CreateICmpEQ(Load, NullPtr); Index: llvm/lib/Transforms/IPO/ArgumentPromotion.cpp =================================================================== --- llvm/lib/Transforms/IPO/ArgumentPromotion.cpp +++ llvm/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -263,7 +263,8 @@ Value *Idx = GetElementPtrInst::Create( STy, *AI, Idxs, (*AI)->getName() + "." + Twine(i), Call); // TODO: Tell AA about the new values? - Args.push_back(new LoadInst(Idx, Idx->getName() + ".val", Call)); + Args.push_back(new LoadInst(STy->getElementType(i), Idx, + Idx->getName() + ".val", Call)); ArgAttrVec.push_back(AttributeSet()); } } else if (!I->use_empty()) { @@ -299,7 +300,8 @@ } // Since we're replacing a load make sure we take the alignment // of the previous load. - LoadInst *newLoad = new LoadInst(V, V->getName() + ".val", Call); + LoadInst *newLoad = + new LoadInst(OrigLoad->getType(), V, V->getName() + ".val", Call); newLoad->setAlignment(OrigLoad->getAlignment()); // Transfer the AA info too. AAMDNodes AAInfo; Index: llvm/lib/Transforms/IPO/GlobalOpt.cpp =================================================================== --- llvm/lib/Transforms/IPO/GlobalOpt.cpp +++ llvm/lib/Transforms/IPO/GlobalOpt.cpp @@ -905,9 +905,10 @@ // Replace the cmp X, 0 with a use of the bool value. // Sink the load to where the compare was, if atomic rules allow us to. - Value *LV = new LoadInst(InitBool, InitBool->getName()+".val", false, 0, + Value *LV = new LoadInst(InitBool->getValueType(), InitBool, + InitBool->getName() + ".val", false, 0, LI->getOrdering(), LI->getSyncScopeID(), - LI->isUnordered() ? (Instruction*)ICI : LI); + LI->isUnordered() ? (Instruction *)ICI : LI); InitBoolUsed = true; switch (ICI->getPredicate()) { default: llvm_unreachable("Unknown ICmp Predicate!"); @@ -1040,7 +1041,8 @@ } // Insert a load from the global, and use it instead of the malloc. - Value *NL = new LoadInst(GV, GV->getName()+".val", InsertPt); + Value *NL = + new LoadInst(GV->getValueType(), GV, GV->getName() + ".val", InsertPt); U->replaceUsesOfWith(Alloc, NL); } } @@ -1163,10 +1165,10 @@ if (LoadInst *LI = dyn_cast(V)) { // This is a scalarized version of the load from the global. Just create // a new Load of the scalarized global. - Result = new LoadInst(GetHeapSROAValue(LI->getOperand(0), FieldNo, - InsertedScalarizedValues, - PHIsToRewrite), - LI->getName()+".f"+Twine(FieldNo), LI); + Value *V = GetHeapSROAValue(LI->getOperand(0), FieldNo, + InsertedScalarizedValues, PHIsToRewrite); + Result = new LoadInst(V->getType()->getPointerElementType(), V, + LI->getName() + ".f" + Twine(FieldNo), LI); } else { PHINode *PN = cast(V); // PN's type is pointer to struct. Make a new PHI of pointer to struct @@ -1356,7 +1358,9 @@ // Within the NullPtrBlock, we need to emit a comparison and branch for each // pointer, because some may be null while others are not. for (unsigned i = 0, e = FieldGlobals.size(); i != e; ++i) { - Value *GVVal = new LoadInst(FieldGlobals[i], "tmp", NullPtrBlock); + Value *GVVal = + new LoadInst(cast(FieldGlobals[i])->getValueType(), + FieldGlobals[i], "tmp", NullPtrBlock); Value *Cmp = new ICmpInst(*NullPtrBlock, ICmpInst::ICMP_NE, GVVal, Constant::getNullValue(GVVal->getType())); BasicBlock *FreeBlock = BasicBlock::Create(Cmp->getContext(), "free_it", @@ -1700,7 +1704,8 @@ if (LoadInst *LI = dyn_cast(StoredVal)) { assert(LI->getOperand(0) == GV && "Not a copy!"); // Insert a new load, to preserve the saved value. - StoreVal = new LoadInst(NewGV, LI->getName()+".b", false, 0, + StoreVal = new LoadInst(NewGV->getValueType(), NewGV, + LI->getName() + ".b", false, 0, LI->getOrdering(), LI->getSyncScopeID(), LI); } else { assert((isa(StoredVal) || isa(StoredVal)) && @@ -1716,8 +1721,9 @@ } else { // Change the load into a load of bool then a select. LoadInst *LI = cast(UI); - LoadInst *NLI = new LoadInst(NewGV, LI->getName()+".b", false, 0, - LI->getOrdering(), LI->getSyncScopeID(), LI); + LoadInst *NLI = + new LoadInst(NewGV->getValueType(), NewGV, LI->getName() + ".b", + false, 0, LI->getOrdering(), LI->getSyncScopeID(), LI); Instruction *NSI; if (IsOneZero) NSI = new ZExtInst(NLI, LI->getType(), "", LI); Index: llvm/lib/Transforms/IPO/LowerTypeTests.cpp =================================================================== --- llvm/lib/Transforms/IPO/LowerTypeTests.cpp +++ llvm/lib/Transforms/IPO/LowerTypeTests.cpp @@ -618,7 +618,7 @@ } Value *ByteAddr = B.CreateGEP(Int8Ty, ByteArray, BitOffset); - Value *Byte = B.CreateLoad(ByteAddr); + Value *Byte = B.CreateLoad(Int8Ty, ByteAddr); Value *ByteAndMask = B.CreateAnd(Byte, ConstantExpr::getPtrToInt(TIL.BitMask, Int8Ty)); Index: llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp =================================================================== --- llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp +++ llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp @@ -1183,7 +1183,7 @@ Value *Addr = B.CreateGEP(Int8Ty, B.CreateBitCast(Call.VTable, Int8PtrTy), Byte); if (RetType->getBitWidth() == 1) { - Value *Bits = B.CreateLoad(Addr); + Value *Bits = B.CreateLoad(Int8Ty, Addr); Value *BitsAndBit = B.CreateAnd(Bits, Bit); auto IsBitSet = B.CreateICmpNE(BitsAndBit, ConstantInt::get(Int8Ty, 0)); Call.replaceAndErase("virtual-const-prop-1-bit", FnName, RemarksEnabled, Index: llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp =================================================================== --- llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp +++ llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp @@ -172,7 +172,7 @@ Value *Src = Builder.CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy); Value *Dest = Builder.CreateBitCast(MI->getArgOperand(0), NewDstPtrTy); - LoadInst *L = Builder.CreateLoad(Src); + LoadInst *L = Builder.CreateLoad(IntType, Src); // Alignment from the mem intrinsic will be better, so use it. L->setAlignment(CopySrcAlign); if (CopyMD) @@ -1156,7 +1156,8 @@ if (maskIsAllOneOrUndef(II.getArgOperand(2))) { Value *LoadPtr = II.getArgOperand(0); unsigned Alignment = cast(II.getArgOperand(1))->getZExtValue(); - return Builder.CreateAlignedLoad(LoadPtr, Alignment, "unmaskedload"); + return Builder.CreateAlignedLoad(II.getType(), LoadPtr, Alignment, + "unmaskedload"); } return nullptr; @@ -1473,7 +1474,7 @@ auto *BCastInst = Builder.CreateBitCast(II.getArgOperand(0), PointerType::get(II.getType(), 0)); - return Builder.CreateAlignedLoad(BCastInst, Alignment); + return Builder.CreateAlignedLoad(II.getType(), BCastInst, Alignment); } // Returns true iff the 2 intrinsics have the same operands, limiting the @@ -2262,7 +2263,7 @@ &DT) >= 16) { Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0), PointerType::getUnqual(II->getType())); - return new LoadInst(Ptr); + return new LoadInst(II->getType(), Ptr); } break; case Intrinsic::ppc_vsx_lxvw4x: @@ -2270,7 +2271,7 @@ // Turn PPC VSX loads into normal loads. Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0), PointerType::getUnqual(II->getType())); - return new LoadInst(Ptr, Twine(""), false, 1); + return new LoadInst(II->getType(), Ptr, Twine(""), false, 1); } case Intrinsic::ppc_altivec_stvx: case Intrinsic::ppc_altivec_stvxl: @@ -2298,7 +2299,7 @@ II->getType()->getVectorNumElements()); Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0), PointerType::getUnqual(VTy)); - Value *Load = Builder.CreateLoad(Ptr); + Value *Load = Builder.CreateLoad(VTy, Ptr); return new FPExtInst(Load, II->getType()); } break; @@ -2308,7 +2309,7 @@ &DT) >= 32) { Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0), PointerType::getUnqual(II->getType())); - return new LoadInst(Ptr); + return new LoadInst(II->getType(), Ptr); } break; case Intrinsic::ppc_qpx_qvstfs: Index: llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp =================================================================== --- llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp +++ llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp @@ -298,7 +298,7 @@ if (auto *LT = dyn_cast(I)) { auto *V = getReplacement(LT->getPointerOperand()); assert(V && "Operand not replaced"); - auto *NewI = new LoadInst(V); + auto *NewI = new LoadInst(I->getType(), V); NewI->takeName(LT); IC.InsertNewInstWith(NewI, *LT); IC.replaceInstUsesWith(*LT, NewI); @@ -465,7 +465,7 @@ NewPtr = IC.Builder.CreateBitCast(Ptr, NewTy->getPointerTo(AS)); LoadInst *NewLoad = IC.Builder.CreateAlignedLoad( - NewPtr, LI.getAlignment(), LI.isVolatile(), LI.getName() + Suffix); + NewTy, NewPtr, LI.getAlignment(), LI.isVolatile(), LI.getName() + Suffix); NewLoad->setAtomic(LI.getOrdering(), LI.getSyncScopeID()); MDBuilder MDB(NewLoad->getContext()); for (const auto &MDPair : MD) { @@ -724,7 +724,8 @@ auto *Ptr = IC.Builder.CreateInBoundsGEP(ST, Addr, makeArrayRef(Indices), Name + ".elt"); auto EltAlign = MinAlign(Align, SL->getElementOffset(i)); - auto *L = IC.Builder.CreateAlignedLoad(Ptr, EltAlign, Name + ".unpack"); + auto *L = IC.Builder.CreateAlignedLoad(ST->getElementType(i), Ptr, + EltAlign, Name + ".unpack"); // Propagate AA metadata. It'll still be valid on the narrowed load. AAMDNodes AAMD; LI.getAAMetadata(AAMD); @@ -774,8 +775,8 @@ }; auto *Ptr = IC.Builder.CreateInBoundsGEP(AT, Addr, makeArrayRef(Indices), Name + ".elt"); - auto *L = IC.Builder.CreateAlignedLoad(Ptr, MinAlign(Align, Offset), - Name + ".unpack"); + auto *L = IC.Builder.CreateAlignedLoad( + AT->getElementType(), Ptr, MinAlign(Align, Offset), Name + ".unpack"); AAMDNodes AAMD; LI.getAAMetadata(AAMD); L->setAAMetadata(AAMD); @@ -1065,10 +1066,12 @@ unsigned Align = LI.getAlignment(); if (isSafeToLoadUnconditionally(SI->getOperand(1), Align, DL, SI) && isSafeToLoadUnconditionally(SI->getOperand(2), Align, DL, SI)) { - LoadInst *V1 = Builder.CreateLoad(SI->getOperand(1), - SI->getOperand(1)->getName()+".val"); - LoadInst *V2 = Builder.CreateLoad(SI->getOperand(2), - SI->getOperand(2)->getName()+".val"); + LoadInst *V1 = + Builder.CreateLoad(LI.getType(), SI->getOperand(1), + SI->getOperand(1)->getName() + ".val"); + LoadInst *V2 = + Builder.CreateLoad(LI.getType(), SI->getOperand(2), + SI->getOperand(2)->getName() + ".val"); assert(LI.isUnordered() && "implied by above"); V1->setAlignment(Align); V1->setAtomic(LI.getOrdering(), LI.getSyncScopeID()); Index: llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp =================================================================== --- llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp +++ llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp @@ -595,7 +595,8 @@ Value *InVal = FirstLI->getOperand(0); NewPN->addIncoming(InVal, PN.getIncomingBlock(0)); - LoadInst *NewLI = new LoadInst(NewPN, "", isVolatile, LoadAlignment); + LoadInst *NewLI = + new LoadInst(FirstLI->getType(), NewPN, "", isVolatile, LoadAlignment); unsigned KnownIDs[] = { LLVMContext::MD_tbaa, Index: llvm/lib/Transforms/InstCombine/InstructionCombining.cpp =================================================================== --- llvm/lib/Transforms/InstCombine/InstructionCombining.cpp +++ llvm/lib/Transforms/InstCombine/InstructionCombining.cpp @@ -2686,7 +2686,7 @@ Builder.SetInsertPoint(L); Value *GEP = Builder.CreateInBoundsGEP(L->getType(), L->getPointerOperand(), Indices); - Instruction *NL = Builder.CreateLoad(GEP); + Instruction *NL = Builder.CreateLoad(EV.getType(), GEP); // Whatever aliasing information we had for the orignal load must also // hold for the smaller load, so propagate the annotations. AAMDNodes Nodes; Index: llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp =================================================================== --- llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp +++ llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp @@ -949,8 +949,9 @@ DynamicAreaOffset); } - IRB.CreateCall(AsanAllocasUnpoisonFunc, - {IRB.CreateLoad(DynamicAllocaLayout), DynamicAreaPtr}); + IRB.CreateCall( + AsanAllocasUnpoisonFunc, + {IRB.CreateLoad(IntptrTy, DynamicAllocaLayout), DynamicAreaPtr}); } // Unpoison dynamic allocas redzones. @@ -1552,7 +1553,7 @@ Value *ShadowPtr = memToShadow(AddrLong, IRB); Value *CmpVal = Constant::getNullValue(ShadowTy); Value *ShadowValue = - IRB.CreateLoad(IRB.CreateIntToPtr(ShadowPtr, ShadowPtrTy)); + IRB.CreateLoad(ShadowTy, IRB.CreateIntToPtr(ShadowPtr, ShadowPtrTy)); Value *Cmp = IRB.CreateICmpNE(ShadowValue, CmpVal); size_t Granularity = 1ULL << Mapping.Scale; @@ -2444,7 +2445,7 @@ } else { Value *GlobalDynamicAddress = F.getParent()->getOrInsertGlobal( kAsanShadowMemoryDynamicAddress, IntptrTy); - LocalDynamicShadow = IRB.CreateLoad(GlobalDynamicAddress); + LocalDynamicShadow = IRB.CreateLoad(IntptrTy, GlobalDynamicAddress); } } @@ -2948,9 +2949,9 @@ // void *LocalStackBase = (FakeStack) ? FakeStack : alloca(LocalStackSize); Constant *OptionDetectUseAfterReturn = F.getParent()->getOrInsertGlobal( kAsanOptionDetectUseAfterReturn, IRB.getInt32Ty()); - Value *UseAfterReturnIsEnabled = - IRB.CreateICmpNE(IRB.CreateLoad(OptionDetectUseAfterReturn), - Constant::getNullValue(IRB.getInt32Ty())); + Value *UseAfterReturnIsEnabled = IRB.CreateICmpNE( + IRB.CreateLoad(IRB.getInt32Ty(), OptionDetectUseAfterReturn), + Constant::getNullValue(IRB.getInt32Ty())); Instruction *Term = SplitBlockAndInsertIfThen(UseAfterReturnIsEnabled, InsBefore, false); IRBuilder<> IRBIf(Term); @@ -3084,7 +3085,7 @@ FakeStack, ConstantInt::get(IntptrTy, ClassSize - ASan.LongSize / 8)); Value *SavedFlagPtr = IRBPoison.CreateLoad( - IRBPoison.CreateIntToPtr(SavedFlagPtrPtr, IntptrPtrTy)); + IntptrTy, IRBPoison.CreateIntToPtr(SavedFlagPtrPtr, IntptrPtrTy)); IRBPoison.CreateStore( Constant::getNullValue(IRBPoison.getInt8Ty()), IRBPoison.CreateIntToPtr(SavedFlagPtr, IRBPoison.getInt8PtrTy())); Index: llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp =================================================================== --- llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp +++ llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp @@ -1033,7 +1033,8 @@ DFS.ArgTLS ? &*F->getEntryBlock().begin() : cast(ArgTLSPtr)->getNextNode(); IRBuilder<> IRB(ArgTLSPos); - Shadow = IRB.CreateLoad(getArgTLS(A->getArgNo(), ArgTLSPos)); + Shadow = + IRB.CreateLoad(DFS.ShadowTy, getArgTLS(A->getArgNo(), ArgTLSPos)); break; } case DataFlowSanitizer::IA_Args: { @@ -1183,7 +1184,7 @@ const auto i = AllocaShadowMap.find(AI); if (i != AllocaShadowMap.end()) { IRBuilder<> IRB(Pos); - return IRB.CreateLoad(i->second); + return IRB.CreateLoad(DFS.ShadowTy, i->second); } } @@ -1208,7 +1209,7 @@ case 0: return DFS.ZeroShadow; case 1: { - LoadInst *LI = new LoadInst(ShadowAddr, "", Pos); + LoadInst *LI = new LoadInst(DFS.ShadowTy, ShadowAddr, "", Pos); LI->setAlignment(ShadowAlign); return LI; } @@ -1216,8 +1217,9 @@ IRBuilder<> IRB(Pos); Value *ShadowAddr1 = IRB.CreateGEP(DFS.ShadowTy, ShadowAddr, ConstantInt::get(DFS.IntptrTy, 1)); - return combineShadows(IRB.CreateAlignedLoad(ShadowAddr, ShadowAlign), - IRB.CreateAlignedLoad(ShadowAddr1, ShadowAlign), Pos); + return combineShadows( + IRB.CreateAlignedLoad(DFS.ShadowTy, ShadowAddr, ShadowAlign), + IRB.CreateAlignedLoad(DFS.ShadowTy, ShadowAddr1, ShadowAlign), Pos); } } if (!AvoidNewBlocks && Size % (64 / DFS.ShadowWidth) == 0) { @@ -1236,7 +1238,8 @@ IRBuilder<> IRB(Pos); Value *WideAddr = IRB.CreateBitCast(ShadowAddr, Type::getInt64PtrTy(*DFS.Ctx)); - Value *WideShadow = IRB.CreateAlignedLoad(WideAddr, ShadowAlign); + Value *WideShadow = + IRB.CreateAlignedLoad(IRB.getInt64Ty(), WideAddr, ShadowAlign); Value *TruncShadow = IRB.CreateTrunc(WideShadow, DFS.ShadowTy); Value *ShlShadow = IRB.CreateShl(WideShadow, DFS.ShadowWidth); Value *ShrShadow = IRB.CreateLShr(WideShadow, 64 - DFS.ShadowWidth); @@ -1269,7 +1272,8 @@ IRBuilder<> NextIRB(NextBB); WideAddr = NextIRB.CreateGEP(Type::getInt64Ty(*DFS.Ctx), WideAddr, ConstantInt::get(DFS.IntptrTy, 1)); - Value *NextWideShadow = NextIRB.CreateAlignedLoad(WideAddr, ShadowAlign); + Value *NextWideShadow = NextIRB.CreateAlignedLoad(NextIRB.getInt64Ty(), + WideAddr, ShadowAlign); ShadowsEq = NextIRB.CreateICmpEQ(WideShadow, NextWideShadow); LastBr->setSuccessor(0, NextBB); LastBr = NextIRB.CreateCondBr(ShadowsEq, FallbackBB, FallbackBB); @@ -1646,7 +1650,8 @@ } if (!FT->getReturnType()->isVoidTy()) { - LoadInst *LabelLoad = IRB.CreateLoad(DFSF.LabelReturnAlloca); + LoadInst *LabelLoad = + IRB.CreateLoad(DFSF.DFS.ShadowTy, DFSF.LabelReturnAlloca); DFSF.setShadow(CustomCI, LabelLoad); } @@ -1684,7 +1689,7 @@ if (DFSF.DFS.getInstrumentedABI() == DataFlowSanitizer::IA_TLS) { IRBuilder<> NextIRB(Next); - LoadInst *LI = NextIRB.CreateLoad(DFSF.getRetvalTLS()); + LoadInst *LI = NextIRB.CreateLoad(DFSF.DFS.ShadowTy, DFSF.getRetvalTLS()); DFSF.SkipInsts.insert(LI); DFSF.setShadow(CS.getInstruction(), LI); DFSF.NonZeroChecks.push_back(LI); Index: llvm/lib/Transforms/Instrumentation/EfficiencySanitizer.cpp =================================================================== --- llvm/lib/Transforms/Instrumentation/EfficiencySanitizer.cpp +++ llvm/lib/Transforms/Instrumentation/EfficiencySanitizer.cpp @@ -790,7 +790,7 @@ ConstantExpr::getGetElementPtr( ArrayType::get(IRB.getInt64Ty(), getStructCounterSize(StructTy)), CounterArray, Indices); - Value *Load = IRB.CreateLoad(Counter); + Value *Load = IRB.CreateLoad(IRB.getInt64Ty(), Counter); IRB.CreateStore(IRB.CreateAdd(Load, ConstantInt::get(IRB.getInt64Ty(), 1)), Counter); return true; @@ -875,7 +875,8 @@ // memory access, if they are not already set. Value *ValueMask = ConstantInt::get(ShadowTy, 0x81); // 10000001B - Value *OldValue = IRB.CreateLoad(IRB.CreateIntToPtr(ShadowPtr, ShadowPtrTy)); + Value *OldValue = + IRB.CreateLoad(ShadowTy, IRB.CreateIntToPtr(ShadowPtr, ShadowPtrTy)); // The AND and CMP will be turned into a TEST instruction by the compiler. Value *Cmp = IRB.CreateICmpNE(IRB.CreateAnd(OldValue, ValueMask), ValueMask); Instruction *CmpTerm = SplitBlockAndInsertIfThen(Cmp, I, false); Index: llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp =================================================================== --- llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp +++ llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp @@ -817,7 +817,7 @@ // Skip phis, landingpads. IRBuilder<> Builder(&*BB.getFirstInsertionPt()); - Value *Count = Builder.CreateLoad(Phi); + Value *Count = Builder.CreateLoad(Builder.getInt64Ty(), Phi); Count = Builder.CreateAdd(Count, Builder.getInt64(1)); Builder.CreateStore(Count, Phi); @@ -828,7 +828,7 @@ const unsigned Edge = It->second; Value *Counter = Builder.CreateConstInBoundsGEP2_64(Counters, 0, Edge); - Value *Count = Builder.CreateLoad(Counter); + Value *Count = Builder.CreateLoad(Builder.getInt64Ty(), Counter); Count = Builder.CreateAdd(Count, Builder.getInt64(1)); Builder.CreateStore(Count, Counter); } @@ -1089,17 +1089,20 @@ auto *StartFileCallArgsPtr = Builder.CreateStructGEP(FileInfoPtr, 0); auto *StartFileCall = Builder.CreateCall( StartFile, - {Builder.CreateLoad(Builder.CreateStructGEP(StartFileCallArgsPtr, 0)), - Builder.CreateLoad(Builder.CreateStructGEP(StartFileCallArgsPtr, 1)), - Builder.CreateLoad(Builder.CreateStructGEP(StartFileCallArgsPtr, 2))}); + {Builder.CreateLoad(StartFileCallArgsTy->getElementType(0), + Builder.CreateStructGEP(StartFileCallArgsPtr, 0)), + Builder.CreateLoad(StartFileCallArgsTy->getElementType(1), + Builder.CreateStructGEP(StartFileCallArgsPtr, 1)), + Builder.CreateLoad(StartFileCallArgsTy->getElementType(2), + Builder.CreateStructGEP(StartFileCallArgsPtr, 2))}); if (auto AK = TLI->getExtAttrForI32Param(false)) StartFileCall->addParamAttr(2, AK); - auto *NumCounters = - Builder.CreateLoad(Builder.CreateStructGEP(FileInfoPtr, 1)); - auto *EmitFunctionCallArgsArray = - Builder.CreateLoad(Builder.CreateStructGEP(FileInfoPtr, 2)); - auto *EmitArcsCallArgsArray = - Builder.CreateLoad(Builder.CreateStructGEP(FileInfoPtr, 3)); + auto *NumCounters = Builder.CreateLoad( + FileInfoTy->getElementType(1), Builder.CreateStructGEP(FileInfoPtr, 1)); + auto *EmitFunctionCallArgsArray = Builder.CreateLoad( + FileInfoTy->getElementType(2), Builder.CreateStructGEP(FileInfoPtr, 2)); + auto *EmitArcsCallArgsArray = Builder.CreateLoad( + FileInfoTy->getElementType(3), Builder.CreateStructGEP(FileInfoPtr, 3)); auto *EnterCounterLoopCond = Builder.CreateICmpSLT(Builder.getInt32(0), NumCounters); Builder.CreateCondBr(EnterCounterLoopCond, CounterLoopHeader, FileLoopLatch); @@ -1111,11 +1114,16 @@ Builder.CreateInBoundsGEP(EmitFunctionCallArgsArray, {JV}); auto *EmitFunctionCall = Builder.CreateCall( EmitFunction, - {Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 0)), - Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 1)), - Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 2)), - Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 3)), + {Builder.CreateLoad(EmitFunctionCallArgsTy->getElementType(0), + Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 0)), + Builder.CreateLoad(EmitFunctionCallArgsTy->getElementType(1), + Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 1)), + Builder.CreateLoad(EmitFunctionCallArgsTy->getElementType(2), + Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 2)), + Builder.CreateLoad(EmitFunctionCallArgsTy->getElementType(3), + Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 3)), Builder.CreateLoad( + EmitFunctionCallArgsTy->getElementType(4), Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 4))}); if (auto AK = TLI->getExtAttrForI32Param(false)) { EmitFunctionCall->addParamAttr(0, AK); @@ -1127,8 +1135,10 @@ Builder.CreateInBoundsGEP(EmitArcsCallArgsArray, {JV}); auto *EmitArcsCall = Builder.CreateCall( EmitArcs, - {Builder.CreateLoad(Builder.CreateStructGEP(EmitArcsCallArgsPtr, 0)), - Builder.CreateLoad(Builder.CreateStructGEP(EmitArcsCallArgsPtr, 1))}); + {Builder.CreateLoad(EmitArcsCallArgsTy->getElementType(0), + Builder.CreateStructGEP(EmitArcsCallArgsPtr, 0)), + Builder.CreateLoad(EmitArcsCallArgsTy->getElementType(1), + Builder.CreateStructGEP(EmitArcsCallArgsPtr, 1))}); if (auto AK = TLI->getExtAttrForI32Param(false)) EmitArcsCall->addParamAttr(0, AK); auto *NextJV = Builder.CreateAdd(JV, Builder.getInt32(1)); Index: llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp =================================================================== --- llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp +++ llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp @@ -428,7 +428,7 @@ Value *GlobalDynamicAddress = IRB.GetInsertBlock()->getParent()->getParent()->getOrInsertGlobal( kHwasanShadowMemoryDynamicAddress, Int8PtrTy); - return IRB.CreateLoad(GlobalDynamicAddress); + return IRB.CreateLoad(Int8PtrTy, GlobalDynamicAddress); } } @@ -557,7 +557,7 @@ IRB.getInt8Ty()); Value *AddrLong = untagPointer(IRB, PtrLong); Value *Shadow = memToShadow(AddrLong, IRB); - Value *MemTag = IRB.CreateLoad(Shadow); + Value *MemTag = IRB.CreateLoad(Int8Ty, Shadow); Value *TagMismatch = IRB.CreateICmpNE(PtrTag, MemTag); int matchAllTag = ClMatchAllTag.getNumOccurrences() > 0 ? @@ -841,7 +841,7 @@ Value *SlotPtr = getHwasanThreadSlotPtr(IRB, IntptrTy); assert(SlotPtr); - Instruction *ThreadLong = IRB.CreateLoad(SlotPtr); + Instruction *ThreadLong = IRB.CreateLoad(IntptrTy, SlotPtr); Function *F = IRB.GetInsertBlock()->getParent(); if (F->getFnAttribute("hwasan-abi").getValueAsString() == "interceptor") { @@ -855,7 +855,7 @@ // FIXME: This should call a new runtime function with a custom calling // convention to avoid needing to spill all arguments here. IRB.CreateCall(HwasanThreadEnterFunc); - LoadInst *ReloadThreadLong = IRB.CreateLoad(SlotPtr); + LoadInst *ReloadThreadLong = IRB.CreateLoad(IntptrTy, SlotPtr); IRB.SetInsertPoint(&*Br->getSuccessor(0)->begin()); PHINode *ThreadLongPhi = IRB.CreatePHI(IntptrTy, 2); Index: llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp =================================================================== --- llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp +++ llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp @@ -195,6 +195,7 @@ // block. Value *LiveInValue = SSA.GetValueInMiddleOfBlock(ExitBlock); Value *Addr = cast(Store)->getPointerOperand(); + Type *Ty = LiveInValue->getType(); IRBuilder<> Builder(InsertPos); if (AtomicCounterUpdatePromoted) // automic update currently can only be promoted across the current @@ -202,7 +203,7 @@ Builder.CreateAtomicRMW(AtomicRMWInst::Add, Addr, LiveInValue, AtomicOrdering::SequentiallyConsistent); else { - LoadInst *OldVal = Builder.CreateLoad(Addr, "pgocount.promoted"); + LoadInst *OldVal = Builder.CreateLoad(Ty, Addr, "pgocount.promoted"); auto *NewVal = Builder.CreateAdd(OldVal, LiveInValue); auto *NewStore = Builder.CreateStore(NewVal, Addr); @@ -603,7 +604,8 @@ Builder.CreateAtomicRMW(AtomicRMWInst::Add, Addr, Inc->getStep(), AtomicOrdering::Monotonic); } else { - Value *Load = Builder.CreateLoad(Addr, "pgocount"); + Value *IncStep = Inc->getStep(); + Value *Load = Builder.CreateLoad(IncStep->getType(), Addr, "pgocount"); auto *Count = Builder.CreateAdd(Load, Inc->getStep()); auto *Store = Builder.CreateStore(Count, Addr); if (isCounterPromotionEnabled()) @@ -950,7 +952,7 @@ User->setComdat(M->getOrInsertComdat(User->getName())); IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", User)); - auto *Load = IRB.CreateLoad(Var); + auto *Load = IRB.CreateLoad(Int32Ty, Var); IRB.CreateRet(Load); // Mark the user variable as used so that it isn't stripped out. Index: llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp =================================================================== --- llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp +++ llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp @@ -1401,7 +1401,7 @@ IRB.CreateAnd(OriginLong, ConstantInt::get(MS.IntptrTy, ~Mask)); } OriginPtr = - IRB.CreateIntToPtr(OriginLong, PointerType::get(IRB.getInt32Ty(), 0)); + IRB.CreateIntToPtr(OriginLong, PointerType::get(MS.OriginTy, 0)); } return std::make_pair(ShadowPtr, OriginPtr); } @@ -1618,8 +1618,8 @@ // ParamTLS overflow. *ShadowPtr = getCleanShadow(V); } else { - *ShadowPtr = - EntryIRB.CreateAlignedLoad(Base, kShadowTLSAlignment); + *ShadowPtr = EntryIRB.CreateAlignedLoad(getShadowTy(&FArg), Base, + kShadowTLSAlignment); } } LLVM_DEBUG(dbgs() @@ -1627,7 +1627,7 @@ if (MS.TrackOrigins && !Overflow) { Value *OriginPtr = getOriginPtrForArgument(&FArg, EntryIRB, ArgOffset); - setOrigin(A, EntryIRB.CreateLoad(OriginPtr)); + setOrigin(A, EntryIRB.CreateLoad(MS.OriginTy, OriginPtr)); } else { setOrigin(A, getCleanOrigin()); } @@ -1758,7 +1758,8 @@ if (PropagateShadow) { std::tie(ShadowPtr, OriginPtr) = getShadowOriginPtr(Addr, IRB, ShadowTy, Alignment, /*isStore*/ false); - setShadow(&I, IRB.CreateAlignedLoad(ShadowPtr, Alignment, "_msld")); + setShadow(&I, + IRB.CreateAlignedLoad(ShadowTy, ShadowPtr, Alignment, "_msld")); } else { setShadow(&I, getCleanShadow(&I)); } @@ -1772,7 +1773,8 @@ if (MS.TrackOrigins) { if (PropagateShadow) { unsigned OriginAlignment = std::max(kMinOriginAlignment, Alignment); - setOrigin(&I, IRB.CreateAlignedLoad(OriginPtr, OriginAlignment)); + setOrigin( + &I, IRB.CreateAlignedLoad(MS.OriginTy, OriginPtr, OriginAlignment)); } else { setOrigin(&I, getCleanOrigin()); } @@ -2452,7 +2454,8 @@ unsigned Alignment = 1; std::tie(ShadowPtr, OriginPtr) = getShadowOriginPtr(Addr, IRB, ShadowTy, Alignment, /*isStore*/ false); - setShadow(&I, IRB.CreateAlignedLoad(ShadowPtr, Alignment, "_msld")); + setShadow(&I, + IRB.CreateAlignedLoad(ShadowTy, ShadowPtr, Alignment, "_msld")); } else { setShadow(&I, getCleanShadow(&I)); } @@ -2462,7 +2465,7 @@ if (MS.TrackOrigins) { if (PropagateShadow) - setOrigin(&I, IRB.CreateLoad(OriginPtr)); + setOrigin(&I, IRB.CreateLoad(MS.OriginTy, OriginPtr)); else setOrigin(&I, getCleanOrigin()); } @@ -2845,9 +2848,9 @@ if (ClCheckAccessAddress) insertShadowCheck(Addr, &I); - Value *Shadow = IRB.CreateAlignedLoad(ShadowPtr, Alignment, "_ldmxcsr"); - Value *Origin = - MS.TrackOrigins ? IRB.CreateLoad(OriginPtr) : getCleanOrigin(); + Value *Shadow = IRB.CreateAlignedLoad(Ty, ShadowPtr, Alignment, "_ldmxcsr"); + Value *Origin = MS.TrackOrigins ? IRB.CreateLoad(MS.OriginTy, OriginPtr) + : getCleanOrigin(); insertShadowCheck(Shadow, Origin, &I); } @@ -2921,7 +2924,7 @@ Value *Origin = IRB.CreateSelect( IRB.CreateICmpNE(Acc, Constant::getNullValue(Acc->getType())), - getOrigin(PassThru), IRB.CreateLoad(OriginPtr)); + getOrigin(PassThru), IRB.CreateLoad(MS.OriginTy, OriginPtr)); setOrigin(&I, Origin); } else { @@ -3284,12 +3287,13 @@ "Could not find insertion point for retval shadow load"); } IRBuilder<> IRBAfter(&*NextInsn); - Value *RetvalShadow = - IRBAfter.CreateAlignedLoad(getShadowPtrForRetval(&I, IRBAfter), - kShadowTLSAlignment, "_msret"); + Value *RetvalShadow = IRBAfter.CreateAlignedLoad( + getShadowTy(&I), getShadowPtrForRetval(&I, IRBAfter), + kShadowTLSAlignment, "_msret"); setShadow(&I, RetvalShadow); if (MS.TrackOrigins) - setOrigin(&I, IRBAfter.CreateLoad(getOriginPtrForRetval(IRBAfter))); + setOrigin(&I, IRBAfter.CreateLoad(MS.OriginTy, + getOriginPtrForRetval(IRBAfter))); } bool isAMustTailRetVal(Value *RetVal) { @@ -3837,7 +3841,8 @@ // If there is a va_start in this function, make a backup copy of // va_arg_tls somewhere in the function entry block. IRBuilder<> IRB(MSV.ActualFnStart->getFirstNonPHI()); - VAArgOverflowSize = IRB.CreateLoad(MS.VAArgOverflowSizeTLS); + VAArgOverflowSize = + IRB.CreateLoad(IRB.getInt64Ty(), MS.VAArgOverflowSizeTLS); Value *CopySize = IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, AMD64FpEndOffset), VAArgOverflowSize); @@ -3856,11 +3861,13 @@ IRBuilder<> IRB(OrigInst->getNextNode()); Value *VAListTag = OrigInst->getArgOperand(0); + Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C); Value *RegSaveAreaPtrPtr = IRB.CreateIntToPtr( IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), ConstantInt::get(MS.IntptrTy, 16)), - PointerType::get(Type::getInt64PtrTy(*MS.C), 0)); - Value *RegSaveAreaPtr = IRB.CreateLoad(RegSaveAreaPtrPtr); + PointerType::get(RegSaveAreaPtrTy, 0)); + Value *RegSaveAreaPtr = + IRB.CreateLoad(RegSaveAreaPtrTy, RegSaveAreaPtrPtr); Value *RegSaveAreaShadowPtr, *RegSaveAreaOriginPtr; unsigned Alignment = 16; std::tie(RegSaveAreaShadowPtr, RegSaveAreaOriginPtr) = @@ -3871,11 +3878,13 @@ if (MS.TrackOrigins) IRB.CreateMemCpy(RegSaveAreaOriginPtr, Alignment, VAArgTLSOriginCopy, Alignment, AMD64FpEndOffset); + Type *OverflowArgAreaPtrTy = Type::getInt64PtrTy(*MS.C); Value *OverflowArgAreaPtrPtr = IRB.CreateIntToPtr( IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), ConstantInt::get(MS.IntptrTy, 8)), - PointerType::get(Type::getInt64PtrTy(*MS.C), 0)); - Value *OverflowArgAreaPtr = IRB.CreateLoad(OverflowArgAreaPtrPtr); + PointerType::get(OverflowArgAreaPtrTy, 0)); + Value *OverflowArgAreaPtr = + IRB.CreateLoad(OverflowArgAreaPtrTy, OverflowArgAreaPtrPtr); Value *OverflowArgAreaShadowPtr, *OverflowArgAreaOriginPtr; std::tie(OverflowArgAreaShadowPtr, OverflowArgAreaOriginPtr) = MSV.getShadowOriginPtr(OverflowArgAreaPtr, IRB, IRB.getInt8Ty(), @@ -3977,7 +3986,7 @@ assert(!VAArgSize && !VAArgTLSCopy && "finalizeInstrumentation called twice"); IRBuilder<> IRB(MSV.ActualFnStart->getFirstNonPHI()); - VAArgSize = IRB.CreateLoad(MS.VAArgOverflowSizeTLS); + VAArgSize = IRB.CreateLoad(IRB.getInt64Ty(), MS.VAArgOverflowSizeTLS); Value *CopySize = IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, 0), VAArgSize); @@ -3994,10 +4003,12 @@ CallInst *OrigInst = VAStartInstrumentationList[i]; IRBuilder<> IRB(OrigInst->getNextNode()); Value *VAListTag = OrigInst->getArgOperand(0); + Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C); Value *RegSaveAreaPtrPtr = IRB.CreateIntToPtr(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), - PointerType::get(Type::getInt64PtrTy(*MS.C), 0)); - Value *RegSaveAreaPtr = IRB.CreateLoad(RegSaveAreaPtrPtr); + PointerType::get(RegSaveAreaPtrTy, 0)); + Value *RegSaveAreaPtr = + IRB.CreateLoad(RegSaveAreaPtrTy, RegSaveAreaPtrPtr); Value *RegSaveAreaShadowPtr, *RegSaveAreaOriginPtr; unsigned Alignment = 8; std::tie(RegSaveAreaShadowPtr, RegSaveAreaOriginPtr) = @@ -4147,7 +4158,7 @@ IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), ConstantInt::get(MS.IntptrTy, offset)), Type::getInt64PtrTy(*MS.C)); - return IRB.CreateLoad(SaveAreaPtrPtr); + return IRB.CreateLoad(Type::getInt64Ty(*MS.C), SaveAreaPtrPtr); } // Retrieve a va_list field of 'int' size. @@ -4157,7 +4168,7 @@ IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), ConstantInt::get(MS.IntptrTy, offset)), Type::getInt32PtrTy(*MS.C)); - Value *SaveArea32 = IRB.CreateLoad(SaveAreaPtr); + Value *SaveArea32 = IRB.CreateLoad(IRB.getInt32Ty(), SaveAreaPtr); return IRB.CreateSExt(SaveArea32, MS.IntptrTy); } @@ -4168,7 +4179,8 @@ // If there is a va_start in this function, make a backup copy of // va_arg_tls somewhere in the function entry block. IRBuilder<> IRB(MSV.ActualFnStart->getFirstNonPHI()); - VAArgOverflowSize = IRB.CreateLoad(MS.VAArgOverflowSizeTLS); + VAArgOverflowSize = + IRB.CreateLoad(IRB.getInt64Ty(), MS.VAArgOverflowSizeTLS); Value *CopySize = IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, AArch64VAEndOffset), VAArgOverflowSize); @@ -4411,7 +4423,7 @@ assert(!VAArgSize && !VAArgTLSCopy && "finalizeInstrumentation called twice"); IRBuilder<> IRB(MSV.ActualFnStart->getFirstNonPHI()); - VAArgSize = IRB.CreateLoad(MS.VAArgOverflowSizeTLS); + VAArgSize = IRB.CreateLoad(IRB.getInt64Ty(), MS.VAArgOverflowSizeTLS); Value *CopySize = IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, 0), VAArgSize); @@ -4428,10 +4440,12 @@ CallInst *OrigInst = VAStartInstrumentationList[i]; IRBuilder<> IRB(OrigInst->getNextNode()); Value *VAListTag = OrigInst->getArgOperand(0); + Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C); Value *RegSaveAreaPtrPtr = IRB.CreateIntToPtr(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), - PointerType::get(Type::getInt64PtrTy(*MS.C), 0)); - Value *RegSaveAreaPtr = IRB.CreateLoad(RegSaveAreaPtrPtr); + PointerType::get(RegSaveAreaPtrTy, 0)); + Value *RegSaveAreaPtr = + IRB.CreateLoad(RegSaveAreaPtrTy, RegSaveAreaPtrPtr); Value *RegSaveAreaShadowPtr, *RegSaveAreaOriginPtr; unsigned Alignment = 8; std::tie(RegSaveAreaShadowPtr, RegSaveAreaOriginPtr) = Index: llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp =================================================================== --- llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp +++ llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp @@ -790,7 +790,7 @@ auto CounterPtr = IRB.CreateGEP( Function8bitCounterArray, {ConstantInt::get(IntptrTy, 0), ConstantInt::get(IntptrTy, Idx)}); - auto Load = IRB.CreateLoad(CounterPtr); + auto Load = IRB.CreateLoad(Int8Ty, CounterPtr); auto Inc = IRB.CreateAdd(Load, ConstantInt::get(Int8Ty, 1)); auto Store = IRB.CreateStore(Inc, CounterPtr); SetNoSanitizeMetadata(Load); @@ -803,7 +803,7 @@ auto FrameAddrPtr = IRB.CreateCall(GetFrameAddr, {Constant::getNullValue(Int32Ty)}); auto FrameAddrInt = IRB.CreatePtrToInt(FrameAddrPtr, IntptrTy); - auto LowestStack = IRB.CreateLoad(SanCovLowestStack); + auto LowestStack = IRB.CreateLoad(IntptrTy, SanCovLowestStack); auto IsStackLower = IRB.CreateICmpULT(FrameAddrInt, LowestStack); auto ThenTerm = SplitBlockAndInsertIfThen(IsStackLower, &*IP, false); IRBuilder<> ThenIRB(ThenTerm); Index: llvm/lib/Transforms/Scalar/GVN.cpp =================================================================== --- llvm/lib/Transforms/Scalar/GVN.cpp +++ llvm/lib/Transforms/Scalar/GVN.cpp @@ -1234,10 +1234,10 @@ BasicBlock *UnavailablePred = PredLoad.first; Value *LoadPtr = PredLoad.second; - auto *NewLoad = new LoadInst(LoadPtr, LI->getName()+".pre", - LI->isVolatile(), LI->getAlignment(), - LI->getOrdering(), LI->getSyncScopeID(), - UnavailablePred->getTerminator()); + auto *NewLoad = + new LoadInst(LI->getType(), LoadPtr, LI->getName() + ".pre", + LI->isVolatile(), LI->getAlignment(), LI->getOrdering(), + LI->getSyncScopeID(), UnavailablePred->getTerminator()); NewLoad->setDebugLoc(LI->getDebugLoc()); // Transfer the old load's AA tags to the new load. Index: llvm/lib/Transforms/Scalar/JumpThreading.cpp =================================================================== --- llvm/lib/Transforms/Scalar/JumpThreading.cpp +++ llvm/lib/Transforms/Scalar/JumpThreading.cpp @@ -1445,11 +1445,11 @@ if (UnavailablePred) { assert(UnavailablePred->getTerminator()->getNumSuccessors() == 1 && "Can't handle critical edge here!"); - LoadInst *NewVal = - new LoadInst(LoadedPtr->DoPHITranslation(LoadBB, UnavailablePred), - LoadI->getName() + ".pr", false, LoadI->getAlignment(), - LoadI->getOrdering(), LoadI->getSyncScopeID(), - UnavailablePred->getTerminator()); + LoadInst *NewVal = new LoadInst( + LoadI->getType(), LoadedPtr->DoPHITranslation(LoadBB, UnavailablePred), + LoadI->getName() + ".pr", false, LoadI->getAlignment(), + LoadI->getOrdering(), LoadI->getSyncScopeID(), + UnavailablePred->getTerminator()); NewVal->setDebugLoc(LoadI->getDebugLoc()); if (AATags) NewVal->setAAMetadata(AATags); Index: llvm/lib/Transforms/Scalar/LICM.cpp =================================================================== --- llvm/lib/Transforms/Scalar/LICM.cpp +++ llvm/lib/Transforms/Scalar/LICM.cpp @@ -1947,7 +1947,8 @@ // Set up the preheader to have a definition of the value. It is the live-out // value from the preheader that uses in the loop will use. LoadInst *PreheaderLoad = new LoadInst( - SomePtr, SomePtr->getName() + ".promoted", Preheader->getTerminator()); + SomePtr->getType()->getPointerElementType(), SomePtr, + SomePtr->getName() + ".promoted", Preheader->getTerminator()); if (SawUnorderedAtomic) PreheaderLoad->setOrdering(AtomicOrdering::Unordered); PreheaderLoad->setAlignment(Alignment); Index: llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp =================================================================== --- llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp +++ llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp @@ -427,9 +427,9 @@ auto *PH = L->getLoopPreheader(); Value *InitialPtr = SEE.expandCodeFor(PtrSCEV->getStart(), Ptr->getType(), PH->getTerminator()); - Value *Initial = - new LoadInst(InitialPtr, "load_initial", /* isVolatile */ false, - Cand.Load->getAlignment(), PH->getTerminator()); + Value *Initial = new LoadInst( + Cand.Load->getType(), InitialPtr, "load_initial", + /* isVolatile */ false, Cand.Load->getAlignment(), PH->getTerminator()); PHINode *PHI = PHINode::Create(Initial->getType(), 2, "store_forwarded", &L->getHeader()->front()); Index: llvm/lib/Transforms/Scalar/LowerAtomic.cpp =================================================================== --- llvm/lib/Transforms/Scalar/LowerAtomic.cpp +++ llvm/lib/Transforms/Scalar/LowerAtomic.cpp @@ -26,7 +26,7 @@ Value *Cmp = CXI->getCompareOperand(); Value *Val = CXI->getNewValOperand(); - LoadInst *Orig = Builder.CreateLoad(Ptr); + LoadInst *Orig = Builder.CreateLoad(Val->getType(), Ptr); Value *Equal = Builder.CreateICmpEQ(Orig, Cmp); Value *Res = Builder.CreateSelect(Equal, Val, Orig); Builder.CreateStore(Res, Ptr); @@ -44,7 +44,7 @@ Value *Ptr = RMWI->getPointerOperand(); Value *Val = RMWI->getValOperand(); - LoadInst *Orig = Builder.CreateLoad(Ptr); + LoadInst *Orig = Builder.CreateLoad(Val->getType(), Ptr); Value *Res = nullptr; switch (RMWI->getOperation()) { Index: llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp =================================================================== --- llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp +++ llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp @@ -1636,7 +1636,7 @@ // for sanity checking. static void insertRelocationStores(iterator_range GCRelocs, - DenseMap &AllocaMap, + DenseMap &AllocaMap, DenseSet &VisitedLiveValues) { for (User *U : GCRelocs) { GCRelocateInst *Relocate = dyn_cast(U); @@ -1671,7 +1671,7 @@ // "insertRelocationStores" but works for rematerialized values. static void insertRematerializationStores( const RematerializedValueMapTy &RematerializedValues, - DenseMap &AllocaMap, + DenseMap &AllocaMap, DenseSet &VisitedLiveValues) { for (auto RematerializedValuePair: RematerializedValues) { Instruction *RematerializedValue = RematerializedValuePair.first; @@ -1704,7 +1704,7 @@ #endif // TODO-PERF: change data structures, reserve - DenseMap AllocaMap; + DenseMap AllocaMap; SmallVector PromotableAllocas; // Used later to chack that we have enough allocas to store all values std::size_t NumRematerializedValues = 0; @@ -1774,7 +1774,7 @@ SmallVector ToClobber; for (auto Pair : AllocaMap) { Value *Def = Pair.first; - AllocaInst *Alloca = cast(Pair.second); + AllocaInst *Alloca = Pair.second; // This value was relocated if (VisitedLiveValues.count(Def)) { @@ -1806,7 +1806,7 @@ // Update use with load allocas and add store for gc_relocated. for (auto Pair : AllocaMap) { Value *Def = Pair.first; - Value *Alloca = Pair.second; + AllocaInst *Alloca = Pair.second; // We pre-record the uses of allocas so that we dont have to worry about // later update that changes the user information.. @@ -1834,13 +1834,15 @@ PHINode *Phi = cast(Use); for (unsigned i = 0; i < Phi->getNumIncomingValues(); i++) { if (Def == Phi->getIncomingValue(i)) { - LoadInst *Load = new LoadInst( - Alloca, "", Phi->getIncomingBlock(i)->getTerminator()); + LoadInst *Load = + new LoadInst(Alloca->getAllocatedType(), Alloca, "", + Phi->getIncomingBlock(i)->getTerminator()); Phi->setIncomingValue(i, Load); } } } else { - LoadInst *Load = new LoadInst(Alloca, "", Use); + LoadInst *Load = + new LoadInst(Alloca->getAllocatedType(), Alloca, "", Use); Use->replaceUsesOfWith(Def, Load); } } Index: llvm/lib/Transforms/Scalar/SROA.cpp =================================================================== --- llvm/lib/Transforms/Scalar/SROA.cpp +++ llvm/lib/Transforms/Scalar/SROA.cpp @@ -1231,15 +1231,14 @@ static void speculatePHINodeLoads(PHINode &PN) { LLVM_DEBUG(dbgs() << " original: " << PN << "\n"); - Type *LoadTy = cast(PN.getType())->getElementType(); + LoadInst *SomeLoad = cast(PN.user_back()); + Type *LoadTy = SomeLoad->getType(); IRBuilderTy PHIBuilder(&PN); PHINode *NewPN = PHIBuilder.CreatePHI(LoadTy, PN.getNumIncomingValues(), PN.getName() + ".sroa.speculated"); // Get the AA tags and alignment to use from one of the loads. It doesn't // matter which one we get and if any differ. - LoadInst *SomeLoad = cast(PN.user_back()); - AAMDNodes AATags; SomeLoad->getAAMetadata(AATags); unsigned Align = SomeLoad->getAlignment(); @@ -1270,7 +1269,8 @@ IRBuilderTy PredBuilder(TI); LoadInst *Load = PredBuilder.CreateLoad( - InVal, (PN.getName() + ".sroa.speculate.load." + Pred->getName())); + LoadTy, InVal, + (PN.getName() + ".sroa.speculate.load." + Pred->getName())); ++NumLoadsSpeculated; Load->setAlignment(Align); if (AATags) @@ -1330,10 +1330,10 @@ assert(LI->isSimple() && "We only speculate simple loads"); IRB.SetInsertPoint(LI); - LoadInst *TL = - IRB.CreateLoad(TV, LI->getName() + ".sroa.speculate.load.true"); - LoadInst *FL = - IRB.CreateLoad(FV, LI->getName() + ".sroa.speculate.load.false"); + LoadInst *TL = IRB.CreateLoad(LI->getType(), TV, + LI->getName() + ".sroa.speculate.load.true"); + LoadInst *FL = IRB.CreateLoad(LI->getType(), FV, + LI->getName() + ".sroa.speculate.load.false"); NumLoadsSpeculated += 2; // Transfer alignment and AA info if present. @@ -2410,14 +2410,16 @@ unsigned EndIndex = getIndex(NewEndOffset); assert(EndIndex > BeginIndex && "Empty vector!"); - Value *V = IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "load"); + Value *V = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "load"); return extractVector(IRB, V, BeginIndex, EndIndex, "vec"); } Value *rewriteIntegerLoad(LoadInst &LI) { assert(IntTy && "We cannot insert an integer to the alloca"); assert(!LI.isVolatile()); - Value *V = IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "load"); + Value *V = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "load"); V = convertValue(DL, IRB, V, IntTy); assert(NewBeginOffset >= NewAllocaBeginOffset && "Out of bounds offset"); uint64_t Offset = NewBeginOffset - NewAllocaBeginOffset; @@ -2461,7 +2463,8 @@ (canConvertValue(DL, NewAllocaTy, TargetTy) || (IsLoadPastEnd && NewAllocaTy->isIntegerTy() && TargetTy->isIntegerTy()))) { - LoadInst *NewLI = IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), + LoadInst *NewLI = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), LI.isVolatile(), LI.getName()); if (AATags) NewLI->setAAMetadata(AATags); @@ -2497,9 +2500,9 @@ } } else { Type *LTy = TargetTy->getPointerTo(AS); - LoadInst *NewLI = IRB.CreateAlignedLoad(getNewAllocaSlicePtr(IRB, LTy), - getSliceAlign(TargetTy), - LI.isVolatile(), LI.getName()); + LoadInst *NewLI = IRB.CreateAlignedLoad( + TargetTy, getNewAllocaSlicePtr(IRB, LTy), getSliceAlign(TargetTy), + LI.isVolatile(), LI.getName()); if (AATags) NewLI->setAAMetadata(AATags); if (LI.isVolatile()) @@ -2525,8 +2528,8 @@ // basis for the new value. This allows us to replace the uses of LI with // the computed value, and then replace the placeholder with LI, leaving // LI only used for this computation. - Value *Placeholder = - new LoadInst(UndefValue::get(LI.getType()->getPointerTo(AS))); + Value *Placeholder = new LoadInst( + LI.getType(), UndefValue::get(LI.getType()->getPointerTo(AS))); V = insertInteger(DL, IRB, Placeholder, V, NewBeginOffset - BeginOffset, "insert"); LI.replaceAllUsesWith(V); @@ -2557,7 +2560,8 @@ V = convertValue(DL, IRB, V, SliceTy); // Mix in the existing elements. - Value *Old = IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "load"); + Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "load"); V = insertVector(IRB, Old, V, BeginIndex, "vec"); } StoreInst *Store = IRB.CreateAlignedStore(V, &NewAI, NewAI.getAlignment()); @@ -2573,8 +2577,8 @@ assert(IntTy && "We cannot extract an integer from the alloca"); assert(!SI.isVolatile()); if (DL.getTypeSizeInBits(V->getType()) != IntTy->getBitWidth()) { - Value *Old = - IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "oldload"); + Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "oldload"); Old = convertValue(DL, IRB, Old, IntTy); assert(BeginOffset >= NewAllocaBeginOffset && "Out of bounds offset"); uint64_t Offset = BeginOffset - NewAllocaBeginOffset; @@ -2766,8 +2770,8 @@ if (NumElements > 1) Splat = getVectorSplat(Splat, NumElements); - Value *Old = - IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "oldload"); + Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "oldload"); V = insertVector(IRB, Old, Splat, BeginIndex, "vec"); } else if (IntTy) { // If this is a memset on an alloca where we can widen stores, insert the @@ -2779,8 +2783,8 @@ if (IntTy && (BeginOffset != NewAllocaBeginOffset || EndOffset != NewAllocaBeginOffset)) { - Value *Old = - IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "oldload"); + Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "oldload"); Old = convertValue(DL, IRB, Old, IntTy); uint64_t Offset = NewBeginOffset - NewAllocaBeginOffset; V = insertInteger(DL, IRB, Old, V, Offset, "insert"); @@ -2940,18 +2944,18 @@ // Reset the other pointer type to match the register type we're going to // use, but using the address space of the original other pointer. + Type *OtherTy; if (VecTy && !IsWholeAlloca) { if (NumElements == 1) - OtherPtrTy = VecTy->getElementType(); + OtherTy = VecTy->getElementType(); else - OtherPtrTy = VectorType::get(VecTy->getElementType(), NumElements); - - OtherPtrTy = OtherPtrTy->getPointerTo(OtherAS); + OtherTy = VectorType::get(VecTy->getElementType(), NumElements); } else if (IntTy && !IsWholeAlloca) { - OtherPtrTy = SubIntTy->getPointerTo(OtherAS); + OtherTy = SubIntTy; } else { - OtherPtrTy = NewAllocaTy->getPointerTo(OtherAS); + OtherTy = NewAllocaTy; } + OtherPtrTy = OtherTy->getPointerTo(OtherAS); Value *SrcPtr = getAdjustedPtr(IRB, DL, OtherPtr, OtherOffset, OtherPtrTy, OtherPtr->getName() + "."); @@ -2965,28 +2969,30 @@ Value *Src; if (VecTy && !IsWholeAlloca && !IsDest) { - Src = IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "load"); + Src = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "load"); Src = extractVector(IRB, Src, BeginIndex, EndIndex, "vec"); } else if (IntTy && !IsWholeAlloca && !IsDest) { - Src = IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "load"); + Src = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "load"); Src = convertValue(DL, IRB, Src, IntTy); uint64_t Offset = NewBeginOffset - NewAllocaBeginOffset; Src = extractInteger(DL, IRB, Src, SubIntTy, Offset, "extract"); } else { - LoadInst *Load = IRB.CreateAlignedLoad(SrcPtr, SrcAlign, II.isVolatile(), - "copyload"); + LoadInst *Load = IRB.CreateAlignedLoad(OtherTy, SrcPtr, SrcAlign, + II.isVolatile(), "copyload"); if (AATags) Load->setAAMetadata(AATags); Src = Load; } if (VecTy && !IsWholeAlloca && IsDest) { - Value *Old = - IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "oldload"); + Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "oldload"); Src = insertVector(IRB, Old, Src, BeginIndex, "vec"); } else if (IntTy && !IsWholeAlloca && IsDest) { - Value *Old = - IRB.CreateAlignedLoad(&NewAI, NewAI.getAlignment(), "oldload"); + Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI, + NewAI.getAlignment(), "oldload"); Old = convertValue(DL, IRB, Old, IntTy); uint64_t Offset = NewBeginOffset - NewAllocaBeginOffset; Src = insertInteger(DL, IRB, Old, Src, Offset, "insert"); @@ -3293,7 +3299,7 @@ // Load the single value and insert it using the indices. Value *GEP = IRB.CreateInBoundsGEP(nullptr, Ptr, GEPIndices, Name + ".gep"); - LoadInst *Load = IRB.CreateAlignedLoad(GEP, Align, Name + ".load"); + LoadInst *Load = IRB.CreateAlignedLoad(Ty, GEP, Align, Name + ".load"); if (AATags) Load->setAAMetadata(AATags); Agg = IRB.CreateInsertValue(Agg, Load, Indices, Name + ".insert"); @@ -3787,6 +3793,7 @@ auto AS = LI->getPointerAddressSpace(); auto *PartPtrTy = PartTy->getPointerTo(AS); LoadInst *PLoad = IRB.CreateAlignedLoad( + PartTy, getAdjustedPtr(IRB, DL, BasePtr, APInt(DL.getIndexSizeInBits(AS), PartOffset), PartPtrTy, BasePtr->getName() + "."), @@ -3928,6 +3935,7 @@ IRB.SetInsertPoint(LI); auto AS = LI->getPointerAddressSpace(); PLoad = IRB.CreateAlignedLoad( + PartTy, getAdjustedPtr(IRB, DL, LoadBasePtr, APInt(DL.getIndexSizeInBits(AS), PartOffset), LoadPartPtrTy, LoadBasePtr->getName() + "."), Index: llvm/lib/Transforms/Scalar/Scalarizer.cpp =================================================================== --- llvm/lib/Transforms/Scalar/Scalarizer.cpp +++ llvm/lib/Transforms/Scalar/Scalarizer.cpp @@ -743,7 +743,8 @@ Res.resize(NumElems); for (unsigned I = 0; I < NumElems; ++I) - Res[I] = Builder.CreateAlignedLoad(Ptr[I], Layout.getElemAlign(I), + Res[I] = Builder.CreateAlignedLoad(Layout.VecTy->getElementType(), Ptr[I], + Layout.getElemAlign(I), LI.getName() + ".i" + Twine(I)); gather(&LI, Res); return true; Index: llvm/lib/Transforms/Utils/CodeExtractor.cpp =================================================================== --- llvm/lib/Transforms/Utils/CodeExtractor.cpp +++ llvm/lib/Transforms/Utils/CodeExtractor.cpp @@ -844,7 +844,8 @@ Instruction *TI = newFunction->begin()->getTerminator(); GetElementPtrInst *GEP = GetElementPtrInst::Create( StructTy, &*AI, Idx, "gep_" + inputs[i]->getName(), TI); - RewriteVal = new LoadInst(GEP, "loadgep_" + inputs[i]->getName(), TI); + RewriteVal = new LoadInst(StructTy->getElementType(i), GEP, + "loadgep_" + inputs[i]->getName(), TI); } else RewriteVal = &*AI++; @@ -1041,7 +1042,8 @@ } else { Output = ReloadOutputs[i]; } - LoadInst *load = new LoadInst(Output, outputs[i]->getName()+".reload"); + LoadInst *load = new LoadInst(outputs[i]->getType(), Output, + outputs[i]->getName() + ".reload"); Reloads.push_back(load); codeReplacer->getInstList().push_back(load); std::vector Users(outputs[i]->user_begin(), outputs[i]->user_end()); Index: llvm/lib/Transforms/Utils/DemoteRegToStack.cpp =================================================================== --- llvm/lib/Transforms/Utils/DemoteRegToStack.cpp +++ llvm/lib/Transforms/Utils/DemoteRegToStack.cpp @@ -72,7 +72,8 @@ Value *&V = Loads[PN->getIncomingBlock(i)]; if (!V) { // Insert the load into the predecessor block - V = new LoadInst(Slot, I.getName()+".reload", VolatileLoads, + V = new LoadInst(I.getType(), Slot, I.getName() + ".reload", + VolatileLoads, PN->getIncomingBlock(i)->getTerminator()); } PN->setIncomingValue(i, V); @@ -80,7 +81,8 @@ } else { // If this is a normal instruction, just insert a load. - Value *V = new LoadInst(Slot, I.getName()+".reload", VolatileLoads, U); + Value *V = new LoadInst(I.getType(), Slot, I.getName() + ".reload", + VolatileLoads, U); U->replaceUsesOfWith(&I, V); } } @@ -141,7 +143,8 @@ for (; isa(InsertPt) || InsertPt->isEHPad(); ++InsertPt) /* empty */; // Don't insert before PHI nodes or landingpad instrs. - Value *V = new LoadInst(Slot, P->getName() + ".reload", &*InsertPt); + Value *V = + new LoadInst(P->getType(), Slot, P->getName() + ".reload", &*InsertPt); P->replaceAllUsesWith(V); // Delete PHI. Index: llvm/lib/Transforms/Utils/LowerMemIntrinsics.cpp =================================================================== --- llvm/lib/Transforms/Utils/LowerMemIntrinsics.cpp +++ llvm/lib/Transforms/Utils/LowerMemIntrinsics.cpp @@ -72,7 +72,7 @@ // Loop Body Value *SrcGEP = LoopBuilder.CreateInBoundsGEP(LoopOpType, SrcAddr, LoopIndex); - Value *Load = LoopBuilder.CreateLoad(SrcGEP, SrcIsVolatile); + Value *Load = LoopBuilder.CreateLoad(LoopOpType, SrcGEP, SrcIsVolatile); Value *DstGEP = LoopBuilder.CreateInBoundsGEP(LoopOpType, DstAddr, LoopIndex); LoopBuilder.CreateStore(Load, DstGEP, DstIsVolatile); @@ -114,7 +114,7 @@ : RBuilder.CreateBitCast(SrcAddr, SrcPtrType); Value *SrcGEP = RBuilder.CreateInBoundsGEP( OpTy, CastedSrc, ConstantInt::get(TypeOfCopyLen, GepIndex)); - Value *Load = RBuilder.CreateLoad(SrcGEP, SrcIsVolatile); + Value *Load = RBuilder.CreateLoad(OpTy, SrcGEP, SrcIsVolatile); // Cast destination to operand type and store. PointerType *DstPtrType = PointerType::get(OpTy, DstAS); @@ -181,7 +181,7 @@ LoopIndex->addIncoming(ConstantInt::get(CopyLenType, 0U), PreLoopBB); Value *SrcGEP = LoopBuilder.CreateInBoundsGEP(LoopOpType, SrcAddr, LoopIndex); - Value *Load = LoopBuilder.CreateLoad(SrcGEP, SrcIsVolatile); + Value *Load = LoopBuilder.CreateLoad(LoopOpType, SrcGEP, SrcIsVolatile); Value *DstGEP = LoopBuilder.CreateInBoundsGEP(LoopOpType, DstAddr, LoopIndex); LoopBuilder.CreateStore(Load, DstGEP, DstIsVolatile); @@ -234,7 +234,7 @@ Value *FullOffset = ResBuilder.CreateAdd(RuntimeBytesCopied, ResidualIndex); Value *SrcGEP = ResBuilder.CreateInBoundsGEP(Int8Type, SrcAsInt8, FullOffset); - Value *Load = ResBuilder.CreateLoad(SrcGEP, SrcIsVolatile); + Value *Load = ResBuilder.CreateLoad(Int8Type, SrcGEP, SrcIsVolatile); Value *DstGEP = ResBuilder.CreateInBoundsGEP(Int8Type, DstAsInt8, FullOffset); ResBuilder.CreateStore(Load, DstGEP, DstIsVolatile); @@ -292,6 +292,8 @@ BasicBlock *OrigBB = InsertBefore->getParent(); Function *F = OrigBB->getParent(); + Type *EltTy = cast(SrcAddr->getType())->getElementType(); + // Create the a comparison of src and dst, based on which we jump to either // the forward-copy part of the function (if src >= dst) or the backwards-copy // part (if src < dst). @@ -330,7 +332,7 @@ Value *IndexPtr = LoopBuilder.CreateSub( LoopPhi, ConstantInt::get(TypeOfCopyLen, 1), "index_ptr"); Value *Element = LoopBuilder.CreateLoad( - LoopBuilder.CreateInBoundsGEP(SrcAddr, IndexPtr), "element"); + EltTy, LoopBuilder.CreateInBoundsGEP(SrcAddr, IndexPtr), "element"); LoopBuilder.CreateStore(Element, LoopBuilder.CreateInBoundsGEP(DstAddr, IndexPtr)); LoopBuilder.CreateCondBr( @@ -347,7 +349,7 @@ IRBuilder<> FwdLoopBuilder(FwdLoopBB); PHINode *FwdCopyPhi = FwdLoopBuilder.CreatePHI(TypeOfCopyLen, 0, "index_ptr"); Value *FwdElement = FwdLoopBuilder.CreateLoad( - FwdLoopBuilder.CreateInBoundsGEP(SrcAddr, FwdCopyPhi), "element"); + EltTy, FwdLoopBuilder.CreateInBoundsGEP(SrcAddr, FwdCopyPhi), "element"); FwdLoopBuilder.CreateStore( FwdElement, FwdLoopBuilder.CreateInBoundsGEP(DstAddr, FwdCopyPhi)); Value *FwdIndexPtr = FwdLoopBuilder.CreateAdd( Index: llvm/lib/Transforms/Utils/SimplifyCFG.cpp =================================================================== --- llvm/lib/Transforms/Utils/SimplifyCFG.cpp +++ llvm/lib/Transforms/Utils/SimplifyCFG.cpp @@ -5090,7 +5090,9 @@ Value *GEPIndices[] = {Builder.getInt32(0), Index}; Value *GEP = Builder.CreateInBoundsGEP(Array->getValueType(), Array, GEPIndices, "switch.gep"); - return Builder.CreateLoad(GEP, "switch.load"); + return Builder.CreateLoad( + cast(Array->getValueType())->getElementType(), GEP, + "switch.load"); } } llvm_unreachable("Unknown lookup table kind!"); Index: llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp =================================================================== --- llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -333,11 +333,12 @@ return ConstantInt::get(CI->getType(), Str1.compare(Str2)); if (HasStr1 && Str1.empty()) // strcmp("", x) -> -*x - return B.CreateNeg( - B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"), CI->getType())); + return B.CreateNeg(B.CreateZExt( + B.CreateLoad(B.getInt8Ty(), Str2P, "strcmpload"), CI->getType())); if (HasStr2 && Str2.empty()) // strcmp(x,"") -> *x - return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType()); + return B.CreateZExt(B.CreateLoad(B.getInt8Ty(), Str1P, "strcmpload"), + CI->getType()); // strcmp(P, "x") -> memcmp(P, "x", 2) uint64_t Len1 = GetStringLength(Str1P); @@ -397,11 +398,12 @@ } if (HasStr1 && Str1.empty()) // strncmp("", x, n) -> -*x - return B.CreateNeg( - B.CreateZExt(B.CreateLoad(Str2P, "strcmpload"), CI->getType())); + return B.CreateNeg(B.CreateZExt( + B.CreateLoad(B.getInt8Ty(), Str2P, "strcmpload"), CI->getType())); if (HasStr2 && Str2.empty()) // strncmp(x, "", n) -> *x - return B.CreateZExt(B.CreateLoad(Str1P, "strcmpload"), CI->getType()); + return B.CreateZExt(B.CreateLoad(B.getInt8Ty(), Str1P, "strcmpload"), + CI->getType()); uint64_t Len1 = GetStringLength(Str1P); uint64_t Len2 = GetStringLength(Str2P); @@ -590,7 +592,8 @@ // strlen(x) != 0 --> *x != 0 // strlen(x) == 0 --> *x == 0 if (isOnlyUsedInZeroEqualityComparison(CI)) - return B.CreateZExt(B.CreateLoad(Src, "strlenfirst"), CI->getType()); + return B.CreateZExt(B.CreateLoad(B.getIntNTy(CharSize), Src, "strlenfirst"), + CI->getType()); return nullptr; } @@ -844,10 +847,12 @@ // memcmp(S1,S2,1) -> *(unsigned char*)LHS - *(unsigned char*)RHS if (Len == 1) { - Value *LHSV = B.CreateZExt(B.CreateLoad(castToCStr(LHS, B), "lhsc"), - CI->getType(), "lhsv"); - Value *RHSV = B.CreateZExt(B.CreateLoad(castToCStr(RHS, B), "rhsc"), - CI->getType(), "rhsv"); + Value *LHSV = + B.CreateZExt(B.CreateLoad(B.getInt8Ty(), castToCStr(LHS, B), "lhsc"), + CI->getType(), "lhsv"); + Value *RHSV = + B.CreateZExt(B.CreateLoad(B.getInt8Ty(), castToCStr(RHS, B), "rhsc"), + CI->getType(), "rhsv"); return B.CreateSub(LHSV, RHSV, "chardiff"); } @@ -877,12 +882,12 @@ if (!LHSV) { Type *LHSPtrTy = IntType->getPointerTo(LHS->getType()->getPointerAddressSpace()); - LHSV = B.CreateLoad(B.CreateBitCast(LHS, LHSPtrTy), "lhsv"); + LHSV = B.CreateLoad(IntType, B.CreateBitCast(LHS, LHSPtrTy), "lhsv"); } if (!RHSV) { Type *RHSPtrTy = IntType->getPointerTo(RHS->getType()->getPointerAddressSpace()); - RHSV = B.CreateLoad(B.CreateBitCast(RHS, RHSPtrTy), "rhsv"); + RHSV = B.CreateLoad(IntType, B.CreateBitCast(RHS, RHSPtrTy), "rhsv"); } return B.CreateZExt(B.CreateICmpNE(LHSV, RHSV), CI->getType(), "memcmp"); } @@ -2286,7 +2291,8 @@ // If this is writing one byte, turn it into fputc. // This optimisation is only valid, if the return value is unused. if (Bytes == 1 && CI->use_empty()) { // fwrite(S,1,1,F) -> fputc(S[0],F) - Value *Char = B.CreateLoad(castToCStr(CI->getArgOperand(0), B), "char"); + Value *Char = B.CreateLoad(B.getInt8Ty(), + castToCStr(CI->getArgOperand(0), B), "char"); Value *NewCI = emitFPutC(Char, CI->getArgOperand(3), B, TLI); return NewCI ? ConstantInt::get(CI->getType(), 1) : nullptr; } Index: llvm/lib/Transforms/Utils/VNCoercion.cpp =================================================================== --- llvm/lib/Transforms/Utils/VNCoercion.cpp +++ llvm/lib/Transforms/Utils/VNCoercion.cpp @@ -386,12 +386,12 @@ // memdep queries will find the new load. We can't easily remove the old // load completely because it is already in the value numbering table. IRBuilder<> Builder(SrcVal->getParent(), ++BasicBlock::iterator(SrcVal)); - Type *DestPTy = IntegerType::get(LoadTy->getContext(), NewLoadSize * 8); - DestPTy = - PointerType::get(DestPTy, PtrVal->getType()->getPointerAddressSpace()); + Type *DestTy = IntegerType::get(LoadTy->getContext(), NewLoadSize * 8); + Type *DestPTy = + PointerType::get(DestTy, PtrVal->getType()->getPointerAddressSpace()); Builder.SetCurrentDebugLocation(SrcVal->getDebugLoc()); PtrVal = Builder.CreateBitCast(PtrVal, DestPTy); - LoadInst *NewLoad = Builder.CreateLoad(PtrVal); + LoadInst *NewLoad = Builder.CreateLoad(DestTy, PtrVal); NewLoad->takeName(SrcVal); NewLoad->setAlignment(SrcVal->getAlignment()); Index: llvm/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp =================================================================== --- llvm/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp +++ llvm/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp @@ -1181,7 +1181,7 @@ Value *Bitcast = Builder.CreateBitCast(L0->getPointerOperand(), VecTy->getPointerTo(AS)); - LoadInst *LI = Builder.CreateAlignedLoad(Bitcast, Alignment); + LoadInst *LI = Builder.CreateAlignedLoad(VecTy, Bitcast, Alignment); propagateMetadata(LI, Chain); if (VecLoadTy) { Index: llvm/lib/Transforms/Vectorize/LoopVectorize.cpp =================================================================== --- llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -2100,8 +2100,8 @@ GroupMask, UndefVec, "wide.masked.vec"); } else - NewLoad = Builder.CreateAlignedLoad(NewPtrs[Part], - Group->getAlignment(), "wide.vec"); + NewLoad = Builder.CreateAlignedLoad(VecTy, NewPtrs[Part], + Group->getAlignment(), "wide.vec"); Group->addMetadata(NewLoad); NewLoads.push_back(NewLoad); } @@ -2312,7 +2312,8 @@ UndefValue::get(DataTy), "wide.masked.load"); else - NewLI = Builder.CreateAlignedLoad(VecPtr, Alignment, "wide.load"); + NewLI = + Builder.CreateAlignedLoad(DataTy, VecPtr, Alignment, "wide.load"); // Add metadata to the load, but setVectorValue to the reverse shuffle. addMetadata(NewLI, LI); Index: llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp =================================================================== --- llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp +++ llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp @@ -3136,7 +3136,7 @@ Builder.SetInsertPoint(LI); PointerType *PtrTy = PointerType::get(VecTy, LI->getPointerAddressSpace()); Value *Ptr = Builder.CreateBitCast(LI->getOperand(0), PtrTy); - LoadInst *V = Builder.CreateAlignedLoad(Ptr, LI->getAlignment()); + LoadInst *V = Builder.CreateAlignedLoad(VecTy, Ptr, LI->getAlignment()); Value *NewV = propagateMetadata(V, E->Scalars); if (!E->ReorderIndices.empty()) { OrdersType Mask; @@ -3341,7 +3341,7 @@ ExternalUses.push_back(ExternalUser(PO, cast(VecPtr), 0)); unsigned Alignment = LI->getAlignment(); - LI = Builder.CreateLoad(VecPtr); + LI = Builder.CreateLoad(VecTy, VecPtr); if (!Alignment) { Alignment = DL->getABITypeAlignment(ScalarLoadTy); } Index: llvm/test/CodeGen/AMDGPU/lower-kernargs.ll =================================================================== --- llvm/test/CodeGen/AMDGPU/lower-kernargs.ll +++ llvm/test/CodeGen/AMDGPU/lower-kernargs.ll @@ -306,20 +306,18 @@ ; HSA-LABEL: @kern_v3i32( ; HSA-NEXT: [[KERN_V3I32_KERNARG_SEGMENT:%.*]] = call nonnull align 16 dereferenceable(16) i8 addrspace(4)* @llvm.amdgcn.kernarg.segment.ptr() ; HSA-NEXT: [[ARG0_KERNARG_OFFSET:%.*]] = getelementptr inbounds i8, i8 addrspace(4)* [[KERN_V3I32_KERNARG_SEGMENT]], i64 0 -; HSA-NEXT: [[ARG0_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG0_KERNARG_OFFSET]] to <3 x i32> addrspace(4)* -; HSA-NEXT: [[TMP1:%.*]] = bitcast <3 x i32> addrspace(4)* [[ARG0_KERNARG_OFFSET_CAST]] to <4 x i32> addrspace(4)* -; HSA-NEXT: [[TMP2:%.*]] = load <4 x i32>, <4 x i32> addrspace(4)* [[TMP1]], align 16, !invariant.load !0 -; HSA-NEXT: [[ARG0_LOAD:%.*]] = shufflevector <4 x i32> [[TMP2]], <4 x i32> undef, <3 x i32> +; HSA-NEXT: [[ARG0_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG0_KERNARG_OFFSET]] to <4 x i32> addrspace(4)* +; HSA-NEXT: [[TMP:%.*]] = load <4 x i32>, <4 x i32> addrspace(4)* [[ARG0_KERNARG_OFFSET_CAST]], align 16, !invariant.load !0 +; HSA-NEXT: [[ARG0_LOAD:%.*]] = shufflevector <4 x i32> [[TMP]], <4 x i32> undef, <3 x i32> ; HSA-NEXT: store <3 x i32> [[ARG0_LOAD]], <3 x i32> addrspace(1)* undef, align 4 ; HSA-NEXT: ret void ; ; MESA-LABEL: @kern_v3i32( ; MESA-NEXT: [[KERN_V3I32_KERNARG_SEGMENT:%.*]] = call nonnull align 16 dereferenceable(52) i8 addrspace(4)* @llvm.amdgcn.kernarg.segment.ptr() ; MESA-NEXT: [[ARG0_KERNARG_OFFSET:%.*]] = getelementptr inbounds i8, i8 addrspace(4)* [[KERN_V3I32_KERNARG_SEGMENT]], i64 36 -; MESA-NEXT: [[ARG0_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG0_KERNARG_OFFSET]] to <3 x i32> addrspace(4)* -; MESA-NEXT: [[TMP1:%.*]] = bitcast <3 x i32> addrspace(4)* [[ARG0_KERNARG_OFFSET_CAST]] to <4 x i32> addrspace(4)* -; MESA-NEXT: [[TMP2:%.*]] = load <4 x i32>, <4 x i32> addrspace(4)* [[TMP1]], align 4, !invariant.load !0 -; MESA-NEXT: [[ARG0_LOAD:%.*]] = shufflevector <4 x i32> [[TMP2]], <4 x i32> undef, <3 x i32> +; MESA-NEXT: [[ARG0_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG0_KERNARG_OFFSET]] to <4 x i32> addrspace(4)* +; MESA-NEXT: [[TMP:%.*]] = load <4 x i32>, <4 x i32> addrspace(4)* [[ARG0_KERNARG_OFFSET_CAST]], align 4, !invariant.load !0 +; MESA-NEXT: [[ARG0_LOAD:%.*]] = shufflevector <4 x i32> [[TMP]], <4 x i32> undef, <3 x i32> ; MESA-NEXT: store <3 x i32> [[ARG0_LOAD]], <3 x i32> addrspace(1)* undef, align 4 ; MESA-NEXT: ret void ; @@ -397,10 +395,9 @@ ; HSA-NEXT: [[ARG0_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG0_KERNARG_OFFSET]] to i32 addrspace(4)* ; HSA-NEXT: [[ARG0_LOAD:%.*]] = load i32, i32 addrspace(4)* [[ARG0_KERNARG_OFFSET_CAST]], align 16, !invariant.load !0 ; HSA-NEXT: [[ARG1_KERNARG_OFFSET:%.*]] = getelementptr inbounds i8, i8 addrspace(4)* [[KERN_I32_V3I32_KERNARG_SEGMENT]], i64 16 -; HSA-NEXT: [[ARG1_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG1_KERNARG_OFFSET]] to <3 x i32> addrspace(4)* -; HSA-NEXT: [[TMP1:%.*]] = bitcast <3 x i32> addrspace(4)* [[ARG1_KERNARG_OFFSET_CAST]] to <4 x i32> addrspace(4)* -; HSA-NEXT: [[TMP2:%.*]] = load <4 x i32>, <4 x i32> addrspace(4)* [[TMP1]], align 16, !invariant.load !0 -; HSA-NEXT: [[ARG1_LOAD:%.*]] = shufflevector <4 x i32> [[TMP2]], <4 x i32> undef, <3 x i32> +; HSA-NEXT: [[ARG1_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG1_KERNARG_OFFSET]] to <4 x i32> addrspace(4)* +; HSA-NEXT: [[TMP:%.*]] = load <4 x i32>, <4 x i32> addrspace(4)* [[ARG1_KERNARG_OFFSET_CAST]], align 16, !invariant.load !0 +; HSA-NEXT: [[ARG1_LOAD:%.*]] = shufflevector <4 x i32> [[TMP]], <4 x i32> undef, <3 x i32> ; HSA-NEXT: store i32 [[ARG0_LOAD]], i32 addrspace(1)* undef ; HSA-NEXT: store <3 x i32> [[ARG1_LOAD]], <3 x i32> addrspace(1)* undef, align 4 ; HSA-NEXT: ret void @@ -411,10 +408,9 @@ ; MESA-NEXT: [[ARG0_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG0_KERNARG_OFFSET]] to i32 addrspace(4)* ; MESA-NEXT: [[ARG0_LOAD:%.*]] = load i32, i32 addrspace(4)* [[ARG0_KERNARG_OFFSET_CAST]], align 4, !invariant.load !0 ; MESA-NEXT: [[ARG1_KERNARG_OFFSET:%.*]] = getelementptr inbounds i8, i8 addrspace(4)* [[KERN_I32_V3I32_KERNARG_SEGMENT]], i64 52 -; MESA-NEXT: [[ARG1_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG1_KERNARG_OFFSET]] to <3 x i32> addrspace(4)* -; MESA-NEXT: [[TMP1:%.*]] = bitcast <3 x i32> addrspace(4)* [[ARG1_KERNARG_OFFSET_CAST]] to <4 x i32> addrspace(4)* -; MESA-NEXT: [[TMP2:%.*]] = load <4 x i32>, <4 x i32> addrspace(4)* [[TMP1]], align 4, !invariant.load !0 -; MESA-NEXT: [[ARG1_LOAD:%.*]] = shufflevector <4 x i32> [[TMP2]], <4 x i32> undef, <3 x i32> +; MESA-NEXT: [[ARG1_KERNARG_OFFSET_CAST:%.*]] = bitcast i8 addrspace(4)* [[ARG1_KERNARG_OFFSET]] to <4 x i32> addrspace(4)* +; MESA-NEXT: [[TMP:%.*]] = load <4 x i32>, <4 x i32> addrspace(4)* [[ARG1_KERNARG_OFFSET_CAST]], align 4, !invariant.load !0 +; MESA-NEXT: [[ARG1_LOAD:%.*]] = shufflevector <4 x i32> [[TMP]], <4 x i32> undef, <3 x i32> ; MESA-NEXT: store i32 [[ARG0_LOAD]], i32 addrspace(1)* undef ; MESA-NEXT: store <3 x i32> [[ARG1_LOAD]], <3 x i32> addrspace(1)* undef, align 4 ; MESA-NEXT: ret void Index: llvm/tools/bugpoint/Miscompilation.cpp =================================================================== --- llvm/tools/bugpoint/Miscompilation.cpp +++ llvm/tools/bugpoint/Miscompilation.cpp @@ -879,7 +879,8 @@ BasicBlock::Create(F->getContext(), "lookupfp", FuncWrapper); // Check to see if we already looked up the value. - Value *CachedVal = new LoadInst(Cache, "fpcache", EntryBB); + Value *CachedVal = + new LoadInst(F->getType(), Cache, "fpcache", EntryBB); Value *IsNull = new ICmpInst(*EntryBB, ICmpInst::ICMP_EQ, CachedVal, NullPtr, "isNull"); BranchInst::Create(LookupBB, DoCallBB, IsNull, EntryBB); Index: llvm/unittests/Analysis/AliasAnalysisTest.cpp =================================================================== --- llvm/unittests/Analysis/AliasAnalysisTest.cpp +++ llvm/unittests/Analysis/AliasAnalysisTest.cpp @@ -174,7 +174,7 @@ auto *Addr = ConstantPointerNull::get(PtrType); auto *Store1 = new StoreInst(Value, Addr, BB); - auto *Load1 = new LoadInst(Addr, "load", BB); + auto *Load1 = new LoadInst(IntType, Addr, "load", BB); auto *Add1 = BinaryOperator::CreateAdd(Value, Value, "add", BB); auto *VAArg1 = new VAArgInst(Addr, PtrType, "vaarg", BB); auto *CmpXChg1 = new AtomicCmpXchgInst( Index: llvm/unittests/Analysis/MemorySSATest.cpp =================================================================== --- llvm/unittests/Analysis/MemorySSATest.cpp +++ llvm/unittests/Analysis/MemorySSATest.cpp @@ -92,7 +92,7 @@ MemorySSAUpdater Updater(&MSSA); // Add the load B.SetInsertPoint(Merge); - LoadInst *LoadInst = B.CreateLoad(PointerArg); + LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg); // MemoryPHI should already exist. MemoryPhi *MP = MSSA.getMemoryAccess(Merge); @@ -138,7 +138,7 @@ // Add the load B.SetInsertPoint(Merge, Merge->begin()); - LoadInst *FirstLoad = B.CreateLoad(PointerArg); + LoadInst *FirstLoad = B.CreateLoad(B.getInt8Ty(), PointerArg); // MemoryPHI should not already exist. MemoryPhi *MP = MSSA.getMemoryAccess(Merge); @@ -162,7 +162,7 @@ // We don't touch existing loads, so we need to create a new one to get a phi // Add the second load B.SetInsertPoint(Merge, Merge->begin()); - LoadInst *SecondLoad = B.CreateLoad(PointerArg); + LoadInst *SecondLoad = B.CreateLoad(B.getInt8Ty(), PointerArg); // MemoryPHI should not already exist. MP = MSSA.getMemoryAccess(Merge); @@ -228,7 +228,7 @@ // Add the load B.SetInsertPoint(Merge, Merge->begin()); - LoadInst *LoadInst = B.CreateLoad(PointerArg); + LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg); // MemoryPHI should not already exist. MemoryPhi *MP = MSSA.getMemoryAccess(Merge); @@ -262,7 +262,7 @@ // Load in left block B.SetInsertPoint(Left, Left->begin()); - LoadInst *LoadInst1 = B.CreateLoad(PointerArg); + LoadInst *LoadInst1 = B.CreateLoad(B.getInt8Ty(), PointerArg); // Store in merge block B.SetInsertPoint(Merge, Merge->begin()); B.CreateStore(B.getInt8(16), PointerArg); @@ -310,7 +310,7 @@ BranchInst::Create(Merge, Left); BranchInst::Create(Merge, Right); B.SetInsertPoint(Merge); - B.CreateLoad(PointerArg); + B.CreateLoad(B.getInt8Ty(), PointerArg); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; MemorySSAUpdater Updater(&MSSA); @@ -346,7 +346,7 @@ BranchInst::Create(Merge, Left); BranchInst::Create(Merge, Right); B.SetInsertPoint(Merge); - auto *MergeLoad = B.CreateLoad(PointerArg); + auto *MergeLoad = B.CreateLoad(B.getInt8Ty(), PointerArg); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; MemorySSAUpdater Updater(&MSSA); @@ -392,7 +392,7 @@ BranchInst::Create(Merge, Left); BranchInst::Create(Merge, Right); B.SetInsertPoint(Merge); - auto *MergeLoad = B.CreateLoad(PointerArg); + auto *MergeLoad = B.CreateLoad(B.getInt8Ty(), PointerArg); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; MemorySSAUpdater Updater(&MSSA); @@ -436,7 +436,7 @@ BranchInst::Create(Merge, Left); BranchInst::Create(Merge, Right); B.SetInsertPoint(Merge); - auto *MergeLoad = B.CreateLoad(PointerArg); + auto *MergeLoad = B.CreateLoad(B.getInt8Ty(), PointerArg); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; MemorySSAUpdater Updater(&MSSA); @@ -490,7 +490,7 @@ BranchInst::Create(Merge, Left); BranchInst::Create(Merge, Right); B.SetInsertPoint(Merge); - LoadInst *LoadInst = B.CreateLoad(PointerArg); + LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; @@ -535,7 +535,7 @@ BranchInst::Create(Merge, Left); BranchInst::Create(Merge, Right); B.SetInsertPoint(Merge); - LoadInst *LoadInst = B.CreateLoad(PointerArg); + LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; @@ -631,7 +631,7 @@ Type *Int8 = Type::getInt8Ty(C); Value *Alloca = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A"); Instruction *SI = B.CreateStore(ConstantInt::get(Int8, 0), Alloca); - Instruction *LI = B.CreateLoad(Alloca); + Instruction *LI = B.CreateLoad(Int8, Alloca); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; @@ -715,12 +715,12 @@ B.SetInsertPoint(IfThen); Instruction *FirstStore = B.CreateStore(Zero, AllocA); B.CreateStore(Zero, AllocB); - Instruction *ALoad0 = B.CreateLoad(AllocA, ""); + Instruction *ALoad0 = B.CreateLoad(Int8, AllocA, ""); Instruction *BStore = B.CreateStore(Zero, AllocB); // Due to use optimization/etc. we make a store to A, which is removed after // we build MSSA. This helps keep the test case simple-ish. Instruction *KillStore = B.CreateStore(Zero, AllocA); - Instruction *ALoad = B.CreateLoad(AllocA, ""); + Instruction *ALoad = B.CreateLoad(Int8, AllocA, ""); B.CreateBr(IfEnd); B.SetInsertPoint(IfEnd); @@ -771,7 +771,7 @@ Value *AllocA = B.CreateAlloca(Int8, One, ""); Instruction *Store = B.CreateStore(One, AllocA); - Instruction *Load = B.CreateLoad(AllocA); + Instruction *Load = B.CreateLoad(Int8, AllocA); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; @@ -800,7 +800,7 @@ Instruction *SIA = B.CreateStore(ConstantInt::get(Int8, 0), AllocaA); Value *AllocaB = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B"); Instruction *SIB = B.CreateStore(ConstantInt::get(Int8, 0), AllocaB); - Instruction *LIA = B.CreateLoad(AllocaA); + Instruction *LIA = B.CreateLoad(Int8, AllocaA); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; @@ -834,11 +834,11 @@ StoreInst *StoreA0 = B.CreateStore(ConstantInt::get(Int8, 0), A); StoreInst *StoreB = B.CreateStore(ConstantInt::get(Int8, 0), B_); - LoadInst *LoadB = B.CreateLoad(B_); + LoadInst *LoadB = B.CreateLoad(Int8, B_); StoreInst *StoreA1 = B.CreateStore(ConstantInt::get(Int8, 4), A); StoreInst *StoreC = B.CreateStore(ConstantInt::get(Int8, 4), C); StoreInst *StoreA2 = B.CreateStore(ConstantInt::get(Int8, 4), A); - LoadInst *LoadC = B.CreateLoad(C); + LoadInst *LoadC = B.CreateLoad(Int8, C); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; @@ -902,7 +902,7 @@ MemorySSA &MSSA = *Analyses->MSSA; MemorySSAUpdater Updater(&MSSA); // Create the load memory acccess - LoadInst *LoadInst = B.CreateLoad(FirstArg); + LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), FirstArg); MemoryUse *LoadAccess = cast(Updater.createMemoryAccessInBB( LoadInst, nullptr, AfterLoopBB, MemorySSA::Beginning)); Updater.insertUse(LoadAccess); @@ -1010,15 +1010,15 @@ B.CreateStore(ConstantInt::get(Int8, 1), AllocaB); // Check load from LOE - LoadInst *LA1 = B.CreateLoad(AllocaA, ""); + LoadInst *LA1 = B.CreateLoad(Int8, AllocaA, ""); // Check load alias cached for second load - LoadInst *LA2 = B.CreateLoad(AllocaA, ""); + LoadInst *LA2 = B.CreateLoad(Int8, AllocaA, ""); B.CreateStore(ConstantInt::get(Int8, 1), AllocaA); // Check load from store/def - LoadInst *LA3 = B.CreateLoad(AllocaA, ""); + LoadInst *LA3 = B.CreateLoad(Int8, AllocaA, ""); // Check load alias cached for second load - LoadInst *LA4 = B.CreateLoad(AllocaA, ""); + LoadInst *LA4 = B.CreateLoad(Int8, AllocaA, ""); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; @@ -1103,13 +1103,13 @@ Argument *PointerA = &*ArgIt; Argument *PointerB = &*(++ArgIt); B.CreateStore(ConstantInt::get(Int8, 1), PointerB); - LoadInst *LA1 = B.CreateLoad(PointerA, ""); + LoadInst *LA1 = B.CreateLoad(Int8, PointerA, ""); B.CreateStore(ConstantInt::get(Int8, 0), PointerA); - LoadInst *LB1 = B.CreateLoad(PointerB, ""); + LoadInst *LB1 = B.CreateLoad(Int8, PointerB, ""); B.CreateStore(ConstantInt::get(Int8, 0), PointerA); - LoadInst *LA2 = B.CreateLoad(PointerA, ""); + LoadInst *LA2 = B.CreateLoad(Int8, PointerA, ""); B.CreateStore(ConstantInt::get(Int8, 0), PointerB); - LoadInst *LB2 = B.CreateLoad(PointerB, ""); + LoadInst *LB2 = B.CreateLoad(Int8, PointerB, ""); setupAnalyses(); MemorySSA &MSSA = *Analyses->MSSA; Index: llvm/unittests/Analysis/OrderedInstructionsTest.cpp =================================================================== --- llvm/unittests/Analysis/OrderedInstructionsTest.cpp +++ llvm/unittests/Analysis/OrderedInstructionsTest.cpp @@ -44,13 +44,13 @@ BasicBlock *BBX = BasicBlock::Create(Ctx, "bbx", F); B.SetInsertPoint(BBX); Argument *PointerArg = &*F->arg_begin(); - LoadInst *LoadInstX = B.CreateLoad(PointerArg); - LoadInst *LoadInstY = B.CreateLoad(PointerArg); + LoadInst *LoadInstX = B.CreateLoad(B.getInt8Ty(), PointerArg); + LoadInst *LoadInstY = B.CreateLoad(B.getInt8Ty(), PointerArg); // Create BBY with 1 load. BasicBlock *BBY = BasicBlock::Create(Ctx, "bby", F); B.SetInsertPoint(BBY); - LoadInst *LoadInstZ = B.CreateLoad(PointerArg); + LoadInst *LoadInstZ = B.CreateLoad(B.getInt8Ty(), PointerArg); B.CreateRet(LoadInstZ); std::unique_ptr DT(new DominatorTree(*F)); OrderedInstructions OI(&*DT); Index: llvm/unittests/Analysis/PhiValuesTest.cpp =================================================================== --- llvm/unittests/Analysis/PhiValuesTest.cpp +++ llvm/unittests/Analysis/PhiValuesTest.cpp @@ -37,10 +37,10 @@ BranchInst::Create(Then, If); BranchInst::Create(Then, Else); - Value *Val1 = new LoadInst(UndefValue::get(I32PtrTy), "val1", Entry); - Value *Val2 = new LoadInst(UndefValue::get(I32PtrTy), "val2", Entry); - Value *Val3 = new LoadInst(UndefValue::get(I32PtrTy), "val3", Entry); - Value *Val4 = new LoadInst(UndefValue::get(I32PtrTy), "val4", Entry); + Value *Val1 = new LoadInst(I32Ty, UndefValue::get(I32PtrTy), "val1", Entry); + Value *Val2 = new LoadInst(I32Ty, UndefValue::get(I32PtrTy), "val2", Entry); + Value *Val3 = new LoadInst(I32Ty, UndefValue::get(I32PtrTy), "val3", Entry); + Value *Val4 = new LoadInst(I32Ty, UndefValue::get(I32PtrTy), "val4", Entry); PHINode *Phi1 = PHINode::Create(I32Ty, 2, "phi1", Then); Phi1->addIncoming(Val1, If); @@ -110,10 +110,10 @@ BranchInst::Create(End, If2); BranchInst::Create(End, Else2); - Value *Val1 = new LoadInst(UndefValue::get(I32PtrTy), "val1", Entry); - Value *Val2 = new LoadInst(UndefValue::get(I32PtrTy), "val2", Entry); - Value *Val3 = new LoadInst(UndefValue::get(I32PtrTy), "val3", Entry); - Value *Val4 = new LoadInst(UndefValue::get(I32PtrTy), "val4", Entry); + Value *Val1 = new LoadInst(I32Ty, UndefValue::get(I32PtrTy), "val1", Entry); + Value *Val2 = new LoadInst(I32Ty, UndefValue::get(I32PtrTy), "val2", Entry); + Value *Val3 = new LoadInst(I32Ty, UndefValue::get(I32PtrTy), "val3", Entry); + Value *Val4 = new LoadInst(I32Ty, UndefValue::get(I32PtrTy), "val4", Entry); PHINode *Phi1 = PHINode::Create(I32Ty, 2, "phi1", Then); Phi1->addIncoming(Val1, If1); Index: llvm/unittests/Analysis/ScalarEvolutionTest.cpp =================================================================== --- llvm/unittests/Analysis/ScalarEvolutionTest.cpp +++ llvm/unittests/Analysis/ScalarEvolutionTest.cpp @@ -407,9 +407,11 @@ const int ValueDepth = 10; for (int i = 0; i < ValueDepth; i++) { - X = new LoadInst(new IntToPtrInst(X, IntPtrPtrTy, "", EntryBB), "", + X = new LoadInst(IntPtrTy, new IntToPtrInst(X, IntPtrPtrTy, "", EntryBB), + "", /*isVolatile*/ false, EntryBB); - Y = new LoadInst(new IntToPtrInst(Y, IntPtrPtrTy, "", EntryBB), "", + Y = new LoadInst(IntPtrTy, new IntToPtrInst(Y, IntPtrPtrTy, "", EntryBB), + "", /*isVolatile*/ false, EntryBB); } Index: llvm/unittests/Analysis/SparsePropagation.cpp =================================================================== --- llvm/unittests/Analysis/SparsePropagation.cpp +++ llvm/unittests/Analysis/SparsePropagation.cpp @@ -381,7 +381,7 @@ BasicBlock *Else = BasicBlock::Create(Context, "else", F); F->arg_begin()->setName("cond"); Builder.SetInsertPoint(If); - LoadInst *Cond = Builder.CreateLoad(F->arg_begin()); + LoadInst *Cond = Builder.CreateLoad(Type::getInt1Ty(Context), F->arg_begin()); Builder.CreateCondBr(Cond, Then, Else); Builder.SetInsertPoint(Then); Builder.CreateRet(Builder.getInt64(1)); @@ -421,7 +421,7 @@ BasicBlock *Else = BasicBlock::Create(Context, "else", F); F->arg_begin()->setName("cond"); Builder.SetInsertPoint(If); - LoadInst *Cond = Builder.CreateLoad(F->arg_begin()); + LoadInst *Cond = Builder.CreateLoad(Type::getInt1Ty(Context), F->arg_begin()); Builder.CreateCondBr(Cond, Then, Else); Builder.SetInsertPoint(Then); Builder.CreateRet(Builder.getInt64(0)); Index: llvm/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp =================================================================== --- llvm/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp +++ llvm/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp @@ -211,10 +211,10 @@ GVB = insertGlobalInt32(B.get(), "GVB", initialNum); FA = startFunction(A.get(), FunctionType::get(Builder.getInt32Ty(), {}, false), "FA"); - endFunctionWithRet(FA, Builder.CreateLoad(GVA)); + endFunctionWithRet(FA, Builder.CreateLoad(Builder.getInt32Ty(), GVA)); FB = startFunction(B.get(), FunctionType::get(Builder.getInt32Ty(), {}, false), "FB"); - endFunctionWithRet(FB, Builder.CreateLoad(GVB)); + endFunctionWithRet(FB, Builder.CreateLoad(Builder.getInt32Ty(), GVB)); GVC = insertGlobalInt32(B.get(), "GVC", initialNum); GVC->setLinkage(GlobalValue::InternalLinkage); Index: llvm/unittests/ExecutionEngine/MCJIT/MCJITTest.cpp =================================================================== --- llvm/unittests/ExecutionEngine/MCJIT/MCJITTest.cpp +++ llvm/unittests/ExecutionEngine/MCJIT/MCJITTest.cpp @@ -101,7 +101,7 @@ Function *ReturnGlobal = startFunction(M.get(), FunctionType::get(Builder.getInt32Ty(), {}, false), "ReturnGlobal"); - Value *ReadGlobal = Builder.CreateLoad(GV); + Value *ReadGlobal = Builder.CreateLoad(Builder.getInt32Ty(), GV); endFunctionWithRet(ReturnGlobal, ReadGlobal); createJIT(std::move(M)); Index: llvm/unittests/IR/IRBuilderTest.cpp =================================================================== --- llvm/unittests/IR/IRBuilderTest.cpp +++ llvm/unittests/IR/IRBuilderTest.cpp @@ -54,7 +54,7 @@ CallInst *Call; IntrinsicInst *II; - V = Builder.CreateLoad(GV); + V = Builder.CreateLoad(GV->getValueType(), GV); I = cast(Builder.CreateFAdd(V, V)); I->setHasNoInfs(true); I->setHasNoNaNs(false); @@ -207,7 +207,7 @@ Value *F, *FC; Instruction *FDiv, *FAdd, *FCmp, *FCall; - F = Builder.CreateLoad(GV); + F = Builder.CreateLoad(GV->getValueType(), GV); F = Builder.CreateFAdd(F, F); EXPECT_FALSE(Builder.getFastMathFlags().any()); @@ -394,7 +394,7 @@ // Test instructions. GlobalVariable *G = new GlobalVariable(*M, Builder.getInt32Ty(), true, GlobalValue::ExternalLinkage, nullptr); - Value *V = Builder.CreateLoad(G); + Value *V = Builder.CreateLoad(G->getValueType(), G); EXPECT_TRUE( cast(Builder.CreateNSWAdd(V, V))->hasNoSignedWrap()); EXPECT_TRUE( @@ -461,7 +461,7 @@ EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal()); EXPECT_EQ(FPMathA, Builder.getDefaultFPMathTag()); - Value *F = Builder.CreateLoad(GV); + Value *F = Builder.CreateLoad(GV->getValueType(), GV); { IRBuilder<>::InsertPointGuard Guard(Builder); Index: llvm/unittests/IR/PatternMatch.cpp =================================================================== --- llvm/unittests/IR/PatternMatch.cpp +++ llvm/unittests/IR/PatternMatch.cpp @@ -397,7 +397,7 @@ // store i32 42, i32* %0 Value *Alloca = IRB.CreateAlloca(IRB.getInt32Ty()); - Value *LoadInst = IRB.CreateLoad(Alloca); + Value *LoadInst = IRB.CreateLoad(IRB.getInt32Ty(), Alloca); Value *FourtyTwo = IRB.getInt32(42); Value *StoreInst = IRB.CreateStore(FourtyTwo, Alloca); Value *MatchLoad, *MatchStoreVal, *MatchStorePointer; Index: llvm/unittests/Linker/LinkModulesTest.cpp =================================================================== --- llvm/unittests/Linker/LinkModulesTest.cpp +++ llvm/unittests/Linker/LinkModulesTest.cpp @@ -83,7 +83,7 @@ GEPIndices.push_back(&*F->arg_begin()); Value *GEP = Builder.CreateGEP(AT, GV, GEPIndices, "switch.gep"); - Value *Load = Builder.CreateLoad(GEP, "switch.load"); + Value *Load = Builder.CreateLoad(AT->getElementType(), GEP, "switch.load"); Builder.CreateRet(Load); Index: llvm/unittests/Transforms/Scalar/LoopPassManagerTest.cpp =================================================================== --- llvm/unittests/Transforms/Scalar/LoopPassManagerTest.cpp +++ llvm/unittests/Transforms/Scalar/LoopPassManagerTest.cpp @@ -908,7 +908,8 @@ ASSERT_THAT(BBI, F.end()); auto CreateCondBr = [&](BasicBlock *TrueBB, BasicBlock *FalseBB, const char *Name, BasicBlock *BB) { - auto *Cond = new LoadInst(&Ptr, Name, /*isVolatile*/ true, BB); + auto *Cond = new LoadInst(Type::getInt1Ty(Context), &Ptr, Name, + /*isVolatile*/ true, BB); BranchInst::Create(TrueBB, FalseBB, Cond, BB); }; @@ -1110,7 +1111,8 @@ ASSERT_THAT(BBI, F.end()); auto CreateCondBr = [&](BasicBlock *TrueBB, BasicBlock *FalseBB, const char *Name, BasicBlock *BB) { - auto *Cond = new LoadInst(&Ptr, Name, /*isVolatile*/ true, BB); + auto *Cond = new LoadInst(Type::getInt1Ty(Context), &Ptr, Name, + /*isVolatile*/ true, BB); BranchInst::Create(TrueBB, FalseBB, Cond, BB); }; @@ -1503,8 +1505,9 @@ auto *NewLoop03BB = BasicBlock::Create(Context, "loop.0.3", &F, &Loop0LatchBB); BranchInst::Create(NewLoop03BB, NewLoop03PHBB); - auto *Cond = new LoadInst(&Ptr, "cond.0.3", /*isVolatile*/ true, - NewLoop03BB); + auto *Cond = + new LoadInst(Type::getInt1Ty(Context), &Ptr, "cond.0.3", + /*isVolatile*/ true, NewLoop03BB); BranchInst::Create(&Loop0LatchBB, NewLoop03BB, Cond, NewLoop03BB); Loop02PHBB.getTerminator()->replaceUsesOfWith(&Loop0LatchBB, NewLoop03PHBB); Index: llvm/unittests/Transforms/Utils/FunctionComparatorTest.cpp =================================================================== --- llvm/unittests/Transforms/Utils/FunctionComparatorTest.cpp +++ llvm/unittests/Transforms/Utils/FunctionComparatorTest.cpp @@ -31,7 +31,7 @@ BB = BasicBlock::Create(Ctx, "", F); B.SetInsertPoint(BB); Argument *PointerArg = &*F->arg_begin(); - LoadInst *LoadInst = B.CreateLoad(PointerArg); + LoadInst *LoadInst = B.CreateLoad(T, PointerArg); C = B.getInt8(addVal); I = cast(B.CreateAdd(LoadInst, C)); B.CreateRet(I);