reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/IR/IRBuilder.h
 2066     return CreateBitCast(V, DestTy, Name);
 2439       Ptr = CreateBitCast(Ptr, Int8PtrTy);
 2452       return CreateBitCast(Fn, PtrType);
 2467       Ptr = CreateBitCast(Ptr, Int8PtrTy);
 2480       return CreateBitCast(Fn, PtrType);
lib/Analysis/LoopAccessAnalysis.cpp
 2233     Value *Start0 = ChkBuilder.CreateBitCast(A.Start, PtrArithTy0, "bc");
 2234     Value *Start1 = ChkBuilder.CreateBitCast(B.Start, PtrArithTy1, "bc");
 2235     Value *End0 =   ChkBuilder.CreateBitCast(A.End,   PtrArithTy1, "bc");
 2236     Value *End1 =   ChkBuilder.CreateBitCast(B.End,   PtrArithTy0, "bc");
lib/Analysis/ScalarEvolutionExpander.cpp
 1066       IncV = Builder.CreateBitCast(IncV, PN->getType());
 1894         V = Builder.CreateBitCast(V, Type::getInt8PtrTy(SE.getContext(), AS));
 1897         V = Builder.CreateBitCast(V, Vty);
 2298     Add = Builder.CreateBitCast(expandAddToGEP(MulS, ARPtrTy, Ty, StartValue),
 2300     Sub = Builder.CreateBitCast(
lib/CodeGen/AtomicExpandPass.cpp
  382   Value *NewAddr = Builder.CreateBitCast(Addr, PT);
  390   Value *NewVal = Builder.CreateBitCast(NewLI, LI->getType());
  464   Value *NewVal = Builder.CreateBitCast(SI->getValueOperand(), NewTy);
  469   Value *NewAddr = Builder.CreateBitCast(Addr, PT);
  508     Addr = Builder.CreateBitCast(Addr, IntTy->getPointerTo(AS));
  509     NewVal = Builder.CreateBitCast(NewVal, IntTy);
  510     Loaded = Builder.CreateBitCast(Loaded, IntTy);
  520     NewLoaded = Builder.CreateBitCast(NewLoaded, OrigTy);
 1063   Value *NewAddr = Builder.CreateBitCast(Addr, PT);
 1706   Value *PtrVal = Builder.CreateBitCast(PointerOperand,
 1718       Builder.CreateBitCast(AllocaCASExpected,
 1735           Builder.CreateBitCast(AllocaValue, Type::getInt8PtrTy(Ctx));
 1748       Builder.CreateBitCast(AllocaResult, Type::getInt8PtrTy(Ctx, AllocaAS));
lib/CodeGen/CodeGenPrepare.cpp
 1006           Builder.CreateBitCast(RelocatedBase, Base->getType());
 1016           Builder.CreateBitCast(Replacement, ToReplace->getType());
 6731     LValue = Builder.CreateBitCast(LBC->getOperand(0), LBC->getType());
 6733     HValue = Builder.CreateBitCast(HBC->getOperand(0), HBC->getType());
 6738     Value *Addr = Builder.CreateBitCast(
lib/CodeGen/ExpandMemCmp.cpp
  268         ByteType, Builder.CreateBitCast(Source, ByteType->getPointerTo()),
  271   return Builder.CreateBitCast(Source, LoadSizeType->getPointerTo());
  572     Source1 = Builder.CreateBitCast(Source1, LoadSizeType->getPointerTo());
  574     Source2 = Builder.CreateBitCast(Source2, LoadSizeType->getPointerTo());
lib/CodeGen/PreISelIntrinsicLowering.cpp
   46     Value *OffsetPtrI32 = B.CreateBitCast(OffsetPtr, Int32PtrTy);
lib/CodeGen/SafeStack.cpp
  556         IRB.CreateBitCast(Off, StackGuardSlot->getType(), "StackGuardSlot");
  574     Value *NewArg = IRB.CreateBitCast(Off, Arg->getType(),
  610       Value *Replacement = IRBUser.CreateBitCast(Off, AI->getType(), Name);
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp
  157   Value *FirstEltPtr = Builder.CreateBitCast(Ptr, NewPtrType);
  181     SclrMask = Builder.CreateBitCast(Mask, SclrMaskTy, "scalar_mask");
  293   Value *FirstEltPtr = Builder.CreateBitCast(Ptr, NewPtrType);
  313     SclrMask = Builder.CreateBitCast(Mask, SclrMaskTy, "scalar_mask");
  431     SclrMask = Builder.CreateBitCast(Mask, SclrMaskTy, "scalar_mask");
  553     SclrMask = Builder.CreateBitCast(Mask, SclrMaskTy, "scalar_mask");
  642     SclrMask = Builder.CreateBitCast(Mask, SclrMaskTy, "scalar_mask");
  750     SclrMask = Builder.CreateBitCast(Mask, SclrMaskTy, "scalar_mask");
lib/CodeGen/SjLjEHPrepare.cpp
  212       Builder.CreateBitCast(PersonalityFn, Builder.getInt8PtrTy()),
  411   Value *FuncCtxArg = Builder.CreateBitCast(FuncCtx, Builder.getInt8PtrTy());
lib/IR/AutoUpgrade.cpp
  877   Op = Builder.CreateBitCast(Op, VecTy, "cast");
  899   return Builder.CreateBitCast(Res, ResultTy, "cast");
  911   Op = Builder.CreateBitCast(Op, VecTy, "cast");
  933   return Builder.CreateBitCast(Res, ResultTy, "cast");
  940   Mask = Builder.CreateBitCast(Mask, MaskTy);
  977   Mask = Builder.CreateBitCast(Mask, MaskTy);
 1087                              : Builder.CreateBitCast(CI.getArgOperand(1),
 1216   Ptr = Builder.CreateBitCast(Ptr,
 1237   Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(ValTy));
 1283   Value *LHS = Builder.CreateBitCast(CI.getArgOperand(0), Ty);
 1284   Value *RHS = Builder.CreateBitCast(CI.getArgOperand(1), Ty);
 1328   return Builder.CreateBitCast(Vec, Builder.getIntNTy(std::max(NumElts, 8U)));
 1682       Value *Addr = Builder.CreateBitCast(Arg0, EltPtrTy, "cast");
 1706       Value *BC = Builder.CreateBitCast(Arg0,
 1724       Value *BC0 = Builder.CreateBitCast(Arg1, NewVecTy, "cast");
 1726       Value *BC = Builder.CreateBitCast(Arg0,
 1742       Arg0 = Builder.CreateBitCast(Arg0,
 1859       Rep = Builder.CreateBitCast(Rep, CI->getType());
 1864       Rep = Builder.CreateBitCast(Rep, CI->getType());
 1870       Rep = Builder.CreateBitCast(Rep, CI->getType());
 1875       Rep = Builder.CreateBitCast(Rep, CI->getType());
 1880       Rep = Builder.CreateBitCast(Rep, CI->getType());
 1886       Rep = Builder.CreateBitCast(Rep, CI->getType());
 1890       Rep = Builder.CreateBitCast(Rep, CI->getType());
 1896       Rep = Builder.CreateBitCast(Rep, Builder.getInt16Ty());
 2128       Value *Ptr = Builder.CreateBitCast(CI->getOperand(0),
 2143       Value *Ptr = Builder.CreateBitCast(CI->getOperand(0),
 2238       Value *Cast = Builder.CreateBitCast(CI->getArgOperand(0),
 2684       Rep = Builder.CreateAnd(Builder.CreateBitCast(CI->getArgOperand(0), ITy),
 2685                               Builder.CreateBitCast(CI->getArgOperand(1), ITy));
 2686       Rep = Builder.CreateBitCast(Rep, FTy);
 2693       Rep = Builder.CreateNot(Builder.CreateBitCast(CI->getArgOperand(0), ITy));
 2695                               Builder.CreateBitCast(CI->getArgOperand(1), ITy));
 2696       Rep = Builder.CreateBitCast(Rep, FTy);
 2703       Rep = Builder.CreateOr(Builder.CreateBitCast(CI->getArgOperand(0), ITy),
 2704                              Builder.CreateBitCast(CI->getArgOperand(1), ITy));
 2705       Rep = Builder.CreateBitCast(Rep, FTy);
 2712       Rep = Builder.CreateXor(Builder.CreateBitCast(CI->getArgOperand(0), ITy),
 2713                               Builder.CreateBitCast(CI->getArgOperand(1), ITy));
 2714       Rep = Builder.CreateBitCast(Rep, FTy);
 3032           Builder.CreateBitCast(Ptr, PointerType::getUnqual(VTy), "cast");
 3413       Value *Ptr = Builder.CreateBitCast(CI->getArgOperand(3),
 3597     Args[2] = Builder.CreateBitCast(Args[2], IntIdxTy);
 3618     Value *BC0 = Builder.CreateBitCast(Arg0, NewVecTy, "cast");
 3619     Value *BC1 = Builder.CreateBitCast(Arg1, NewVecTy, "cast");
 3635     Value *Ptr = Builder.CreateBitCast(CI->getArgOperand(0),
 3902           Arg = Builder.CreateBitCast(Arg, NewFuncTy->getParamType(I));
 3916       Value *NewRetVal = Builder.CreateBitCast(NewCall, CI->getType());
lib/IR/Core.cpp
 3761   return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name));
lib/Target/AArch64/AArch64ISelLowering.cpp
 8825     BaseAddr = Builder.CreateBitCast(
 8853         LdNFunc, Builder.CreateBitCast(BaseAddr, PtrTy), "ldN");
 8965     BaseAddr = Builder.CreateBitCast(
 9015     Ops.push_back(Builder.CreateBitCast(BaseAddr, PtrTy));
12183     Addr = Builder.CreateBitCast(Addr, Type::getInt8PtrTy(M->getContext()));
12205   return Builder.CreateBitCast(Trunc, EltTy);
12231     Addr = Builder.CreateBitCast(Addr, Type::getInt8PtrTy(M->getContext()));
12242   Val = Builder.CreateBitCast(Val, IntValTy);
lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp
  462     Value *const BitCast = B.CreateBitCast(Ballot, VecTy);
  505       NewV = B.CreateBitCast(Insert, Ty);
  604       BroadcastI = B.CreateBitCast(Insert, Ty);
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp
  942     Value *BitCast= Builder.CreateBitCast(I.getPointerOperand(), PT);
  969     Value *ValOrig = Builder.CreateBitCast(ValTrunc, I.getType());
lib/Target/AMDGPU/AMDGPULibCalls.cpp
 1142     sign = B.CreateAnd(B.CreateBitCast(opr0, nTy), sign, "__pow_sign");
 1143     nval = B.CreateOr(B.CreateBitCast(nval, nTy), sign);
 1144     nval = B.CreateBitCast(nval, opr0->getType());
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp
  160     ArgPtr = Builder.CreateBitCast(ArgPtr, AdjustedArgTy->getPointerTo(AS),
  208       Value *NewVal = Builder.CreateBitCast(Trunc, ArgTy,
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp
  245   Value *CastDispatchPtr = Builder.CreateBitCast(
  432       Value *BitCast = Builder.CreateBitCast(Alloca, VecPtrTy);
  447       Value *BitCast = Builder.CreateBitCast(Alloca, VecPtrTy);
lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp
  414         Val = B.CreateBitCast(Val, EffectiveEltTy);
  463     Value *PtrVal = B.CreateBitCast(&Arg, PtrTy);
lib/Target/ARM/ARMISelLowering.cpp
16620     Addr = Builder.CreateBitCast(Addr, Type::getInt8PtrTy(M->getContext()));
16669     Addr = Builder.CreateBitCast(Addr, Type::getInt8PtrTy(M->getContext()));
16780     BaseAddr = Builder.CreateBitCast(
16809     Ops.push_back(Builder.CreateBitCast(BaseAddr, Int8Ptr));
16926     BaseAddr = Builder.CreateBitCast(
16949     Ops.push_back(Builder.CreateBitCast(BaseAddr, Int8Ptr));
lib/Target/ARM/ARMParallelDSP.cpp
  772   Value *VecPtr = IRB.CreateBitCast(Base->getPointerOperand(),
lib/Target/Hexagon/HexagonISelLowering.cpp
 3253   Addr = Builder.CreateBitCast(Addr, NewPtrTy);
 3257   return Builder.CreateBitCast(Call, Ty);
 3276   Addr = Builder.CreateBitCast(Addr, CastTy->getPointerTo(AS));
 3277   Val = Builder.CreateBitCast(Val, CastTy);
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp
 2270                       : CondBuilder.CreateBitCast(StoreBasePtr, Int32PtrTy);
 2273                       : CondBuilder.CreateBitCast(LoadBasePtr, Int32PtrTy);
lib/Target/X86/X86InterleavedAccess.cpp
  206     VecBasePtr = Builder.CreateBitCast(LI->getPointerOperand(), VecBasePtrTy);
  211     VecBasePtr = Builder.CreateBitCast(LI->getPointerOperand(), VecBasePtrTy);
lib/Target/X86/X86WinEHState.cpp
  377   Value *FI8 = Builder.CreateBitCast(F, Type::getInt8PtrTy(F->getContext()));
  412       Builder.CreateBitCast(PersonalityFn, TargetFuncTy->getPointerTo());
  431   Value *HandlerI8 = Builder.CreateBitCast(Handler, Builder.getInt8PtrTy());
  489       Builder.CreateBitCast(CS.getArgOperand(0), Builder.getInt8PtrTy()));
  641   Value *RegNodeI8 = Builder.CreateBitCast(RegNode, Builder.getInt8PtrTy());
  649         Builder.CreateBitCast(EHGuardNode, Builder.getInt8PtrTy());
lib/Transforms/CFGuard/CFGuard.cpp
  175                    {B.CreateBitCast(CalledOperand, B.getInt8PtrTy())});
lib/Transforms/Coroutines/CoroCleanup.cpp
   50   auto *FramePtr = Builder.CreateBitCast(FrameRaw, FramePtrTy);
lib/Transforms/Coroutines/CoroEarly.cpp
  100   auto *BCI = Builder.CreateBitCast(Operand, FramePtrTy);
  138   auto *NoopCoroVoidPtr = Builder.CreateBitCast(NoopCoro, Int8Ptr);
lib/Transforms/Coroutines/CoroFrame.cpp
  593       cast<Instruction>(Builder.CreateBitCast(CB, FramePtrTy, "FramePtr"));
lib/Transforms/Coroutines/CoroSplit.cpp
  626       return Builder.CreateBitCast(NewStorage, FramePtrTy);
  630       Builder.CreateBitCast(NewStorage, FramePtrTy->getPointerTo());
  733   auto *NewVFrame = Builder.CreateBitCast(
  984       auto *VFrame = Builder.CreateBitCast(Frame, Builder.getInt8PtrTy());
 1216       Builder.CreateBitCast(RawFramePtr, Shape.CoroBegin->getType());
 1219     auto Dest = Builder.CreateBitCast(Id->getStorage(),
 1285         Builder.CreateBitCast(ReturnPHIs[0], CastedContinuationTy);
lib/Transforms/Coroutines/Coroutines.cpp
  528     Ptr = Builder.CreateBitCast(Ptr,
lib/Transforms/IPO/MergeFunctions.cpp
  505     return Builder.CreateBitCast(V, DestTy);
lib/Transforms/IPO/WholeProgramDevirt.cpp
 1119       Args.push_back(IRB.CreateBitCast(VCallSite.VTable, Int8PtrTy));
 1125         NewCS = IRB.CreateCall(NewFT, IRB.CreateBitCast(JT, NewFTPtr), Args);
 1128             NewFT, IRB.CreateBitCast(JT, NewFTPtr),
 1305                      B.CreateBitCast(Call.VTable, Int8PtrTy), UniqueMemberAddr);
 1373         B.CreateGEP(Int8Ty, B.CreateBitCast(Call.VTable, Int8PtrTy), Byte);
 1381       Value *ValAddr = B.CreateBitCast(Addr, RetType->getPointerTo());
 1631     Value *GEPPtr = LoadB.CreateBitCast(GEP, PointerType::getUnqual(Int8PtrTy));
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
 2177     Value *BitcastC = Builder.CreateBitCast(C, A->getType());
 2178     Value *BitcastD = Builder.CreateBitCast(D, A->getType());
 2180     return Builder.CreateBitCast(Select, OrigType);
lib/Transforms/InstCombine/InstCombineCalls.cpp
  184   Value *Src = Builder.CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy);
  185   Value *Dest = Builder.CreateBitCast(MI->getArgOperand(0), NewDstPtrTy);
  268     Dest = Builder.CreateBitCast(Dest, NewDstPtrTy);
  633   Value *Res = Builder.CreateBitCast(Arg, IntegerVecTy);
  635   Res = Builder.CreateBitCast(Res, IntegerTy);
  788           Builder.CreateBitCast(Op0, ShufTy),
  790       return Builder.CreateBitCast(SV, II.getType());
  868     Value *SV = Builder.CreateShuffleVector(Builder.CreateBitCast(Op0, ShufTy),
  869                                             Builder.CreateBitCast(Op1, ShufTy),
  871     return Builder.CreateBitCast(SV, II.getType());
 1177     Result = IC.Builder.CreateBitCast(Result, II.getType());
 1319   Value *PtrCast = IC.Builder.CreateBitCast(Ptr, VecPtrTy, "castvec");
 1362   Value *PtrCast = IC.Builder.CreateBitCast(Ptr, VecPtrTy, "castvec");
 1453   auto *BCastInst = Builder.CreateBitCast(II.getArgOperand(0),
 2336       Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0),
 2344     Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0),
 2355       Value *Ptr = Builder.CreateBitCast(II->getArgOperand(1), OpPtrTy);
 2363     Value *Ptr = Builder.CreateBitCast(II->getArgOperand(1), OpPtrTy);
 2372       Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0),
 2382       Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0),
 2395       Value *Ptr = Builder.CreateBitCast(II->getArgOperand(1), OpPtrTy);
 2405       Value *Ptr = Builder.CreateBitCast(II->getArgOperand(1), OpPtrTy);
 2487           Builder.CreateBitCast(VectorHalfAsShorts, VectorHalfType);
 2712           Mask = Builder.CreateBitCast(Mask, MaskTy);
 3081         Value *CastOp0 = Builder.CreateBitCast(Op0, Mask->getType());
 3082         Value *CastOp1 = Builder.CreateBitCast(Op1, Mask->getType());
 3180         Value *Op0 = Builder.CreateBitCast(II->getArgOperand(0),
 3182         Value *Op1 = Builder.CreateBitCast(II->getArgOperand(1),
 4744               NestVal = Builder.CreateBitCast(NestVal, NestTy, "nest");
lib/Transforms/InstCombine/InstCombineCasts.cpp
  153     Value *NewCast = AllocaBuilder.CreateBitCast(New, AI.getType(), "tmpcast");
  483     VecInput = IC.Builder.CreateBitCast(VecInput, VecType, "bc");
 1844     InVal = IC.Builder.CreateBitCast(InVal, SrcTy);
 2050   auto *NewBC = IC.Builder.CreateBitCast(ExtElt->getVectorOperand(),
 2075     Value *CastedOp1 = Builder.CreateBitCast(BO->getOperand(1), DestTy);
 2082     Value *CastedOp0 = Builder.CreateBitCast(BO->getOperand(0), DestTy);
 2093     Value *CastedOp0 = Builder.CreateBitCast(BO->getOperand(0), DestTy);
 2131     Value *CastedVal = Builder.CreateBitCast(FVal, DestTy);
 2138     Value *CastedVal = Builder.CreateBitCast(TVal, DestTy);
 2238         NewV = Builder.CreateBitCast(LI, DestTy);
 2267             cast<BitCastInst>(Builder.CreateBitCast(NewPN, SrcTy));
 2363       Value *Elem = Builder.CreateBitCast(Src, DestVTy->getElementType());
 2427         Value *LHS = Builder.CreateBitCast(ShufOp0, DestTy);
 2428         Value *RHS = Builder.CreateBitCast(ShufOp1, DestTy);
 2447       Value *ScalarX = Builder.CreateBitCast(ShufOp0, DestTy);
 2487     Value *NewBitCast = Builder.CreateBitCast(Src, MidTy);
lib/Transforms/InstCombine/InstCombineCompares.cpp
 2777     Op1 = Builder.CreateBitCast(Op1, BCSrcOp->getType());
 4421           NewOp1 = Builder.CreateBitCast(NewOp1, Op0Src->getType());
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
  463     NewPtr = IC.Builder.CreateBitCast(Ptr, NewTy->getPointerTo(AS));
  485       V, IC.Builder.CreateBitCast(Ptr, V->getType()->getPointerTo(AS)),
lib/Transforms/InstCombine/InstCombineVectorOps.cpp
  236       Scalar = Builder.CreateBitCast(Scalar, SrcIntTy);
 2044               : Builder.CreateBitCast(V, CastSrcTy, SVI.getName() + ".bc");
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
 1242         IRB.CreateBitCast(ShadowAddr, Type::getInt64PtrTy(*DFS.Ctx));
 1345         IRB.CreateBitCast(ShadowAddr, PointerType::getUnqual(ShadowTy));
 1360         IRB.CreateBitCast(ShadowAddr, PointerType::getUnqual(ShadowVecTy));
 1485                  {ValShadow, IRB.CreateBitCast(I.getDest(), Type::getInt8PtrTy(
 1498   DestShadow = IRB.CreateBitCast(DestShadow, Int8Ptr);
 1499   SrcShadow = IRB.CreateBitCast(SrcShadow, Int8Ptr);
 1605                 IRB.CreateBitCast(*i, Type::getInt8PtrTy(*DFSF.DFS.Ctx)));
 1710         IRB.CreateBitCast(CS.getCalledValue(), PointerType::getUnqual(NewFT));
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
  619     Ptr = IRB.CreateBitCast(Ptr, Int8PtrTy);
  801                                    Int8Ty, IRB.CreateBitCast(AI, Int8PtrTy),
 1486          P.first ? IRB.CreateBitCast(P.first, Int8PtrTy)
 1488          IRB.CreateBitCast(UnwindGetGR.getCallee(), Int8PtrTy),
 1489          IRB.CreateBitCast(UnwindGetCFA.getCallee(), Int8PtrTy)});
lib/Transforms/Instrumentation/InstrProfiling.cpp
  615                       Builder.CreateBitCast(DataVar, Builder.getInt8PtrTy()),
  621         Builder.CreateBitCast(DataVar, Builder.getInt8PtrTy()),
  964       IRB.CreateCall(RuntimeRegisterF, IRB.CreateBitCast(Data, VoidPtrTy));
  973     IRB.CreateCall(NamesRegisterF, {IRB.CreateBitCast(NamesVar, VoidPtrTy),
lib/Transforms/Instrumentation/MemorySanitizer.cpp
 1379     return IRB.CreateBitCast(V, NoVecTy);
 1909     setShadow(&I, IRB.CreateBitCast(getShadow(&I, 0), getShadowTy(&I)));
 2097     Value *V1 = IRB.CreateBitCast(V, Type::getIntNTy(*MS.C, srcSizeInBits));
 2100     return IRB.CreateBitCast(V2, dstTy);
 2112       return IRB.CreateBitCast(V, ShadowTy);
 2724                                   {IRB.CreateBitCast(S1, V1->getType()), V2});
 2725     Shift = IRB.CreateBitCast(Shift, getShadowTy(&I));
 2790       S1 = IRB.CreateBitCast(S1, T);
 2791       S2 = IRB.CreateBitCast(S2, T);
 2799       S1_ext = IRB.CreateBitCast(S1_ext, X86_MMXTy);
 2800       S2_ext = IRB.CreateBitCast(S2_ext, X86_MMXTy);
 2808     if (isX86_MMX) S = IRB.CreateBitCast(S, getShadowTy(&I));
 2823     S = IRB.CreateBitCast(S, ResTy);
 2827     S = IRB.CreateBitCast(S, getShadowTy(&I));
 2839     S = IRB.CreateBitCast(S, ResTy);
 2842     S = IRB.CreateBitCast(S, getShadowTy(&I));
 3543         B = IRB.CreateICmpNE(IRB.CreateBitCast(B, FlatTy),
 3545         Sb = IRB.CreateICmpNE(IRB.CreateBitCast(Sb, FlatTy),
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
 1649       Builder.CreateBitCast(Relocate,
lib/Transforms/Scalar/SROA.cpp
 1658       Int8Ptr = IRB.CreateBitCast(
 1776       return IRB.CreateIntToPtr(IRB.CreateBitCast(V, DL.getIntPtrType(NewTy)),
 1781       return IRB.CreateIntToPtr(IRB.CreateBitCast(V, DL.getIntPtrType(NewTy)),
 1792       return IRB.CreateBitCast(IRB.CreatePtrToInt(V, DL.getIntPtrType(OldTy)),
 1797       return IRB.CreateBitCast(IRB.CreatePtrToInt(V, DL.getIntPtrType(OldTy)),
 1803   return IRB.CreateBitCast(V, NewTy);
lib/Transforms/Scalar/Scalarizer.cpp
  265       CV[0] = Builder.CreateBitCast(V, NewPtrTy, V->getName() + ".i0");
  677       Res[I] = Builder.CreateBitCast(Op0[I], DstVT->getElementType(),
  693       V = Builder.CreateBitCast(V, MidTy, V->getName() + ".cast");
  709       Res[ResI] = Builder.CreateBitCast(V, DstVT->getElementType(),
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp
  829     ResultPtr = Builder.CreateBitCast(ResultPtr, I8PtrTy);
  878     ResultPtr = Builder.CreateBitCast(ResultPtr, Variadic->getType());
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp
  673         Reduced = Builder.CreateBitCast(Basis.Ins, CharTy);
  679         Reduced = Builder.CreateBitCast(Reduced, C.Ins->getType());
lib/Transforms/Utils/BuildLibCalls.cpp
  824   return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
lib/Transforms/Utils/CallPromotionUtils.cpp
  266     Callee = Builder.CreateBitCast(Callee, CS.getCalledValue()->getType());
lib/Transforms/Utils/InlineFunction.cpp
 2200       Builder.CreateRet(Builder.CreateBitCast(ReturnedMustTail, NewRetTy));
lib/Transforms/Utils/LowerMemIntrinsics.cpp
   63       SrcAddr = PLBuilder.CreateBitCast(SrcAddr, SrcOpType);
   66       DstAddr = PLBuilder.CreateBitCast(DstAddr, DstOpType);
  114                              : RBuilder.CreateBitCast(SrcAddr, SrcPtrType);
  123                              : RBuilder.CreateBitCast(DstAddr, DstPtrType);
  159     SrcAddr = PLBuilder.CreateBitCast(SrcAddr, SrcOpType);
  162     DstAddr = PLBuilder.CreateBitCast(DstAddr, DstOpType);
  231         ResBuilder.CreateBitCast(SrcAddr, PointerType::get(Int8Type, SrcAS));
  233         ResBuilder.CreateBitCast(DstAddr, PointerType::get(Int8Type, DstAS));
  383   DstAddr = Builder.CreateBitCast(DstAddr,
lib/Transforms/Utils/SimplifyLibCalls.cpp
  839     return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
  867     return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
  880     return B.CreateBitCast(Result, CI->getType());
  886     return StrChr ? B.CreateBitCast(StrChr, CI->getType()) : nullptr;
 1030         LHSV = B.CreateLoad(IntType, B.CreateBitCast(LHS, LHSPtrTy), "lhsv");
 1035         RHSV = B.CreateLoad(IntType, B.CreateBitCast(RHS, RHSPtrTy), "rhsv");
lib/Transforms/Utils/VNCoercion.cpp
   71       StoredVal = Helper.CreateBitCast(StoredVal, LoadedTy);
   84         StoredVal = Helper.CreateBitCast(StoredVal, TypeToCastTo);
  112     StoredVal = Helper.CreateBitCast(StoredVal, StoredValTy);
  134       StoredVal = Helper.CreateBitCast(StoredVal, LoadedTy);
  365     SrcVal = Helper.CreateBitCast(SrcVal, IntegerType::get(Ctx, StoreSize * 8));
  431     PtrVal = Builder.CreateBitCast(PtrVal, DestPTy);
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp
 1056           Extract = Builder.CreateBitCast(Extract, StoreTy->getScalarType());
 1079     Builder.CreateBitCast(S0->getPointerOperand(), VecTy->getPointerTo(AS)),
 1195       Builder.CreateBitCast(L0->getPointerOperand(), VecTy->getPointerTo(AS));
 1213           V = Builder.CreateBitCast(V, UI->getType());
lib/Transforms/Vectorize/LoopVectorize.cpp
 2223     NewPtrs.push_back(Builder.CreateBitCast(NewPtr, PtrTy));
 2418     return Builder.CreateBitCast(PartPtr, DataTy->getPointerTo(AddressSpace));
lib/Transforms/Vectorize/SLPVectorizer.cpp
 3830         Value *Ptr = Builder.CreateBitCast(LI->getOperand(0), PtrTy);
 4021       Value *VecPtr = Builder.CreateBitCast(LI->getPointerOperand(),
 4061       Value *VecPtr = Builder.CreateBitCast(ScalarPtr, VecTy->getPointerTo(AS));
tools/clang/lib/CodeGen/CGAtomic.cpp
  733     Address Ptr = Address(CGF.Builder.CreateBitCast(Val, IPtrTy), Align);
 1404       return RValue::get(CGF.Builder.CreateBitCast(IntVal, ValTy));
 1590         return CGF.Builder.CreateBitCast(Value, InputIntTy);
tools/clang/lib/CodeGen/CGBlocks.cpp
 1092         byrefPointer = Builder.CreateBitCast(src.getPointer(), VoidPtrTy);
 1790       BlockVarAddr = CGF.Builder.CreateBitCast(BlockVarAddr, CGF.VoidPtrTy);
 2104       srcValue = Builder.CreateBitCast(srcValue, VoidPtrTy);
 2106           Builder.CreateBitCast(dstField.getPointer(), VoidPtrTy);
 2928     Builder.CreateBitCast(V, Int8PtrTy),
tools/clang/lib/CodeGen/CGBuilder.h
  143     return Address(CreateBitCast(Addr.getPointer(), Ty, Name),
tools/clang/lib/CodeGen/CGBuiltin.cpp
  135   Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
  151   Value *BC = CGF.Builder.CreateBitCast(
  199   Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
  236   Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
  328   Ptr = CGF.Builder.CreateBitCast(Ptr, ITy->getPointerTo());
  342   Ptr = CGF.Builder.CreateBitCast(Ptr, ITy->getPointerTo());
  422   V = CGF.Builder.CreateBitCast(V, IntTy);
  534         Builder.CreateBitCast(ArgValue, DestType, ArgValue->getName().data());
 1806     DstPtr = Builder.CreateBitCast(DstPtr, Type);
 1807     SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
 2124       ArgValue = Builder.CreateBitCast(ArgValue, ConvertType(ArgType));
 2677     Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
 2845     Ptr = Builder.CreateBitCast(Ptr, ITy->getPointerTo());
 2901     Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
 3403       Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), IntPtrType);
 4099     DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), BPP, "cp"),
 4101     SrcAddr = Address(Builder.CreateBitCast(SrcAddr.getPointer(), BPP, "ap"),
 4190         ArgValue = Builder.CreateBitCast(ArgValue, PTy);
 4214       V = Builder.CreateBitCast(V, RetTy);
 4350       Ops[j] = Builder.CreateBitCast(Ops[j], ai->getType(), name);
 4370   Vec = Builder.CreateBitCast(Vec, Ty);
 5232   return CGF.Builder.CreateBitCast(Result, ResultType, s);
 5284     Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
 5285     Ops[1] = Builder.CreateBitCast(Ops[1], SrcTy);
 5352     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 5359     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 5403     Ops[0] = Builder.CreateBitCast(Ops[0], GetFloatNeonType(this, Type));
 5465     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 5466     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 5472     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 5473     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 5474     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 5492     Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
 5497     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 5517     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 5539       Ops[I] = Builder.CreateBitCast(Ops[I], Ty);
 5543     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 5548     Ops[0] = Builder.CreateBitCast(Ops[0], DTy);
 5555     Ops[0] = Builder.CreateBitCast(Ops[0], QTy);
 5621     return Builder.CreateShl(Builder.CreateBitCast(Ops[0],Ty), Ops[1],
 5625     Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
 5635     Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
 5686     Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
 5687     Ops[1] = Builder.CreateBitCast(Ops[1], SrcTy);
 5700     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 5701     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 5702     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 5719     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 5720     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 5728     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 5729     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 5730     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 5746     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 5747     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 5748     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 5810   return Builder.CreateBitCast(Result, ResultType, NameHint);
 5825   Op = Builder.CreateBitCast(Op, OTy);
 6145     return Builder.CreateBitCast(RtAndRt2, ConvertType(E->getType()));
 6168     Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
 6179     return Builder.CreateBitCast(Val, ConvertType(E->getType()));
 6190     LoadAddr = Builder.CreateBitCast(LoadAddr, PtrTy);
 6204       return Builder.CreateBitCast(Val, RealResTy);
 6226     Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), Int8PtrTy);
 6238     StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
 6246       StoreVal = Builder.CreateBitCast(StoreVal, IntTy);
 6676       Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 6693     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 6722     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 6723     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 6739     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 6746       Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 6756     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 7040   Op = Builder.CreateBitCast(Op, Int16Ty);
 7160     Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
 7172     return Builder.CreateBitCast(Val, ConvertType(E->getType()));
 7181     LoadAddr = Builder.CreateBitCast(LoadAddr, PtrTy);
 7195     return Builder.CreateBitCast(Val, RealResTy);
 7214     Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)),
 7227     StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
 7235       StoreVal = Builder.CreateBitCast(StoreVal, IntTy);
 7510     Value *Ptr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), Int128PTy);
 7516     Value *Ptr = Builder.CreateBitCast(Ops[0], Int128PTy);
 7529     Ops[0] = Builder.CreateBitCast(Ops[0], FTy);
 7544     Ops[0] = Builder.CreateBitCast(Ops[0], InTy);
 7566     Ops[0] = Builder.CreateBitCast(Ops[0], InTy);
 7576     Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
 7586     Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
 7596     Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
 7700     Vec = Builder.CreateBitCast(Vec, Ty, "v2i64");
 7713     Vec = Builder.CreateBitCast(Vec, Ty, "v2f64");
 7726     Vec = Builder.CreateBitCast(Vec, Ty, "v2f32");
 7777     Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
 7797     Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
 7798     Ops[1] = Builder.CreateBitCast(Ops[1], DoubleTy);
 7817     Ops[0] = Builder.CreateBitCast(Ops[0], FloatTy);
 7818     Ops[1] = Builder.CreateBitCast(Ops[1], FloatTy);
 7837     Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
 7838     Ops[1] = Builder.CreateBitCast(Ops[1], HalfTy);
 7867     Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
 7868     Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
 7875     Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
 7876     Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
 7896     Ops[1] = Builder.CreateBitCast(Ops[1],
 7902     Ops[1] = Builder.CreateBitCast(Ops[1],
 7909     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int8Ty, 8));
 7914     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int8Ty, 16));
 7919     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int16Ty, 4));
 7924     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int16Ty, 8));
 7929     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 2));
 7933     Ops[0] = Builder.CreateBitCast(Ops[0],
 7939     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 4));
 7944     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 1));
 7948     Ops[0] = Builder.CreateBitCast(Ops[0],
 7954     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 2));
 7958     Ops[0] = Builder.CreateBitCast(Ops[0],
 7963     Ops[0] = Builder.CreateBitCast(Ops[0],
 7969     Ops[0] = Builder.CreateBitCast(Ops[0],
 7975     Ops[0] = Builder.CreateBitCast(Ops[0],
 8056     Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
 8060     return Builder.CreateAdd(Ops[0], Builder.CreateBitCast(Ops[1], Int64Ty));
 8339     Ops[0] = Builder.CreateBitCast(Ops[0], BitTy, "vbsl");
 8340     Ops[1] = Builder.CreateBitCast(Ops[1], BitTy, "vbsl");
 8341     Ops[2] = Builder.CreateBitCast(Ops[2], BitTy, "vbsl");
 8346     return Builder.CreateBitCast(Ops[0], Ty);
 8365     Ops[1] = Builder.CreateBitCast(Ops[1], SourceTy);
 8376       Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
 8377       Ops[1] = Builder.CreateBitCast(Ops[1], DoubleTy);
 8380       Ops[2] = Builder.CreateBitCast(Ops[2], VTy);
 8384       return Builder.CreateBitCast(Result, Ty);
 8387     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 8388     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 8392     Ops[2] = Builder.CreateBitCast(Ops[2], STy);
 8401     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 8402     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 8404     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 8466     llvm::Value *addend = Builder.CreateBitCast(Ops[0], tmp->getType());
 8597     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 8605     Ops[0] = Builder.CreateBitCast(Ops[0], GetNeonType(this, SrcFlag));
 8613     Ops[0] = Builder.CreateBitCast(Ops[0], GetNeonType(this, SrcFlag));
 8629     Ops[0] = Builder.CreateBitCast(Ops[0], GetFloatNeonType(this, Type));
 8719     Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
 8722     Ops[1] = Builder.CreateBitCast(Ops[1], VTy);
 8725     return Builder.CreateBitCast(Result, Ty);
 8749     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 9023     Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
 9024     Value *RHS = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), DoubleTy);
 9109     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 9120     Ops[0] = Builder.CreateBitCast(Ops[0], VTy);
 9125     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
 9132     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
 9133     Ops[1] = Builder.CreateBitCast(Ops[1], VTy);
 9137     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 9139     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 9150     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 9161     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 9165                                              Builder.CreateBitCast(Ops[0], Ty));
 9169     Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
 9173     Ops[0] = Builder.CreateBitCast(Ops[0],
 9180     Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
 9184     Ops[0] = Builder.CreateBitCast(Ops[0],
 9191     Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
 9195     Ops[0] = Builder.CreateBitCast(Ops[0],
 9203     Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
 9207     Ops[0] = Builder.CreateBitCast(Ops[0],
 9215     Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
 9219     Ops[0] = Builder.CreateBitCast(Ops[0],
 9227     Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
 9231     Ops[0] = Builder.CreateBitCast(Ops[0],
 9241     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 9242     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 9246     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 9255     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 9256     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 9257     Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
 9261     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 9270     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 9271     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 9272     Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
 9273     Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
 9277     Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
 9333     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 9334     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 9335     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 9352     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 9353     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 9354     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 9370     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 9371     Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
 9372     Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
 9495   Value *MaskVec = CGF.Builder.CreateBitCast(Mask, MaskTy);
 9514   Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
 9526   Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
 9541   Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
 9572   Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
 9593   return CGF.Builder.CreateBitCast(CGF.Builder.CreateBinOp(Opc, LHS, RHS),
 9678   Mask = CGF.Builder.CreateBitCast(Mask, MaskTy);
 9701   return CGF.Builder.CreateBitCast(Cmp,
 9935   Value *LHS = CGF.Builder.CreateBitCast(Ops[0], Ty);
 9936   Value *RHS = CGF.Builder.CreateBitCast(Ops[1], Ty);
10018   Value *BitCast = CGF.Builder.CreateBitCast(Shl, ResultType);
10210     return Builder.CreateBitCast(Sext, FPVecTy);
10273     return Builder.CreateBitCast(BuildVector(Ops),
10312                           Builder.CreateBitCast(Tmp.getPointer(), Int8PtrTy));
10318                        Builder.CreateBitCast(Tmp.getPointer(), Int8PtrTy));
11253     Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast");
11258     return Builder.CreateBitCast(SV, Ops[0]->getType(), "cast");
11283     Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast");
11288     return Builder.CreateBitCast(SV, ResultType, "cast");
11310     return Builder.CreateBitCast(SV, Ops[0]->getType());
11332     return Builder.CreateBitCast(SV, Ops[0]->getType());
11350     Value *BC = Builder.CreateBitCast(
11550     return Builder.CreateBitCast(Res, Ops[0]->getType());
11583     return Builder.CreateBitCast(Builder.CreateNot(Res),
11595     return Builder.CreateBitCast(Res, Ops[0]->getType());
11618     return Builder.CreateBitCast(Res, Ops[0]->getType());
11818     Ops[0] = Builder.CreateBitCast(Ops[0], MMXTy, "cast");
12273         Builder.CreateBitCast(Ops[0], Int128PtrTy);
12276     Address ComparandResult(Builder.CreateBitCast(Ops[3], Int128PtrTy),
12413       Ops[0] = Builder.CreateBitCast(Ops[0], Int8PtrTy);
12415       Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
12481       Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
12483       Ops[2] = Builder.CreateBitCast(Ops[2], Int8PtrTy);
12674     Ops[1] = Builder.CreateBitCast(Ops[1], llvm::VectorType::get(Int64Ty, 2));
12684       Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 2));
12692     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 4));
12701     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 2));
12738     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 2));
12739     Ops[1] = Builder.CreateBitCast(Ops[1], llvm::VectorType::get(Int64Ty, 2));
12755     return Builder.CreateBitCast(ShuffleCall, RetTy);
12762     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 4));
12763     Ops[1] = Builder.CreateBitCast(Ops[1], llvm::VectorType::get(Int32Ty, 4));
12796     return Builder.CreateBitCast(ShuffleCall, RetTy);
12807     return Builder.CreateBitCast(Res, ConvertType(E->getType()));
12812     Value *Unpacked = Builder.CreateBitCast(
13930             Builder.CreateBitCast(Builder.CreateExtractValue(Result, i),
13970       Values.push_back(Builder.CreateBitCast(V, ParamType));
14030       Values.push_back(Builder.CreateBitCast(V, AType));
14039       Values.push_back(Builder.CreateBitCast(V, BType));
14049       Values.push_back(Builder.CreateBitCast(V, CType));
14055           Builder.CreateBitCast(Builder.CreateExtractValue(Result, i), DType),
14455     BP = Address(Builder.CreateBitCast(BP.getPointer(), Int8PtrPtrTy),
14468     llvm::Value *LV = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)),
14480     BP = Address(Builder.CreateBitCast(BP.getPointer(), Int8PtrPtrTy),
14492     llvm::Value *LV = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)),
14508         Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), Int8PtrTy);
14514     DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), Int8PtrTy),
14533         Builder.CreateBitCast(DestAddress, DestVal->getType()->getPointerTo());
14557     llvm::Value *Base = Builder.CreateBitCast(EmitScalarExpr(E->getArg(2)),
14579     llvm::Value *Base = Builder.CreateBitCast(EmitScalarExpr(E->getArg(2)),
tools/clang/lib/CodeGen/CGCUDANV.cpp
  425         Builder.CreateBitCast(I.Kernel, VoidPtrTy),
  453         Builder.CreateBitCast(Var, VoidPtrTy),
  650           CtorBuilder.CreateBitCast(FatbinWrapper, VoidPtrTy));
  668         CtorBuilder.CreateBitCast(FatbinWrapper, VoidPtrTy));
  710                            CtorBuilder.CreateBitCast(FatbinWrapper, VoidPtrTy),
tools/clang/lib/CodeGen/CGCXX.cpp
  255   VTable = CGF.Builder.CreateBitCast(VTable, Ty);
tools/clang/lib/CodeGen/CGCall.cpp
 1106       V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRCallArgPos));
 1172       return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val");
 2439           V = Builder.CreateBitCast(V, ArgI.getCoerceToType());
 2450           V = Builder.CreateBitCast(V, LTy);
 2670   return CGF.Builder.CreateBitCast(result, resultType);
 2707   return CGF.Builder.CreateBitCast(load, resultType);
 3139   value = CGF.Builder.CreateBitCast(value, srcAddr.getElementType(),
 3295     src = CGF.Builder.CreateBitCast(src, destType->getElementType(),
 4073           V = Builder.CreateBitCast(V, IRFuncTy->getParamType(FirstIRArg));
 4203           Builder.CreateBitCast(CalleePtr, IRFuncTy->getPointerTo(CalleeAS));
 4220         Arg = Builder.CreateBitCast(Arg, LastParamTy);
 4533             V = Builder.CreateBitCast(V, RetIRTy);
tools/clang/lib/CodeGen/CGClass.cpp
  250   ptr = CGF.Builder.CreateBitCast(ptr, CGF.Int8Ty->getPointerTo(AddrSpace));
  412   llvm::Value *Value = Builder.CreateBitCast(BaseAddr.getPointer(), Int8PtrTy);
  417   Value = Builder.CreateBitCast(Value, DerivedPtrTy);
 1640    llvm::Value *Args[] = {CGF.Builder.CreateBitCast(Ptr, CGF.VoidPtrTy),
 1717           CGF.Builder.CreateBitCast(CGF.LoadCXXThis(), CGF.Int8PtrTy),
 2495   VTableAddressPoint = Builder.CreateBitCast(VTableAddressPoint, VTablePtrTy);
 2650     llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
 2758   llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
 2815   llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
 2830   return Builder.CreateBitCast(
tools/clang/lib/CodeGen/CGDecl.cpp
  582         CGF.Builder.CreateBitCast(Addr, CGF.ConvertType(ArgTy));
 1295   Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
 1306   Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
tools/clang/lib/CodeGen/CGException.cpp
 1084     typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy);
 1746       Builder.CreateBitCast(RecoverCall, ParentVar.getType());
 1941     SEHInfo = Builder.CreateBitCast(SEHInfo, Int8PtrTy->getPointerTo());
 1956   llvm::Value *Ptrs = Builder.CreateBitCast(SEHInfo, PtrsTy->getPointerTo());
tools/clang/lib/CodeGen/CGExpr.cpp
   59   return Builder.CreateBitCast(value, destType);
  731       llvm::Value *CastAddr = Builder.CreateBitCast(Ptr, Int8PtrTy);
  812       Address VPtrAddr(Builder.CreateBitCast(Ptr, VPtrTy), getPointerAlign());
 2289   return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name);
 2845       V = Builder.CreateBitCast(V, llvm::Type::getIntNTy(getLLVMContext(),
 3079       Args.push_back(Builder.CreateBitCast(InfoPtr, Int8PtrTy));
 3146         SlowPathFn, {TypeId, Ptr, Builder.CreateBitCast(InfoPtr, Int8PtrTy)});
 4806       llvm::Value *CalleePrefixStruct = Builder.CreateBitCast(
 4856     llvm::Value *CastedCallee = Builder.CreateBitCast(CalleePtr, Int8PtrTy);
 4878     Args.add(RValue::get(Builder.CreateBitCast(Chain, CGM.VoidPtrTy)),
 4938     CalleePtr = Builder.CreateBitCast(CalleePtr, CalleeTy, "callee.knr.cast");
tools/clang/lib/CodeGen/CGExprAgg.cpp
 1681       outerBegin = Builder.CreateBitCast(outerBegin, element->getType());
tools/clang/lib/CodeGen/CGExprCXX.cpp
 1085           Builder.CreateBitCast(CurPtr.getPointer(), BeginPtr.getType());
 1768   llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
 2150     return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy);
 2163   return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(OperandTy),
tools/clang/lib/CodeGen/CGExprScalar.cpp
  483     return Builder.CreateBitCast(V, ConvertType(E->getType()));
 1262       return Builder.CreateBitCast(Src, DstTy, "conv");
 1299       return Builder.CreateBitCast(Src, DstTy, "conv");
 2035     return Builder.CreateBitCast(Src, DstTy);
 2462       value = Builder.CreateBitCast(value, input->getType());
 2556     value = Builder.CreateBitCast(value, input->getType());
 3230     Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
 3232     return CGF.Builder.CreateBitCast(result, pointer->getType());
 3261     Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
 3263     return CGF.Builder.CreateBitCast(result, pointer->getType());
 4216       RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
 4217       LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
 4225       tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
 4365     return Builder.CreateBitCast(Src, DstTy, Name);
 4382     Src = Builder.CreateBitCast(Src, DL.getIntPtrType(DstTy));
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp
  358     DstArrayEnd = CGF.Builder.CreateBitCast(DstArrayEnd, CGF.CGM.Int8PtrPtrTy,
tools/clang/lib/CodeGen/CGObjC.cpp
  103     llvm::Value *Cast = Builder.CreateBitCast(GV, ConvertType(EncodingQT));
  113   return Builder.CreateBitCast(result.getScalarVal(),
  138     return Builder.CreateBitCast(Ptr, ConvertType(E->getType()));
  236   return Builder.CreateBitCast(result.getScalarVal(),
  277   return RValue::get(CGF.Builder.CreateBitCast(Result.getScalarVal(),
  636     newSelf = Builder.CreateBitCast(newSelf, selfTy);
 1007   ivarAddr = CGF.Builder.CreateBitCast(ivarAddr, CGF.Int8PtrTy);
 1103     llvm::Value *self = Builder.CreateBitCast(LoadObjCSelf(), VoidPtrTy);
 1126     RV = RValue::get(Builder.CreateBitCast(
 1183         value = Builder.CreateBitCast(
 1210   ivarAddr = CGF.Builder.CreateBitCast(ivarAddr, CGF.Int8PtrTy);
 1219   argAddr = CGF.Builder.CreateBitCast(argAddr, CGF.Int8PtrTy);
 1256   ivarAddr = CGF.Builder.CreateBitCast(ivarAddr, CGF.Int8PtrTy);
 1265   argAddr = CGF.Builder.CreateBitCast(argAddr, CGF.Int8PtrTy);
 1391       Builder.CreateBitCast(LoadObjCSelf(), VoidPtrTy);
 1396     arg = Builder.CreateBitCast(arg, VoidPtrTy);
 1596       Builder.CreateBitCast(LoadObjCSelf(), Types.ConvertType(IdTy));
 1773     Builder.CreateBitCast(Collection,
 1826   CurrentItem = Builder.CreateBitCast(CurrentItem, convertedElementType,
 1997   value = CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy);
 2004   return CGF.Builder.CreateBitCast(call, origType);
 2026     result = CGF.Builder.CreateBitCast(result, origType);
 2048     CGF.Builder.CreateBitCast(addr.getPointer(), CGF.Int8PtrPtrTy),
 2049     CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy)
 2055   return CGF.Builder.CreateBitCast(result, origType);
 2071     CGF.Builder.CreateBitCast(dst.getPointer(), CGF.Int8PtrPtrTy),
 2072     CGF.Builder.CreateBitCast(src.getPointer(), CGF.Int8PtrPtrTy)
 2101   value = CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy);
 2107   return CGF.Builder.CreateBitCast(Inst, origType);
 2242   value = Builder.CreateBitCast(value, Int8PtrTy);
 2288     Builder.CreateBitCast(addr.getPointer(), Int8PtrPtrTy),
 2289     Builder.CreateBitCast(value, Int8PtrTy)
 2374   value = Builder.CreateBitCast(value, Int8PtrTy);
 2377   return Builder.CreateBitCast(value, origType);
 2648   value = Builder.CreateBitCast(value, Int8PtrTy);
 3143     value = CGF.Builder.CreateBitCast(value, resultType);
 3320     return CGF.Builder.CreateBitCast(value, resultType);
 3475   object = Builder.CreateBitCast(object, VoidPtrTy);
tools/clang/lib/CodeGen/CGObjCGNU.cpp
  326     return B.CreateBitCast(V, Ty);
 2530       ReceiverClass = Builder.CreateBitCast(ReceiverClass,
 2572     ReceiverClass = Builder.CreateBitCast(ReceiverClass,
 3038   return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
 3958     ExceptionAsObject = CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy);
tools/clang/lib/CodeGen/CGObjCMac.cpp
 2068     CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
 2104   Target = CGF.Builder.CreateBitCast(Target, ClassTy);
 2150     Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
 2214       CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType));
 3025       CGF.Builder.CreateBitCast(className,
 4464     SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
 4678         CGF.Builder.CreateBitCast(Caught,
 4768       CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
 4795   read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
 4808     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
 4809                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
 4812   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
 4829     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
 4830                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
 4833   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
 4855     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
 4856                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
 4859   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
 4874     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
 4875                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
 4878   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
 7127     arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
 7205     Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
 7215   calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
 7447     CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
 7462   Target = CGF.Builder.CreateBitCast(Target, ClassTy);
 7520     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
 7521            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
 7524   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
 7540     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
 7541            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
 7544   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
 7573   read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
 7586     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
 7587            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
 7590   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
 7607     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
 7608            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
 7611   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
 7668     Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
tools/clang/lib/CodeGen/CGObjCRuntime.cpp
   65   llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue, CGF.Int8PtrTy);
   69     V = CGF.Builder.CreateBitCast(V, llvm::PointerType::getUnqual(LTy));
  258       llvm::Value *CastExn = CGF.Builder.CreateBitCast(Exn, CatchType);
  340   lock = CGF.Builder.CreateBitCast(lock, CGF.VoidPtrTy);
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp
 3064         CGF.Builder.CreateBitCast(OutlinedFn, RT.getKmpc_MicroPointerTy())};
 8879   llvm::Value *PtrBegin = MapperCGF.Builder.CreateBitCast(
 8952     llvm::Value *CurBaseArg = MapperCGF.Builder.CreateBitCast(
 8954     llvm::Value *CurBeginArg = MapperCGF.Builder.CreateBitCast(
 9910       CGF.Builder.CreateBitCast(OutlinedFn, getKmpc_MicroPointerTy())};
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
 1492       Bld.CreateBitCast(WorkID, ParallelFnTy->getPointerTo());
 2822     return CGF.Builder.CreateBitCast(Val, LLVMCastTy);
tools/clang/lib/CodeGen/CGStmt.cpp
  618   llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()),
 1062     Builder.CreateStore(Builder.CreateBitCast(SLocPtr, Int8PtrTy),
 2108         Arg = Builder.CreateBitCast(Arg, AdjTy);
 2192       Arg = Builder.CreateBitCast(Arg, AdjTy);
 2324         Tmp = Builder.CreateBitCast(Tmp, TruncTy);
tools/clang/lib/CodeGen/CGVTables.cpp
  213   AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr,
  407       AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType);
  414       AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType);
tools/clang/lib/CodeGen/CodeGenFunction.cpp
 1675     Address SrcPtr(Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()),
 2079     Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy),
 2080     Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy),
 2092                        Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()),
 2109       V = Builder.CreateBitCast(V, CGM.Int8PtrTy);
 2111     V = Builder.CreateBitCast(V, VTy);
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp
  606   llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
  608   This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
  683       VirtualFn = Builder.CreateBitCast(VirtualFn, FTy->getPointerTo(),
  691             {Builder.CreateBitCast(VFPAddr, CGF.Int8PtrTy), TypeId});
  694           Builder.CreateBitCast(VFPAddr, FTy->getPointerTo()->getPointerTo());
  751           Builder.CreateBitCast(NonVirtualFn, CGF.Int8PtrTy);
  804   return Builder.CreateBitCast(Addr, PType);
 1193       CGF.Builder.CreateBitCast(Ptr.getPointer(), CGF.Int8PtrTy);
 1423   Value = CGF.Builder.CreateBitCast(Value, DestLTy);
 1467   return CGF.Builder.CreateBitCast(Value, DestLTy);
 1491   VBaseOffsetPtr = CGF.Builder.CreateBitCast(VBaseOffsetPtr,
 1934     OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
 1954   return CGF.Builder.CreateBitCast(ResultPtr, InitialPtr.getType());
 4146         llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
 4155       CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
 4169         CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
 4192     llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
 4223     Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
 4237   Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp
  956   return CGF.Builder.CreateBitCast(Typeid, StdTypeInfoPtrTy);
  997   return CGF.Builder.CreateBitCast(ThisPtr, DestLTy);
 1195       Int8This = Builder.CreateBitCast(getThisValue(CGF),
 1200     VtorDispPtr = Builder.CreateBitCast(
 1502       This = CGF.Builder.CreateBitCast(This, charPtrTy);
 1506       This = CGF.Builder.CreateBitCast(This, thisTy, "this.adjusted");
 2202   return CGF.Builder.CreateBitCast(V, OrigTy);
 2950   VBPtr = Builder.CreateBitCast(VBPtr,
 2970   VBaseOffs = Builder.CreateBitCast(VBaseOffs, CGM.Int32Ty->getPointerTo(0));
 3068   Addr = Builder.CreateBitCast(Addr, CGF.Int8Ty->getPointerTo(AS));
 3075   return Builder.CreateBitCast(Addr, PType);
 3364     llvm::Value *Ptr = Builder.CreateBitCast(ThisPtrForCall, CGF.Int8PtrTy);
 3366     ThisPtrForCall = Builder.CreateBitCast(Ptr, ThisPtrForCall->getType(),
 3371     Builder.CreateBitCast(FunctionPointer, FTy->getPointerTo());
 4287     CGF.Builder.CreateBitCast(AI.getPointer(), CGM.Int8PtrTy),
tools/clang/lib/CodeGen/TargetInfo.cpp
 3700     CGF.Builder.CreateBitCast(overflow_arg_area,
 3814         TyLo, CGF.Builder.CreateBitCast(RegLoAddr, PTyLo),
 3820         TyHi, CGF.Builder.CreateBitCast(RegHiAddr, PTyHi),
tools/polly/lib/CodeGen/BlockGenerators.cpp
 1060       Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
 1086   Value *VectorPtr = Builder.CreateBitCast(NewPointer, VectorPtrType,
 1208         Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
 1342     Value *VectorPtr = Builder.CreateBitCast(Address, VectorPtrType,
tools/polly/lib/CodeGen/IslExprBuilder.cpp
  277         Builder.CreateBitCast(Base, PointerTy, "polly.access.cast." + BaseName);
tools/polly/lib/CodeGen/LoopGenerators.cpp
  188   Value *SubFnParam = Builder.CreateBitCast(Struct, Builder.getInt8PtrTy(),
tools/polly/lib/CodeGen/LoopGeneratorsGOMP.cpp
  129   Value *UserContext = Builder.CreateBitCast(
tools/polly/lib/CodeGen/LoopGeneratorsKMP.cpp
  173   Value *UserContext = Builder.CreateBitCast(Shared, StructData->getType(),
tools/polly/lib/CodeGen/RuntimeDebugBuilder.cpp
  239   Data = Builder.CreateBitCast(Data, Builder.getInt8PtrTy());