diff --git a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h --- a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h +++ b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h @@ -80,9 +80,6 @@ LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn, LibFunc &TheLibFunc); - /// Return V if it is an i8*, otherwise cast it to i8*. - Value *castToCStr(Value *V, IRBuilderBase &B); - /// Emit a call to the strlen function to the builder, for the specified /// pointer. Ptr is required to be some pointer type, and the return value has /// 'size_t' type. diff --git a/llvm/lib/CodeGen/AtomicExpandPass.cpp b/llvm/lib/CodeGen/AtomicExpandPass.cpp --- a/llvm/lib/CodeGen/AtomicExpandPass.cpp +++ b/llvm/lib/CodeGen/AtomicExpandPass.cpp @@ -373,10 +373,8 @@ ReplacementIRBuilder Builder(LI, *DL); Value *Addr = LI->getPointerOperand(); - Type *PT = PointerType::get(NewTy, Addr->getType()->getPointerAddressSpace()); - Value *NewAddr = Builder.CreateBitCast(Addr, PT); - auto *NewLI = Builder.CreateLoad(NewTy, NewAddr); + auto *NewLI = Builder.CreateLoad(NewTy, Addr); NewLI->setAlignment(LI->getAlign()); NewLI->setVolatile(LI->isVolatile()); NewLI->setAtomic(LI->getOrdering(), LI->getSyncScopeID()); @@ -398,14 +396,12 @@ Value *Addr = RMWI->getPointerOperand(); Value *Val = RMWI->getValOperand(); - Type *PT = PointerType::get(NewTy, RMWI->getPointerAddressSpace()); - Value *NewAddr = Builder.CreateBitCast(Addr, PT); Value *NewVal = Val->getType()->isPointerTy() ? Builder.CreatePtrToInt(Val, NewTy) : Builder.CreateBitCast(Val, NewTy); auto *NewRMWI = - Builder.CreateAtomicRMW(AtomicRMWInst::Xchg, NewAddr, NewVal, + Builder.CreateAtomicRMW(AtomicRMWInst::Xchg, Addr, NewVal, RMWI->getAlign(), RMWI->getOrdering()); NewRMWI->setVolatile(RMWI->isVolatile()); LLVM_DEBUG(dbgs() << "Replaced " << *RMWI << " with " << *NewRMWI << "\n"); @@ -508,10 +504,8 @@ Value *NewVal = Builder.CreateBitCast(SI->getValueOperand(), NewTy); Value *Addr = SI->getPointerOperand(); - Type *PT = PointerType::get(NewTy, Addr->getType()->getPointerAddressSpace()); - Value *NewAddr = Builder.CreateBitCast(Addr, PT); - StoreInst *NewSI = Builder.CreateStore(NewVal, NewAddr); + StoreInst *NewSI = Builder.CreateStore(NewVal, Addr); NewSI->setAlignment(SI->getAlign()); NewSI->setVolatile(SI->isVolatile()); NewSI->setAtomic(SI->getOrdering(), SI->getSyncScopeID()); @@ -1188,14 +1182,12 @@ ReplacementIRBuilder Builder(CI, *DL); Value *Addr = CI->getPointerOperand(); - Type *PT = PointerType::get(NewTy, Addr->getType()->getPointerAddressSpace()); - Value *NewAddr = Builder.CreateBitCast(Addr, PT); Value *NewCmp = Builder.CreatePtrToInt(CI->getCompareOperand(), NewTy); Value *NewNewVal = Builder.CreatePtrToInt(CI->getNewValOperand(), NewTy); auto *NewCI = Builder.CreateAtomicCmpXchg( - NewAddr, NewCmp, NewNewVal, CI->getAlign(), CI->getSuccessOrdering(), + Addr, NewCmp, NewNewVal, CI->getAlign(), CI->getSuccessOrdering(), CI->getFailureOrdering(), CI->getSyncScopeID()); NewCI->setVolatile(CI->isVolatile()); NewCI->setWeak(CI->isWeak()); diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp --- a/llvm/lib/CodeGen/CodeGenPrepare.cpp +++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp @@ -5493,7 +5493,7 @@ return Modified; } else { Type *I8PtrTy = - Builder.getInt8PtrTy(Addr->getType()->getPointerAddressSpace()); + Builder.getPtrTy(Addr->getType()->getPointerAddressSpace()); Type *I8Ty = Builder.getInt8Ty(); // Start with the base register. Do this first so that subsequent address @@ -6130,7 +6130,7 @@ LLVMContext &Ctx = GEP->getContext(); Type *PtrIdxTy = DL->getIndexType(GEP->getType()); Type *I8PtrTy = - Type::getInt8PtrTy(Ctx, GEP->getType()->getPointerAddressSpace()); + PointerType::get(Ctx, GEP->getType()->getPointerAddressSpace()); Type *I8Ty = Type::getInt8Ty(Ctx); if (!NewBaseGEP) { diff --git a/llvm/lib/CodeGen/LowerEmuTLS.cpp b/llvm/lib/CodeGen/LowerEmuTLS.cpp --- a/llvm/lib/CodeGen/LowerEmuTLS.cpp +++ b/llvm/lib/CodeGen/LowerEmuTLS.cpp @@ -85,7 +85,7 @@ bool LowerEmuTLS::addEmuTlsVar(Module &M, const GlobalVariable *GV) { LLVMContext &C = M.getContext(); - PointerType *VoidPtrType = Type::getInt8PtrTy(C); + PointerType *VoidPtrType = PointerType::getUnqual(C); std::string EmuTlsVarName = ("__emutls_v." + GV->getName()).str(); GlobalVariable *EmuTlsVar = M.getNamedGlobal(EmuTlsVarName); @@ -114,8 +114,7 @@ // void *templ; // 0 or point to __emutls_t.* // sizeof(word) should be the same as sizeof(void*) on target. IntegerType *WordType = DL.getIntPtrType(C); - PointerType *InitPtrType = InitValue ? - PointerType::getUnqual(InitValue->getType()) : VoidPtrType; + PointerType *InitPtrType = PointerType::getUnqual(C); Type *ElementTypes[4] = {WordType, WordType, VoidPtrType, InitPtrType}; ArrayRef ElementTypeArray(ElementTypes, 4); StructType *EmuTlsVarType = StructType::create(ElementTypeArray); diff --git a/llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp b/llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp --- a/llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp +++ b/llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp @@ -70,7 +70,6 @@ bool Changed = false; Type *Int32Ty = Type::getInt32Ty(F.getContext()); - Type *Int32PtrTy = Int32Ty->getPointerTo(); Type *Int8Ty = Type::getInt8Ty(F.getContext()); for (Use &U : llvm::make_early_inc_range(F.uses())) { @@ -81,8 +80,7 @@ IRBuilder<> B(CI); Value *OffsetPtr = B.CreateGEP(Int8Ty, CI->getArgOperand(0), CI->getArgOperand(1)); - Value *OffsetPtrI32 = B.CreateBitCast(OffsetPtr, Int32PtrTy); - Value *OffsetI32 = B.CreateAlignedLoad(Int32Ty, OffsetPtrI32, Align(4)); + Value *OffsetI32 = B.CreateAlignedLoad(Int32Ty, OffsetPtr, Align(4)); Value *ResultPtr = B.CreateGEP(Int8Ty, CI->getArgOperand(0), OffsetI32); diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -1296,9 +1296,8 @@ } Align SelectionDAG::getEVTAlign(EVT VT) const { - Type *Ty = VT == MVT::iPTR ? - PointerType::get(Type::getInt8Ty(*getContext()), 0) : - VT.getTypeForEVT(*getContext()); + Type *Ty = VT == MVT::iPTR ? PointerType::get(*getContext(), 0) + : VT.getTypeForEVT(*getContext()); return getDataLayout().getABITypeAlign(Ty); } @@ -7727,7 +7726,7 @@ // Emit a library call. TargetLowering::ArgListTy Args; TargetLowering::ArgListEntry Entry; - Entry.Ty = Type::getInt8PtrTy(*getContext()); + Entry.Ty = PointerType::getUnqual(*getContext()); Entry.Node = Dst; Args.push_back(Entry); Entry.Node = Src; Args.push_back(Entry); @@ -7829,7 +7828,7 @@ // Emit a library call. TargetLowering::ArgListTy Args; TargetLowering::ArgListEntry Entry; - Entry.Ty = Type::getInt8PtrTy(*getContext()); + Entry.Ty = PointerType::getUnqual(*getContext()); Entry.Node = Dst; Args.push_back(Entry); Entry.Node = Src; Args.push_back(Entry); @@ -7958,14 +7957,14 @@ // If zeroing out and bzero is present, use it. if (SrcIsZero && BzeroName) { TargetLowering::ArgListTy Args; - Args.push_back(CreateEntry(Dst, Type::getInt8PtrTy(Ctx))); + Args.push_back(CreateEntry(Dst, PointerType::getUnqual(Ctx))); Args.push_back(CreateEntry(Size, DL.getIntPtrType(Ctx))); CLI.setLibCallee( TLI->getLibcallCallingConv(RTLIB::BZERO), Type::getVoidTy(Ctx), getExternalSymbol(BzeroName, TLI->getPointerTy(DL)), std::move(Args)); } else { TargetLowering::ArgListTy Args; - Args.push_back(CreateEntry(Dst, Type::getInt8PtrTy(Ctx))); + Args.push_back(CreateEntry(Dst, PointerType::getUnqual(Ctx))); Args.push_back(CreateEntry(Src, Src.getValueType().getTypeForEVT(Ctx))); Args.push_back(CreateEntry(Size, DL.getIntPtrType(Ctx))); CLI.setLibCallee(TLI->getLibcallCallingConv(RTLIB::MEMSET), diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -2775,7 +2775,7 @@ SDValue StackSlotPtr = DAG.getFrameIndex(FI, PtrTy); const Module &M = *ParentBB->getParent()->getFunction().getParent(); Align Align = - DAG.getDataLayout().getPrefTypeAlign(Type::getInt8PtrTy(M.getContext())); + DAG.getDataLayout().getPrefTypeAlign(PointerType::get(M.getContext(), 0)); // Generate code to load the content of the guard slot. SDValue GuardVal = DAG.getLoad( diff --git a/llvm/lib/Target/Hexagon/HexagonISelLowering.cpp b/llvm/lib/Target/Hexagon/HexagonISelLowering.cpp --- a/llvm/lib/Target/Hexagon/HexagonISelLowering.cpp +++ b/llvm/lib/Target/Hexagon/HexagonISelLowering.cpp @@ -3847,11 +3847,6 @@ : Intrinsic::hexagon_L4_loadd_locked; Function *Fn = Intrinsic::getDeclaration(M, IntID); - auto PtrTy = cast(Addr->getType()); - PointerType *NewPtrTy = - Builder.getIntNTy(SZ)->getPointerTo(PtrTy->getAddressSpace()); - Addr = Builder.CreateBitCast(Addr, NewPtrTy); - Value *Call = Builder.CreateCall(Fn, Addr, "larx"); return Builder.CreateBitCast(Call, ValueTy); @@ -3873,8 +3868,6 @@ : Intrinsic::hexagon_S4_stored_locked; Function *Fn = Intrinsic::getDeclaration(M, IntID); - unsigned AS = Addr->getType()->getPointerAddressSpace(); - Addr = Builder.CreateBitCast(Addr, CastTy->getPointerTo(AS)); Val = Builder.CreateBitCast(Val, CastTy); Value *Call = Builder.CreateCall(Fn, {Addr, Val}, "stcx"); diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp --- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp +++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp @@ -17342,10 +17342,8 @@ Module *M = IRB.GetInsertBlock()->getParent()->getParent(); Function *ThreadPointerFunc = Intrinsic::getDeclaration(M, Intrinsic::thread_pointer); - return IRB.CreatePointerCast( - IRB.CreateConstGEP1_32(IRB.getInt8Ty(), - IRB.CreateCall(ThreadPointerFunc), Offset), - IRB.getInt8PtrTy()->getPointerTo(0)); + return IRB.CreateConstGEP1_32(IRB.getInt8Ty(), + IRB.CreateCall(ThreadPointerFunc), Offset); } Value *RISCVTargetLowering::getIRStackGuard(IRBuilderBase &IRB) const { diff --git a/llvm/lib/Target/X86/X86ISelLoweringCall.cpp b/llvm/lib/Target/X86/X86ISelLoweringCall.cpp --- a/llvm/lib/Target/X86/X86ISelLoweringCall.cpp +++ b/llvm/lib/Target/X86/X86ISelLoweringCall.cpp @@ -561,7 +561,7 @@ int Offset, unsigned AddressSpace) { return ConstantExpr::getIntToPtr( ConstantInt::get(Type::getInt32Ty(IRB.getContext()), Offset), - Type::getInt8PtrTy(IRB.getContext())->getPointerTo(AddressSpace)); + IRB.getPtrTy(AddressSpace)); } Value *X86TargetLowering::getIRStackGuard(IRBuilderBase &IRB) const { diff --git a/llvm/lib/Transforms/Coroutines/CoroSplit.cpp b/llvm/lib/Transforms/Coroutines/CoroSplit.cpp --- a/llvm/lib/Transforms/Coroutines/CoroSplit.cpp +++ b/llvm/lib/Transforms/Coroutines/CoroSplit.cpp @@ -811,7 +811,6 @@ auto *ActiveAsyncSuspend = cast(ActiveSuspend); auto ContextIdx = ActiveAsyncSuspend->getStorageArgumentIndex() & 0xff; auto *CalleeContext = NewF->getArg(ContextIdx); - auto *FramePtrTy = Shape.FrameTy->getPointerTo(); auto *ProjectionFunc = ActiveAsyncSuspend->getAsyncContextProjectionFunction(); auto DbgLoc = @@ -831,7 +830,7 @@ auto InlineRes = InlineFunction(*CallerContext, InlineInfo); assert(InlineRes.isSuccess()); (void)InlineRes; - return Builder.CreateBitCast(FramePtrAddr, FramePtrTy); + return FramePtrAddr; } // In continuation-lowering, the argument is the opaque storage. case coro::ABI::Retcon: @@ -841,12 +840,10 @@ // If the storage is inline, just bitcast to the storage to the frame type. if (Shape.RetconLowering.IsFrameInlineInStorage) - return Builder.CreateBitCast(NewStorage, FramePtrTy); + return NewStorage; // Otherwise, load the real frame from the opaque storage. - auto FramePtrPtr = - Builder.CreateBitCast(NewStorage, FramePtrTy->getPointerTo()); - return Builder.CreateLoad(FramePtrTy, FramePtrPtr); + return Builder.CreateLoad(FramePtrTy, NewStorage); } } llvm_unreachable("bad ABI"); @@ -1829,9 +1826,7 @@ Builder.CreateBitCast(RawFramePtr, Shape.CoroBegin->getType()); // Stash the allocated frame pointer in the continuation storage. - auto Dest = Builder.CreateBitCast(Id->getStorage(), - RawFramePtr->getType()->getPointerTo()); - Builder.CreateStore(RawFramePtr, Dest); + Builder.CreateStore(RawFramePtr, Id->getStorage()); } // Map all uses of llvm.coro.begin to the allocated frame pointer. diff --git a/llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp b/llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp --- a/llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp +++ b/llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp @@ -1437,7 +1437,7 @@ IRBuilder<> IRB(&CB); std::vector Args; - Args.push_back(IRB.CreateBitCast(VCallSite.VTable, Int8PtrTy)); + Args.push_back(VCallSite.VTable); llvm::append_range(Args, CB.args()); CallBase *NewCS = nullptr; @@ -1708,8 +1708,7 @@ continue; auto *RetType = cast(Call.CB.getType()); IRBuilder<> B(&Call.CB); - Value *Addr = - B.CreateGEP(Int8Ty, B.CreateBitCast(Call.VTable, Int8PtrTy), Byte); + Value *Addr = B.CreateGEP(Int8Ty, Call.VTable, Byte); if (RetType->getBitWidth() == 1) { Value *Bits = B.CreateLoad(Int8Ty, Addr); Value *BitsAndBit = B.CreateAnd(Bits, Bit); @@ -2007,17 +2006,14 @@ if (TypeCheckedLoadFunc->getIntrinsicID() == Intrinsic::type_checked_load_relative) { Value *GEP = LoadB.CreateGEP(Int8Ty, Ptr, Offset); - Value *GEPPtr = LoadB.CreateBitCast(GEP, PointerType::getUnqual(Int32Ty)); - LoadedValue = LoadB.CreateLoad(Int32Ty, GEPPtr); + LoadedValue = LoadB.CreateLoad(Int32Ty, GEP); LoadedValue = LoadB.CreateSExt(LoadedValue, IntPtrTy); GEP = LoadB.CreatePtrToInt(GEP, IntPtrTy); LoadedValue = LoadB.CreateAdd(GEP, LoadedValue); LoadedValue = LoadB.CreateIntToPtr(LoadedValue, Int8PtrTy); } else { Value *GEP = LoadB.CreateGEP(Int8Ty, Ptr, Offset); - Value *GEPPtr = - LoadB.CreateBitCast(GEP, PointerType::getUnqual(Int8PtrTy)); - LoadedValue = LoadB.CreateLoad(Int8PtrTy, GEPPtr); + LoadedValue = LoadB.CreateLoad(Int8PtrTy, GEP); } for (Instruction *LoadedPtr : LoadedPtrs) { diff --git a/llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp b/llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp --- a/llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp +++ b/llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp @@ -1051,8 +1051,8 @@ FunctionCallee GCOVProfiler::getEmitArcsFunc(const TargetLibraryInfo *TLI) { Type *Args[] = { - Type::getInt32Ty(*Ctx), // uint32_t num_counters - Type::getInt64PtrTy(*Ctx), // uint64_t *counters + Type::getInt32Ty(*Ctx), // uint32_t num_counters + PointerType::getUnqual(*Ctx), // uint64_t *counters }; FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false); return M->getOrInsertFunction("llvm_gcda_emit_arcs", FTy, diff --git a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp --- a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp +++ b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp @@ -4902,7 +4902,7 @@ NextNodeIRBuilder IRB(OrigInst); Value *VAListTag = OrigInst->getArgOperand(0); - Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C); + Type *RegSaveAreaPtrTy = PointerType::getUnqual(*MS.C); // i64* Value *RegSaveAreaPtrPtr = IRB.CreateIntToPtr( IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), ConstantInt::get(MS.IntptrTy, 16)), @@ -4919,7 +4919,7 @@ if (MS.TrackOrigins) IRB.CreateMemCpy(RegSaveAreaOriginPtr, Alignment, VAArgTLSOriginCopy, Alignment, AMD64FpEndOffset); - Type *OverflowArgAreaPtrTy = Type::getInt64PtrTy(*MS.C); + Type *OverflowArgAreaPtrTy = PointerType::getUnqual(*MS.C); // i64* Value *OverflowArgAreaPtrPtr = IRB.CreateIntToPtr( IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), ConstantInt::get(MS.IntptrTy, 8)), @@ -5051,7 +5051,7 @@ CallInst *OrigInst = VAStartInstrumentationList[i]; NextNodeIRBuilder IRB(OrigInst); Value *VAListTag = OrigInst->getArgOperand(0); - Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C); + Type *RegSaveAreaPtrTy = PointerType::getUnqual(*MS.C); // i64* Value *RegSaveAreaPtrPtr = IRB.CreateIntToPtr(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), PointerType::get(RegSaveAreaPtrTy, 0)); @@ -5498,7 +5498,7 @@ CallInst *OrigInst = VAStartInstrumentationList[i]; NextNodeIRBuilder IRB(OrigInst); Value *VAListTag = OrigInst->getArgOperand(0); - Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C); + Type *RegSaveAreaPtrTy = PointerType::getUnqual(*MS.C); // i64* Value *RegSaveAreaPtrPtr = IRB.CreateIntToPtr(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), PointerType::get(RegSaveAreaPtrTy, 0)); @@ -5743,7 +5743,7 @@ void visitVACopyInst(VACopyInst &I) override { unpoisonVAListTagForInst(I); } void copyRegSaveArea(IRBuilder<> &IRB, Value *VAListTag) { - Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C); + Type *RegSaveAreaPtrTy = PointerType::getUnqual(*MS.C); // i64* Value *RegSaveAreaPtrPtr = IRB.CreateIntToPtr( IRB.CreateAdd( IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), @@ -5768,7 +5768,7 @@ } void copyOverflowArea(IRBuilder<> &IRB, Value *VAListTag) { - Type *OverflowArgAreaPtrTy = Type::getInt64PtrTy(*MS.C); + Type *OverflowArgAreaPtrTy = PointerType::getUnqual(*MS.C); // i64* Value *OverflowArgAreaPtrPtr = IRB.CreateIntToPtr( IRB.CreateAdd( IRB.CreatePtrToInt(VAListTag, MS.IntptrTy), diff --git a/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp b/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp --- a/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp +++ b/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp @@ -261,9 +261,7 @@ FunctionCallee SanCovTraceGepFunction; FunctionCallee SanCovTraceSwitchFunction; GlobalVariable *SanCovLowestStack; - Type *Int128PtrTy, *IntptrTy, *IntptrPtrTy, *Int64Ty, *Int64PtrTy, *Int32Ty, - *Int32PtrTy, *Int16PtrTy, *Int16Ty, *Int8Ty, *Int8PtrTy, *Int1Ty, - *Int1PtrTy; + Type *PtrTy, *IntptrTy, *Int64Ty, *Int32Ty, *Int16Ty, *Int8Ty, *Int1Ty; Module *CurModule; std::string CurModuleUniqueId; Triple TargetTriple; @@ -331,11 +329,10 @@ // Account for the fact that on windows-msvc __start_* symbols actually // point to a uint64_t before the start of the array. - auto SecStartI8Ptr = IRB.CreatePointerCast(SecStart, Int8PtrTy); + auto SecStartI8Ptr = IRB.CreatePointerCast(SecStart, PtrTy); auto GEP = IRB.CreateGEP(Int8Ty, SecStartI8Ptr, ConstantInt::get(IntptrTy, sizeof(uint64_t))); - return std::make_pair(IRB.CreatePointerCast(GEP, PointerType::getUnqual(Ty)), - SecEnd); + return std::make_pair(GEP, SecEnd); } Function *ModuleSanitizerCoverage::CreateInitCallsForSections( @@ -345,7 +342,6 @@ auto SecStart = SecStartEnd.first; auto SecEnd = SecStartEnd.second; Function *CtorFunc; - Type *PtrTy = PointerType::getUnqual(Ty); std::tie(CtorFunc, std::ignore) = createSanitizerCtorAndInitFunctions( M, CtorName, InitFunctionName, {PtrTy, PtrTy}, {SecStart, SecEnd}); assert(CtorFunc->getName() == CtorName); @@ -391,15 +387,9 @@ FunctionPCsArray = nullptr; FunctionCFsArray = nullptr; IntptrTy = Type::getIntNTy(*C, DL->getPointerSizeInBits()); - IntptrPtrTy = PointerType::getUnqual(IntptrTy); + PtrTy = PointerType::getUnqual(*C); Type *VoidTy = Type::getVoidTy(*C); IRBuilder<> IRB(*C); - Int128PtrTy = PointerType::getUnqual(IRB.getInt128Ty()); - Int64PtrTy = PointerType::getUnqual(IRB.getInt64Ty()); - Int16PtrTy = PointerType::getUnqual(IRB.getInt16Ty()); - Int32PtrTy = PointerType::getUnqual(IRB.getInt32Ty()); - Int8PtrTy = PointerType::getUnqual(IRB.getInt8Ty()); - Int1PtrTy = PointerType::getUnqual(IRB.getInt1Ty()); Int64Ty = IRB.getInt64Ty(); Int32Ty = IRB.getInt32Ty(); Int16Ty = IRB.getInt16Ty(); @@ -438,26 +428,26 @@ M.getOrInsertFunction(SanCovTraceConstCmp8, VoidTy, Int64Ty, Int64Ty); // Loads. - SanCovLoadFunction[0] = M.getOrInsertFunction(SanCovLoad1, VoidTy, Int8PtrTy); + SanCovLoadFunction[0] = M.getOrInsertFunction(SanCovLoad1, VoidTy, PtrTy); SanCovLoadFunction[1] = - M.getOrInsertFunction(SanCovLoad2, VoidTy, Int16PtrTy); + M.getOrInsertFunction(SanCovLoad2, VoidTy, PtrTy); SanCovLoadFunction[2] = - M.getOrInsertFunction(SanCovLoad4, VoidTy, Int32PtrTy); + M.getOrInsertFunction(SanCovLoad4, VoidTy, PtrTy); SanCovLoadFunction[3] = - M.getOrInsertFunction(SanCovLoad8, VoidTy, Int64PtrTy); + M.getOrInsertFunction(SanCovLoad8, VoidTy, PtrTy); SanCovLoadFunction[4] = - M.getOrInsertFunction(SanCovLoad16, VoidTy, Int128PtrTy); + M.getOrInsertFunction(SanCovLoad16, VoidTy, PtrTy); // Stores. SanCovStoreFunction[0] = - M.getOrInsertFunction(SanCovStore1, VoidTy, Int8PtrTy); + M.getOrInsertFunction(SanCovStore1, VoidTy, PtrTy); SanCovStoreFunction[1] = - M.getOrInsertFunction(SanCovStore2, VoidTy, Int16PtrTy); + M.getOrInsertFunction(SanCovStore2, VoidTy, PtrTy); SanCovStoreFunction[2] = - M.getOrInsertFunction(SanCovStore4, VoidTy, Int32PtrTy); + M.getOrInsertFunction(SanCovStore4, VoidTy, PtrTy); SanCovStoreFunction[3] = - M.getOrInsertFunction(SanCovStore8, VoidTy, Int64PtrTy); + M.getOrInsertFunction(SanCovStore8, VoidTy, PtrTy); SanCovStoreFunction[4] = - M.getOrInsertFunction(SanCovStore16, VoidTy, Int128PtrTy); + M.getOrInsertFunction(SanCovStore16, VoidTy, PtrTy); { AttributeList AL; @@ -470,7 +460,7 @@ SanCovTraceGepFunction = M.getOrInsertFunction(SanCovTraceGep, VoidTy, IntptrTy); SanCovTraceSwitchFunction = - M.getOrInsertFunction(SanCovTraceSwitchName, VoidTy, Int64Ty, Int64PtrTy); + M.getOrInsertFunction(SanCovTraceSwitchName, VoidTy, Int64Ty, PtrTy); Constant *SanCovLowestStackConstant = M.getOrInsertGlobal(SanCovLowestStackName, IntptrTy); @@ -487,7 +477,7 @@ SanCovTracePC = M.getOrInsertFunction(SanCovTracePCName, VoidTy); SanCovTracePCGuard = - M.getOrInsertFunction(SanCovTracePCGuardName, VoidTy, Int32PtrTy); + M.getOrInsertFunction(SanCovTracePCGuardName, VoidTy, PtrTy); for (auto &F : M) instrumentFunction(F, DTCallback, PDTCallback); @@ -510,7 +500,7 @@ if (Ctor && Options.PCTable) { auto SecStartEnd = CreateSecStartEnd(M, SanCovPCsSectionName, IntptrTy); FunctionCallee InitFunction = declareSanitizerInitFunction( - M, SanCovPCsInitName, {IntptrPtrTy, IntptrPtrTy}); + M, SanCovPCsInitName, {PtrTy, PtrTy}); IRBuilder<> IRBCtor(Ctor->getEntryBlock().getTerminator()); IRBCtor.CreateCall(InitFunction, {SecStartEnd.first, SecStartEnd.second}); } @@ -518,7 +508,7 @@ if (Ctor && Options.CollectControlFlow) { auto SecStartEnd = CreateSecStartEnd(M, SanCovCFsSectionName, IntptrTy); FunctionCallee InitFunction = declareSanitizerInitFunction( - M, SanCovCFsInitName, {IntptrPtrTy, IntptrPtrTy}); + M, SanCovCFsInitName, {PtrTy, PtrTy}); IRBuilder<> IRBCtor(Ctor->getEntryBlock().getTerminator()); IRBCtor.CreateCall(InitFunction, {SecStartEnd.first, SecStartEnd.second}); } @@ -744,19 +734,19 @@ IRBuilder<> IRB(&*F.getEntryBlock().getFirstInsertionPt()); for (size_t i = 0; i < N; i++) { if (&F.getEntryBlock() == AllBlocks[i]) { - PCs.push_back((Constant *)IRB.CreatePointerCast(&F, IntptrPtrTy)); + PCs.push_back((Constant *)IRB.CreatePointerCast(&F, PtrTy)); PCs.push_back((Constant *)IRB.CreateIntToPtr( - ConstantInt::get(IntptrTy, 1), IntptrPtrTy)); + ConstantInt::get(IntptrTy, 1), PtrTy)); } else { PCs.push_back((Constant *)IRB.CreatePointerCast( - BlockAddress::get(AllBlocks[i]), IntptrPtrTy)); - PCs.push_back(Constant::getNullValue(IntptrPtrTy)); + BlockAddress::get(AllBlocks[i]), PtrTy)); + PCs.push_back(Constant::getNullValue(PtrTy)); } } - auto *PCArray = CreateFunctionLocalArrayInSection(N * 2, F, IntptrPtrTy, + auto *PCArray = CreateFunctionLocalArrayInSection(N * 2, F, PtrTy, SanCovPCsSectionName); PCArray->setInitializer( - ConstantArray::get(ArrayType::get(IntptrPtrTy, N * 2), PCs)); + ConstantArray::get(ArrayType::get(PtrTy, N * 2), PCs)); PCArray->setConstant(true); return PCArray; @@ -850,7 +840,7 @@ ConstantArray::get(ArrayOfInt64Ty, Initializers), "__sancov_gen_cov_switch_values"); IRB.CreateCall(SanCovTraceSwitchFunction, - {Cond, IRB.CreatePointerCast(GV, Int64PtrTy)}); + {Cond, IRB.CreatePointerCast(GV, PtrTy)}); } } } @@ -895,16 +885,13 @@ : TypeSize == 128 ? 4 : -1; }; - Type *PointerType[5] = {Int8PtrTy, Int16PtrTy, Int32PtrTy, Int64PtrTy, - Int128PtrTy}; for (auto *LI : Loads) { InstrumentationIRBuilder IRB(LI); auto Ptr = LI->getPointerOperand(); int Idx = CallbackIdx(LI->getType()); if (Idx < 0) continue; - IRB.CreateCall(SanCovLoadFunction[Idx], - IRB.CreatePointerCast(Ptr, PointerType[Idx])); + IRB.CreateCall(SanCovLoadFunction[Idx], Ptr); } for (auto *SI : Stores) { InstrumentationIRBuilder IRB(SI); @@ -912,8 +899,7 @@ int Idx = CallbackIdx(SI->getValueOperand()->getType()); if (Idx < 0) continue; - IRB.CreateCall(SanCovStoreFunction[Idx], - IRB.CreatePointerCast(Ptr, PointerType[Idx])); + IRB.CreateCall(SanCovStoreFunction[Idx], Ptr); } } @@ -978,7 +964,7 @@ auto GuardPtr = IRB.CreateIntToPtr( IRB.CreateAdd(IRB.CreatePointerCast(FunctionGuardArray, IntptrTy), ConstantInt::get(IntptrTy, Idx * 4)), - Int32PtrTy); + PtrTy); IRB.CreateCall(SanCovTracePCGuard, GuardPtr)->setCannotMerge(); } if (Options.Inline8bitCounters) { @@ -1008,7 +994,7 @@ Module *M = F.getParent(); Function *GetFrameAddr = Intrinsic::getDeclaration( M, Intrinsic::frameaddress, - IRB.getInt8PtrTy(M->getDataLayout().getAllocaAddrSpace())); + IRB.getPtrTy(M->getDataLayout().getAllocaAddrSpace())); auto FrameAddrPtr = IRB.CreateCall(GetFrameAddr, {Constant::getNullValue(Int32Ty)}); auto FrameAddrInt = IRB.CreatePtrToInt(FrameAddrPtr, IntptrTy); @@ -1059,40 +1045,40 @@ for (auto &BB : F) { // blockaddress can not be used on function's entry block. if (&BB == &F.getEntryBlock()) - CFs.push_back((Constant *)IRB.CreatePointerCast(&F, IntptrPtrTy)); + CFs.push_back((Constant *)IRB.CreatePointerCast(&F, PtrTy)); else CFs.push_back((Constant *)IRB.CreatePointerCast(BlockAddress::get(&BB), - IntptrPtrTy)); + PtrTy)); for (auto SuccBB : successors(&BB)) { assert(SuccBB != &F.getEntryBlock()); CFs.push_back((Constant *)IRB.CreatePointerCast(BlockAddress::get(SuccBB), - IntptrPtrTy)); + PtrTy)); } - CFs.push_back((Constant *)Constant::getNullValue(IntptrPtrTy)); + CFs.push_back((Constant *)Constant::getNullValue(PtrTy)); for (auto &Inst : BB) { if (CallBase *CB = dyn_cast(&Inst)) { if (CB->isIndirectCall()) { // TODO(navidem): handle indirect calls, for now mark its existence. CFs.push_back((Constant *)IRB.CreateIntToPtr( - ConstantInt::get(IntptrTy, -1), IntptrPtrTy)); + ConstantInt::get(IntptrTy, -1), PtrTy)); } else { auto CalledF = CB->getCalledFunction(); if (CalledF && !CalledF->isIntrinsic()) CFs.push_back( - (Constant *)IRB.CreatePointerCast(CalledF, IntptrPtrTy)); + (Constant *)IRB.CreatePointerCast(CalledF, PtrTy)); } } } - CFs.push_back((Constant *)Constant::getNullValue(IntptrPtrTy)); + CFs.push_back((Constant *)Constant::getNullValue(PtrTy)); } FunctionCFsArray = CreateFunctionLocalArrayInSection( - CFs.size(), F, IntptrPtrTy, SanCovCFsSectionName); + CFs.size(), F, PtrTy, SanCovCFsSectionName); FunctionCFsArray->setInitializer( - ConstantArray::get(ArrayType::get(IntptrPtrTy, CFs.size()), CFs)); + ConstantArray::get(ArrayType::get(PtrTy, CFs.size()), CFs)); FunctionCFsArray->setConstant(true); } diff --git a/llvm/lib/Transforms/Scalar/LICM.cpp b/llvm/lib/Transforms/Scalar/LICM.cpp --- a/llvm/lib/Transforms/Scalar/LICM.cpp +++ b/llvm/lib/Transforms/Scalar/LICM.cpp @@ -1055,14 +1055,15 @@ if (LocSizeInBits.isScalable()) return false; - // if the type is i8 addrspace(x)*, we know this is the type of + // if the type is ptr addrspace(x), we know this is the type of // llvm.invariant.start operand - auto *PtrInt8Ty = PointerType::get(Type::getInt8Ty(LI->getContext()), - LI->getPointerAddressSpace()); + auto *PtrASXTy = PointerType::get(LI->getContext(), + LI->getPointerAddressSpace()); unsigned BitcastsVisited = 0; - // Look through bitcasts until we reach the i8* type (this is invariant.start - // operand type). - while (Addr->getType() != PtrInt8Ty) { + // Look through bitcasts until we reach the PtrASXTy type (this is + // invariant.start operand type). + // FIXME: We shouldn't really find such bitcasts with opaque pointers. + while (Addr->getType() != PtrASXTy) { auto *BC = dyn_cast(Addr); // Avoid traversing high number of bitcast uses. if (++BitcastsVisited > MaxNumUsesTraversed || !BC) diff --git a/llvm/lib/Transforms/Scalar/SROA.cpp b/llvm/lib/Transforms/Scalar/SROA.cpp --- a/llvm/lib/Transforms/Scalar/SROA.cpp +++ b/llvm/lib/Transforms/Scalar/SROA.cpp @@ -2489,7 +2489,7 @@ if (!IsVolatile || AddrSpace == NewAI.getType()->getPointerAddressSpace()) return &NewAI; - Type *AccessTy = NewAI.getAllocatedType()->getPointerTo(AddrSpace); + Type *AccessTy = IRB.getPtrTy(AddrSpace); return IRB.CreateAddrSpaceCast(&NewAI, AccessTy); } diff --git a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp --- a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp @@ -1425,11 +1425,6 @@ //- Emit LibCalls ------------------------------------------------------------// -Value *llvm::castToCStr(Value *V, IRBuilderBase &B) { - unsigned AS = V->getType()->getPointerAddressSpace(); - return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr"); -} - static IntegerType *getIntTy(IRBuilderBase &B, const TargetLibraryInfo *TLI) { return B.getIntNTy(TLI->getIntSize()); } @@ -1463,13 +1458,13 @@ const TargetLibraryInfo *TLI) { Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strlen, SizeTTy, - B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI); + B.getInt8PtrTy(), Ptr, B, TLI); } Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B, const TargetLibraryInfo *TLI) { return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(), - castToCStr(Ptr, B), B, TLI); + Ptr, B, TLI); } Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B, @@ -1477,7 +1472,7 @@ Type *I8Ptr = B.getInt8PtrTy(); Type *IntTy = getIntTy(B, TLI); return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, IntTy}, - {castToCStr(Ptr, B), ConstantInt::get(IntTy, C)}, B, TLI); + {Ptr, ConstantInt::get(IntTy, C)}, B, TLI); } Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, @@ -1487,21 +1482,21 @@ return emitLibCall( LibFunc_strncmp, IntTy, {B.getInt8PtrTy(), B.getInt8PtrTy(), SizeTTy}, - {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI); + {Ptr1, Ptr2, Len}, B, TLI); } Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI) { Type *I8Ptr = Dst->getType(); return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr}, - {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI); + {Dst, Src}, B, TLI); } Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI) { Type *I8Ptr = B.getInt8PtrTy(); return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr}, - {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI); + {Dst, Src}, B, TLI); } Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, @@ -1509,7 +1504,7 @@ Type *I8Ptr = B.getInt8PtrTy(); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, SizeTTy}, - {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI); + {Dst, Src, Len}, B, TLI); } Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, @@ -1517,7 +1512,7 @@ Type *I8Ptr = B.getInt8PtrTy(); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, SizeTTy}, - {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI); + {Dst, Src, Len}, B, TLI); } Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, @@ -1535,8 +1530,6 @@ FunctionCallee MemCpy = getOrInsertLibFunc(M, *TLI, LibFunc_memcpy_chk, AttributeList::get(M->getContext(), AS), I8Ptr, I8Ptr, I8Ptr, SizeTTy, SizeTTy); - Dst = castToCStr(Dst, B); - Src = castToCStr(Src, B); CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize}); if (const Function *F = dyn_cast(MemCpy.getCallee()->stripPointerCasts())) @@ -1560,7 +1553,7 @@ Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_memchr, I8Ptr, {I8Ptr, IntTy, SizeTTy}, - {castToCStr(Ptr, B), Val, Len}, B, TLI); + {Ptr, Val, Len}, B, TLI); } Value *llvm::emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, @@ -1570,7 +1563,7 @@ Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_memrchr, I8Ptr, {I8Ptr, IntTy, SizeTTy}, - {castToCStr(Ptr, B), Val, Len}, B, TLI); + {Ptr, Val, Len}, B, TLI); } Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, @@ -1580,7 +1573,7 @@ Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_memcmp, IntTy, {I8Ptr, I8Ptr, SizeTTy}, - {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI); + {Ptr1, Ptr2, Len}, B, TLI); } Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, @@ -1590,7 +1583,7 @@ Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_bcmp, IntTy, {I8Ptr, I8Ptr, SizeTTy}, - {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI); + {Ptr1, Ptr2, Len}, B, TLI); } Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len, @@ -1609,7 +1602,7 @@ Type *I8Ptr = B.getInt8PtrTy(); Type *IntTy = getIntTy(B, TLI); Type *SizeTTy = getSizeTTy(B, TLI); - SmallVector Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)}; + SmallVector Args{Dest, Size, Fmt}; llvm::append_range(Args, VariadicArgs); return emitLibCall(LibFunc_snprintf, IntTy, {I8Ptr, SizeTTy, I8Ptr}, @@ -1621,7 +1614,7 @@ const TargetLibraryInfo *TLI) { Type *I8Ptr = B.getInt8PtrTy(); Type *IntTy = getIntTy(B, TLI); - SmallVector Args{castToCStr(Dest, B), castToCStr(Fmt, B)}; + SmallVector Args{Dest, Fmt}; llvm::append_range(Args, VariadicArgs); return emitLibCall(LibFunc_sprintf, IntTy, {I8Ptr, I8Ptr}, Args, B, TLI, @@ -1632,7 +1625,7 @@ const TargetLibraryInfo *TLI) { return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(), {B.getInt8PtrTy(), B.getInt8PtrTy()}, - {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI); + {Dest, Src}, B, TLI); } Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, @@ -1641,7 +1634,7 @@ Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strlcpy, SizeTTy, {I8Ptr, I8Ptr, SizeTTy}, - {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI); + {Dest, Src, Size}, B, TLI); } Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, @@ -1650,7 +1643,7 @@ Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strlcat, SizeTTy, {I8Ptr, I8Ptr, SizeTTy}, - {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI); + {Dest, Src, Size}, B, TLI); } Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, @@ -1659,7 +1652,7 @@ Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strncat, I8Ptr, {I8Ptr, I8Ptr, SizeTTy}, - {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI); + {Dest, Src, Size}, B, TLI); } Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList, @@ -1670,7 +1663,7 @@ return emitLibCall( LibFunc_vsnprintf, IntTy, {I8Ptr, SizeTTy, I8Ptr, VAList->getType()}, - {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI); + {Dest, Size, Fmt, VAList}, B, TLI); } Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, @@ -1679,7 +1672,7 @@ Type *IntTy = getIntTy(B, TLI); return emitLibCall(LibFunc_vsprintf, IntTy, {I8Ptr, I8Ptr, VAList->getType()}, - {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI); + {Dest, Fmt, VAList}, B, TLI); } /// Append a suffix to the function name according to the type of 'Op'. @@ -1831,7 +1824,7 @@ FunctionCallee PutS = getOrInsertLibFunc(M, *TLI, LibFunc_puts, IntTy, B.getInt8PtrTy()); inferNonMandatoryLibFuncAttrs(M, PutsName, *TLI); - CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName); + CallInst *CI = B.CreateCall(PutS, Str, PutsName); if (const Function *F = dyn_cast(PutS.getCallee()->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); @@ -1870,7 +1863,7 @@ B.getInt8PtrTy(), File->getType()); if (File->getType()->isPointerTy()) inferNonMandatoryLibFuncAttrs(M, FPutsName, *TLI); - CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName); + CallInst *CI = B.CreateCall(F, {Str, File}, FPutsName); if (const Function *Fn = dyn_cast(F.getCallee()->stripPointerCasts())) @@ -1893,7 +1886,7 @@ if (File->getType()->isPointerTy()) inferNonMandatoryLibFuncAttrs(M, FWriteName, *TLI); CallInst *CI = - B.CreateCall(F, {castToCStr(Ptr, B), Size, + B.CreateCall(F, {Ptr, Size, ConstantInt::get(SizeTTy, 1), File}); if (const Function *Fn = diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp --- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -1174,7 +1174,7 @@ return Constant::getNullValue(CI->getType()); // strstr("abcd", "bc") -> gep((char*)"abcd", 1) - Value *Result = castToCStr(CI->getArgOperand(0), B); + Value *Result = CI->getArgOperand(0); Result = B.CreateConstInBoundsGEP1_64(B.getInt8Ty(), Result, Offset, "strstr"); return B.CreateBitCast(Result, CI->getType()); @@ -1522,12 +1522,10 @@ // memcmp(S1,S2,1) -> *(unsigned char*)LHS - *(unsigned char*)RHS if (Len == 1) { - 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"); + Value *LHSV = B.CreateZExt(B.CreateLoad(B.getInt8Ty(), LHS, "lhsc"), + CI->getType(), "lhsv"); + Value *RHSV = B.CreateZExt(B.CreateLoad(B.getInt8Ty(), RHS, "rhsc"), + CI->getType(), "rhsv"); return B.CreateSub(LHSV, RHSV, "chardiff"); } @@ -3066,7 +3064,7 @@ if (!CI->getArgOperand(2)->getType()->isIntegerTy()) return nullptr; Value *V = B.CreateTrunc(CI->getArgOperand(2), B.getInt8Ty(), "char"); - Value *Ptr = castToCStr(Dest, B); + Value *Ptr = Dest; B.CreateStore(V, Ptr); Ptr = B.CreateInBoundsGEP(B.getInt8Ty(), Ptr, B.getInt32(1), "nul"); B.CreateStore(B.getInt8(0), Ptr); @@ -3261,7 +3259,7 @@ if (!CI->getArgOperand(3)->getType()->isIntegerTy()) return nullptr; Value *V = B.CreateTrunc(CI->getArgOperand(3), B.getInt8Ty(), "char"); - Value *Ptr = castToCStr(DstArg, B); + Value *Ptr = DstArg; B.CreateStore(V, Ptr); Ptr = B.CreateInBoundsGEP(B.getInt8Ty(), Ptr, B.getInt32(1), "nul"); B.CreateStore(B.getInt8(0), Ptr); @@ -3397,8 +3395,7 @@ // 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(B.getInt8Ty(), - castToCStr(CI->getArgOperand(0), B), "char"); + Value *Char = B.CreateLoad(B.getInt8Ty(), CI->getArgOperand(0), "char"); Type *IntTy = B.getIntNTy(TLI->getIntSize()); Value *Cast = B.CreateIntCast(Char, IntTy, /*isSigned*/ true, "chari"); Value *NewCI = emitFPutC(Cast, CI->getArgOperand(3), B, TLI);