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

Declarations

include/llvm/IR/Instruction.def

  195 HANDLE_CAST_INST(49, BitCast , BitCastInst )  // Type cast

References

include/llvm/Analysis/ObjCARCAnalysisUtils.h

  146   return isa<BitCastInst>(I) ||

include/llvm/Analysis/PtrUseVisitor.h

  255   void visitBitCastInst(BitCastInst &BC) {

include/llvm/IR/InstVisitor.h

  189   RetTy visitBitCastInst(BitCastInst &I)          { DELEGATE(CastInst);}

include/llvm/IR/Instructions.h

 5163   BitCastInst *cloneImpl() const;

include/llvm/Support/Casting.h

   58     return To::classof(&Val);
   77     return isa_impl<To, From>::doit(Val);
   92     return isa_impl<To, From>::doit(*Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  142   return isa_impl_wrap<X, const Y,
  172   using ret_type = To *;       // Pointer arg case, return Ty*
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  218   static typename cast_retty<To, From>::ret_type doit(From &Val) {
  219     return cast_convert_val<To, SimpleFrom,
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  248                                typename cast_retty<X, const Y>::ret_type>::type
  252       X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;

lib/Analysis/BranchProbabilityInfo.cpp

  671     if (auto *I = dyn_cast<BitCastInst>(V))
  671     if (auto *I = dyn_cast<BitCastInst>(V))

lib/Analysis/InlineCost.cpp

  268   bool visitBitCast(BitCastInst &I);
  631 bool CallAnalyzer::visitBitCast(BitCastInst &I) {

lib/Analysis/MemoryBuiltins.cpp

  366     if (const BitCastInst *BCI = dyn_cast<BitCastInst>(*UI++)) {
  366     if (const BitCastInst *BCI = dyn_cast<BitCastInst>(*UI++)) {

lib/Analysis/MemoryDependenceAnalysis.cpp

  401       if (isa<BitCastInst>(U)) {

lib/Analysis/ScalarEvolutionExpander.cpp

  152     while ((isa<BitCastInst>(IP) &&
  153             isa<Argument>(cast<BitCastInst>(IP)->getOperand(0)) &&
  154             cast<BitCastInst>(IP)->getOperand(0) != A) ||
  899       (isa<CastInst>(IncV) && !isa<BitCastInst>(IncV)))

lib/Analysis/TypeMetadataUtils.cpp

   37     if (isa<BitCastInst>(User)) {
   56     if (isa<BitCastInst>(User)) {

lib/Analysis/VectorUtils.cpp

  441     if (isa<BitCastInst>(I) || isa<PtrToIntInst>(I) || isa<IntToPtrInst>(I) ||

lib/CodeGen/Analysis.cpp

  286     if (isa<BitCastInst>(I)) {

lib/CodeGen/CodeGenPrepare.cpp

 1981   BitCastInst *BCI = nullptr;
 1984     BCI = dyn_cast<BitCastInst>(V);
 6715   auto *LBC = dyn_cast<BitCastInst>(LValue);
 6715   auto *LBC = dyn_cast<BitCastInst>(LValue);
 6716   auto *HBC = dyn_cast<BitCastInst>(HValue);
 6716   auto *HBC = dyn_cast<BitCastInst>(HValue);
 7028       Instruction *NC = new BitCastInst(GEPI->getOperand(0), GEPI->getType(),

lib/CodeGen/InterleavedLoadCombinePass.cpp

  718     BitCastInst *BCI = dyn_cast<BitCastInst>(V);
  718     BitCastInst *BCI = dyn_cast<BitCastInst>(V);
  730   static bool computeFromBCI(BitCastInst *BCI, VectorInfo &Result,

lib/CodeGen/SafeStackColoring.cpp

   78         if (auto *BI = dyn_cast<BitCastInst>(U)) {
   78         if (auto *BI = dyn_cast<BitCastInst>(U)) {

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 5856       if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Address))
 5856       if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Address))

lib/CodeGen/SelectionDAG/StatepointLowering.cpp

  164   if (const BitCastInst *Cast = dyn_cast<BitCastInst>(Val))
  164   if (const BitCastInst *Cast = dyn_cast<BitCastInst>(Val))

lib/CodeGen/StackColoring.cpp

  923       BitCastInst *Cast = new BitCastInst(Inst, From->getType());
  923       BitCastInst *Cast = new BitCastInst(Inst, From->getType());
  950       if (BitCastInst *BCI = dyn_cast<BitCastInst>(Use.get()))
  950       if (BitCastInst *BCI = dyn_cast<BitCastInst>(Use.get()))

lib/ExecutionEngine/Interpreter/Execution.cpp

 1762 void Interpreter::visitBitCastInst(BitCastInst &I) {

lib/ExecutionEngine/Interpreter/Interpreter.h

  149   void visitBitCastInst(BitCastInst &I);

lib/IR/BasicBlock.cpp

  166     if (auto *BI = dyn_cast<BitCastInst>(Prev)) {

lib/IR/IRBuilder.cpp

   68   BitCastInst *BCI = new BitCastInst(Ptr, PT, "");
   68   BitCastInst *BCI = new BitCastInst(Ptr, PT, "");

lib/IR/Instructions.cpp

  583       Result = new BitCastInst(MCall, AllocPtrType, Name, InsertBefore);
  590       Result = new BitCastInst(MCall, AllocPtrType, Name);
  672       PtrCast = new BitCastInst(Source, IntPtrTy, "", InsertBefore);
  676       PtrCast = new BitCastInst(Source, IntPtrTy, "", InsertAtEnd);
 2763   case BitCast:       return new BitCastInst       (S, Ty, Name, InsertBefore);
 2785   case BitCast:       return new BitCastInst       (S, Ty, Name, InsertAtEnd);
 4216 BitCastInst *BitCastInst::cloneImpl() const {
 4217   return new BitCastInst(getOperand(0), getType());

lib/IR/SafepointIRVerifier.cpp

  691     } else if ((isa<GetElementPtrInst>(I) || isa<BitCastInst>(I)) &&

lib/IR/Verifier.cpp

  448   void visitBitCastInst(BitCastInst &I);
 2768 void Verifier::visitBitCastInst(BitCastInst &I) {
 3098   if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {
 3098   if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {

lib/Target/AArch64/AArch64StackTagging.cpp

  489   auto *NewPtr = new BitCastInst(NewAI, Info.AI->getType(), "", Info.AI);
  489   auto *NewPtr = new BitCastInst(NewAI, Info.AI->getType(), "", Info.AI);

lib/Target/AMDGPU/AMDGPULowerKernelAttributes.cpp

  104     auto *BCI = dyn_cast<BitCastInst>(*U->user_begin());
  104     auto *BCI = dyn_cast<BitCastInst>(*U->user_begin());

lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

  387           new BitCastInst(BufferIdx, idPointer, "PrintBuffIdCast", Brnch);
  431           Arg = new BitCastInst(Arg, IType, "PrintArgFP", Brnch);
  527           Arg = new BitCastInst(Arg, IType, "PrintArgVect", Brnch);
  541               new BitCastInst(BufferIdx, ArgPointer, "PrintBuffPtrCast", Brnch);

lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp

  145       auto *BCI = dyn_cast<BitCastInst>(U.getUser());
  145       auto *BCI = dyn_cast<BitCastInst>(U.getUser());

lib/Target/ARM/ARMCodeGenPrepare.cpp

  243   else if (isa<BitCastInst>(V))

lib/Target/BPF/BPFAbstractMemberAccess.cpp

  144   void traceBitCast(BitCastInst *BitCast, CallInst *Parent,
  404     if (auto *BI = dyn_cast<BitCastInst>(Inst)) {
  404     if (auto *BI = dyn_cast<BitCastInst>(Inst)) {
  428 void BPFAbstractMemberAccess::traceBitCast(BitCastInst *BitCast,
  436     if (auto *BI = dyn_cast<BitCastInst>(Inst)) {
  436     if (auto *BI = dyn_cast<BitCastInst>(Inst)) {
  466     if (auto *BI = dyn_cast<BitCastInst>(Inst)) {
  466     if (auto *BI = dyn_cast<BitCastInst>(Inst)) {
  892   auto *BCInst = new BitCastInst(Base, Type::getInt8PtrTy(BB->getContext()));
  892   auto *BCInst = new BitCastInst(Base, Type::getInt8PtrTy(BB->getContext()));
  901   auto *BCInst2 = new BitCastInst(GEP, Call->getType());
  901   auto *BCInst2 = new BitCastInst(GEP, Call->getType());

lib/Target/NVPTX/NVPTXLowerAlloca.cpp

  108           auto BI = dyn_cast<BitCastInst>(AllocaUse.getUser());

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

  167   while (BitCastInst *BC = dyn_cast<BitCastInst>(StrippedBasePtr))
  167   while (BitCastInst *BC = dyn_cast<BitCastInst>(StrippedBasePtr))
  401     NewBasePtr = new BitCastInst(PtrInc, BasePtr->getType(),
  450       ReplNewPtr = new BitCastInst(RealNewPtr, Ptr->getType(),

lib/Target/SystemZ/SystemZTDC.cpp

  238   if (auto *Cast = dyn_cast<BitCastInst>(Op0)) {
  238   if (auto *Cast = dyn_cast<BitCastInst>(Op0)) {

lib/Transforms/Coroutines/CoroElide.cpp

  131   auto *FrameVoidPtr =
  132       new BitCastInst(Frame, Type::getInt8PtrTy(C), "vFrame", InsertPt);

lib/Transforms/Coroutines/CoroSplit.cpp

 1456     auto *Cast = dyn_cast<BitCastInst>((UI++)->getUser());
 1456     auto *Cast = dyn_cast<BitCastInst>((UI++)->getUser());
 1483   while (auto *Cast = dyn_cast<BitCastInst>(CastFn)) {
 1483   while (auto *Cast = dyn_cast<BitCastInst>(CastFn)) {

lib/Transforms/Coroutines/Coroutines.cpp

  117   auto *Bitcast =
  118       new BitCastInst(Call, ResumeFnType->getPointerTo(), "", InsertPt);
  414             auto BCI = new BitCastInst(*SI, *RI, "", Suspend);

lib/Transforms/IPO/Attributor.cpp

 3588         AI = new BitCastInst(AI, MallocCall->getType(), "malloc_bc",
 3602         auto *BI = new BitCastInst(AI, MallocCall->getType(), "calloc_bc",
 3602         auto *BI = new BitCastInst(AI, MallocCall->getType(), "calloc_bc",
 3694       if (isa<GetElementPtrInst>(UserI) || isa<BitCastInst>(UserI)) {

lib/Transforms/IPO/GlobalOpt.cpp

  640     } else if (const BitCastInst *CI = dyn_cast<BitCastInst>(U)) {
  640     } else if (const BitCastInst *CI = dyn_cast<BitCastInst>(U)) {
  860   BitCastInst *TheBC = nullptr;
  863     if (BitCastInst *BCI = dyn_cast<BitCastInst>(User)) {
  863     if (BitCastInst *BCI = dyn_cast<BitCastInst>(User)) {
  872         TheBC = new BitCastInst(NewGV, CI->getType(), "newgv", CI);
  997     if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Inst)) {
  997     if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Inst)) {
 1027     } else if (isa<BitCastInst>(U)) {
 1548       Instruction *Cast = new BitCastInst(Malloc, CI->getType(), "tmp", CI);
 1551       if (BitCastInst *BCI = dyn_cast<BitCastInst>(Malloc))
 1551       if (BitCastInst *BCI = dyn_cast<BitCastInst>(Malloc))

lib/Transforms/InstCombine/InstCombineCalls.cpp

 3084         return new BitCastInst(Sel, II->getType());

lib/Transforms/InstCombine/InstCombineCasts.cpp

   83 Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
 1722     return new BitCastInst(SrcI, FITy);
 2006 static Value *optimizeIntegerToVectorInsertions(BitCastInst &CI,
 2035 static Instruction *canonicalizeBitCastExtElt(BitCastInst &BitCast,
 2056 static Instruction *foldBitCastBitwiseLogic(BitCastInst &BitCast,
 2102 static Instruction *foldBitCastSelect(BitCastInst &BitCast,
 2207       auto *BCI = dyn_cast<BitCastInst>(IncValue);
 2207       auto *BCI = dyn_cast<BitCastInst>(IncValue);
 2240       } else if (auto *BCI = dyn_cast<BitCastInst>(V)) {
 2240       } else if (auto *BCI = dyn_cast<BitCastInst>(V)) {
 2266           auto *NewBC =
 2267             cast<BitCastInst>(Builder.CreateBitCast(NewPN, SrcTy));
 2273       else if (auto *BCI = dyn_cast<BitCastInst>(V)) {
 2273       else if (auto *BCI = dyn_cast<BitCastInst>(V)) {
 2289 Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
 2375         if (BitCastInst *BCIn = dyn_cast<BitCastInst>(SrcCast->getOperand(0)))
 2375         if (BitCastInst *BCIn = dyn_cast<BitCastInst>(SrcCast->getOperand(0)))
 2405         return new BitCastInst(InsElt->getOperand(1), DestTy);
 2419       BitCastInst *Tmp;
 2423       if (((Tmp = dyn_cast<BitCastInst>(ShufOp0)) &&
 2425           ((Tmp = dyn_cast<BitCastInst>(ShufOp1)) &&

lib/Transforms/InstCombine/InstCombineCompares.cpp

 1059     if (isa<BitCastInst>(V) || isa<GetElementPtrInst>(V) || isa<PHINode>(V) ||
 2727   auto *Bitcast = dyn_cast<BitCastInst>(Cmp.getOperand(0));
 2727   auto *Bitcast = dyn_cast<BitCastInst>(Cmp.getOperand(0));
 2771       (isa<Constant>(Op1) || isa<BitCastInst>(Op1))) {
 2774     if (auto *BC2 = dyn_cast<BitCastInst>(Op1))
 2774     if (auto *BC2 = dyn_cast<BitCastInst>(Op1))

lib/Transforms/InstCombine/InstCombineInternal.h

  162   if (auto *BitCast = dyn_cast<BitCastInst>(V))
  162   if (auto *BitCast = dyn_cast<BitCastInst>(V))
  420   Instruction *visitBitCast(BitCastInst &CI);
  984   Instruction *PromoteCastOfAllocation(BitCastInst &CI, AllocaInst &AI);

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

   79       if (isa<BitCastInst>(I) || isa<AddrSpaceCastInst>(I)) {
  277     } else if (isa<GetElementPtrInst>(Inst) || isa<BitCastInst>(Inst)) {
  316   } else if (auto *BC = dyn_cast<BitCastInst>(I)) {
  316   } else if (auto *BC = dyn_cast<BitCastInst>(I)) {
  321     auto *NewI = new BitCastInst(V, NewT);
  321     auto *NewI = new BitCastInst(V, NewT);
  389           return new BitCastInst(EntryAI, AI.getType());
 1150   if (auto *BC = dyn_cast<BitCastInst>(V)) {
 1150   if (auto *BC = dyn_cast<BitCastInst>(V)) {
 1416         (isa<BitCastInst>(BBI) && BBI->getType()->isPointerTy())) {
 1474            (isa<BitCastInst>(BBI) && BBI->getType()->isPointerTy()));
 1522            (isa<BitCastInst>(BBI) && BBI->getType()->isPointerTy())) {

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  181       return new BitCastInst(Elt, DestTy);
  248       return new BitCastInst(Builder.CreateTrunc(Scalar, DestIntTy), DestTy);
 1046     return new BitCastInst(NewInsElt, IE.getType());
 2004     SmallVector<BitCastInst *, 8> BCs;
 2007       if (BitCastInst *BC = dyn_cast<BitCastInst>(U))
 2007       if (BitCastInst *BC = dyn_cast<BitCastInst>(U))
 2011     for (BitCastInst *BC : BCs) {

lib/Transforms/InstCombine/InstructionCombining.cpp

  873   if (auto *BC = dyn_cast<BitCastInst>(&Op)) {
  873   if (auto *BC = dyn_cast<BitCastInst>(&Op)) {
 2144     if (auto *BC = dyn_cast<BitCastInst>(ASC->getOperand(0)))
 2144     if (auto *BC = dyn_cast<BitCastInst>(ASC->getOperand(0)))
 2148   if (auto *BCI = dyn_cast<BitCastInst>(ASCStrippedPtrOp)) {
 2148   if (auto *BCI = dyn_cast<BitCastInst>(ASCStrippedPtrOp)) {
 2191     if (!isa<BitCastInst>(SrcOp) && GEP.accumulateConstantOffset(DL, Offset)) {
 2211         return new BitCastInst(SrcOp, GEPType);
 2230         return new BitCastInst(NGEP, GEPType);
 2404       } else if (isa<BitCastInst>(I) || isa<GetElementPtrInst>(I) ||

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

 1204       auto *Bitcast = new BitCastInst(NewAI, AI->getType(), "", AI);
 1204       auto *Bitcast = new BitCastInst(NewAI, AI->getType(), "", AI);

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1901   void visitBitCastInst(BitCastInst &I) {
 3390     if (auto *I = dyn_cast<BitCastInst>(RetVal)) {
 3390     if (auto *I = dyn_cast<BitCastInst>(RetVal)) {

lib/Transforms/ObjCARC/ObjCARCContract.cpp

  420     Args[0] = new BitCastInst(Args[0], I8XX, "", Store);
  422     Args[1] = new BitCastInst(Args[1], I8X, "", Store);
  666                 new BitCastInst(Replacement, UseTy, "", &InsertBB->back());
  683             Replacement = new BitCastInst(Replacement, UseTy, "",
  699       if (const BitCastInst *BI = dyn_cast<BitCastInst>(Arg))
  699       if (const BitCastInst *BI = dyn_cast<BitCastInst>(Arg))
  721     SmallVector<BitCastInst *, 2> BitCastUsers;
  725       if (auto *BC = dyn_cast<BitCastInst>(U))
  725       if (auto *BC = dyn_cast<BitCastInst>(U))
  730       auto *BC = BitCastUsers.pop_back_val();
  732         if (auto *B = dyn_cast<BitCastInst>(U))
  732         if (auto *B = dyn_cast<BitCastInst>(U))

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

   93     if (const BitCastInst *BC = dyn_cast<BitCastInst>(Arg))
   93     if (const BitCastInst *BC = dyn_cast<BitCastInst>(Arg))
  694       if (isa<BitCastInst>(U))
 1016                 Op = new BitCastInst(Op, ParamTy, "", InsertPos);
 1579                    new BitCastInst(Arg, ParamTy, "", InsertPt);
 1592                    new BitCastInst(Arg, ParamTy, "", InsertPt);

lib/Transforms/Scalar/CallSiteSplitting.cpp

  246   BitCastInst* BCI = dyn_cast<BitCastInst>(&*II);
  246   BitCastInst* BCI = dyn_cast<BitCastInst>(&*II);

lib/Transforms/Scalar/ConstantHoisting.cpp

  745       Base = new BitCastInst(Base, Int8PtrTy, "base_bitcast", InsertionPt);
  748       Mat = new BitCastInst(Mat, Ty, "mat_bitcast", InsertionPt);
  871         Base = new BitCastInst(ConstInfo.BaseExpr, Ty, "const", IP);
  874         Base = new BitCastInst(ConstInfo.BaseInt, Ty, "const", IP);

lib/Transforms/Scalar/InferAddressSpaces.cpp

  455       return new BitCastInst(Src, NewPtrType);
  471     return new BitCastInst(NewPointerOperands[0], NewPtrType);

lib/Transforms/Scalar/JumpThreading.cpp

  516     if (isa<BitCastInst>(I) && I->getType()->isPointerTy())

lib/Transforms/Scalar/LICM.cpp

  995     auto *BC = dyn_cast<BitCastInst>(Addr);
  995     auto *BC = dyn_cast<BitCastInst>(Addr);

lib/Transforms/Scalar/MemCpyOptimizer.cpp

  824     if (isa<BitCastInst>(U) || isa<AddrSpaceCastInst>(U)) {
 1319     TmpCast = new BitCastInst(MDep->getSource(), ByValArg->getType(),

lib/Transforms/Scalar/Reg2Mem.cpp

   85   CastInst *AllocaInsertionPoint = new BitCastInst(

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

  472   if (auto *BC = dyn_cast<BitCastInst>(I))
  472   if (auto *BC = dyn_cast<BitCastInst>(I))
 1020       Base = new BitCastInst(Base, Input->getType(), "cast", InsertPt);

lib/Transforms/Scalar/SROA.cpp

  709   void visitBitCastInst(BitCastInst &BC) {
  978       } else if (!isa<BitCastInst>(I) && !isa<PHINode>(I) &&
 3434   bool visitBitCastInst(BitCastInst &BC) {

lib/Transforms/Scalar/Scalarizer.cpp

  192   bool visitBitCastInst(BitCastInst &BCI);
  662 bool ScalarizerVisitor::visitBitCastInst(BitCastInst &BCI) {

lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

 1096     NewGEP = new BitCastInst(NewGEP, I8PtrTy, "", GEP);
 1105       NewGEP = new BitCastInst(NewGEP, GEP->getType(), GEP->getName(), GEP);

lib/Transforms/Utils/BasicBlockUtils.cpp

  781     if (BitCastInst *BCI = dyn_cast<BitCastInst>(V)) {
  781     if (BitCastInst *BCI = dyn_cast<BitCastInst>(V)) {

lib/Transforms/Utils/BypassSlowDivision.cpp

  205     if (!C && isa<BitCastInst>(Op1))
  206       C = dyn_cast<ConstantInt>(cast<BitCastInst>(Op1)->getOperand(0));
  394   if (auto *BCI = dyn_cast<BitCastInst>(Divisor))
  394   if (auto *BCI = dyn_cast<BitCastInst>(Divisor))

lib/Transforms/Utils/EntryExitInstrumenter.cpp

   99       if (BitCastInst *BCI = dyn_cast_or_null<BitCastInst>(Prev))
   99       if (BitCastInst *BCI = dyn_cast_or_null<BitCastInst>(Prev))

lib/Transforms/Utils/GlobalStatus.cpp

  140       } else if (isa<BitCastInst>(I) || isa<GetElementPtrInst>(I)) {

lib/Transforms/Utils/InlineFunction.cpp

 2193       auto *OldCast = dyn_cast_or_null<BitCastInst>(RI->getReturnValue());
 2193       auto *OldCast = dyn_cast_or_null<BitCastInst>(RI->getReturnValue());

lib/Transforms/Utils/PromoteMemoryToRegister.cpp

   86     } else if (const BitCastInst *BCI = dyn_cast<BitCastInst>(U)) {
   86     } else if (const BitCastInst *BCI = dyn_cast<BitCastInst>(U)) {

lib/Transforms/Utils/SimplifyCFG.cpp

 5991     if (BitCastInst *BC = dyn_cast<BitCastInst>(Use))
 5991     if (BitCastInst *BC = dyn_cast<BitCastInst>(Use))

lib/Transforms/Utils/StripGCRelocates.cpp

   62       ReplaceGCRel = new BitCastInst(OrigPtr, GCRel->getType(), "cast", GCRel);

lib/Transforms/Vectorize/LoopVectorize.cpp

 4392     return ((isa<BitCastInst>(V) && V->getType()->isPointerTy()) ||

tools/bugpoint/Miscompilation.cpp

  895           CastInst *CastedResolver = new BitCastInst(

tools/clang/lib/CodeGen/CGAtomic.cpp

 1589       else if (llvm::BitCastInst::isBitCastable(Value->getType(), InputIntTy))

tools/clang/lib/CodeGen/CGBuiltin.cpp

 5822   if (BitCastInst *BI = dyn_cast<BitCastInst>(Op))
 5822   if (BitCastInst *BI = dyn_cast<BitCastInst>(Op))

tools/clang/lib/CodeGen/CGCall.cpp

 2576     llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
 2576     llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(insn);
 2602   while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {
 2602   while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(generator)) {
 2637       if (isa<llvm::BitCastInst>(prev)) {
 2655   while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {
 2655   while (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(result)) {
 2764           if (isa<llvm::BitCastInst>(&*II) && (CastAddr == &*II))

tools/clang/lib/CodeGen/CGCoroutine.cpp

  621     auto *PromiseAddrVoidPtr =
  622         new llvm::BitCastInst(PromiseAddr.getPointer(), VoidPtrTy, "", CoroId);

tools/clang/lib/CodeGen/CGObjC.cpp

 2795   } else if (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(value)) {
 2795   } else if (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(value)) {

tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp

 1607     Elem.second.ServiceInsertPt = new llvm::BitCastInst(
 1611         new llvm::BitCastInst(Undef, CGF.Int32Ty, "svcpt");

tools/clang/lib/CodeGen/CodeGenFunction.cpp

  836   AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "allocapt", EntryBB);
 2030   llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "",

tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.cpp

  341     BitCastInst *bit_cast =
  342         new BitCastInst(dereferenced_ptr, GetI8PtrTy(), "", inst);
  432     BitCastInst *bit_cast =
  433         new BitCastInst(target_object, GetI8PtrTy(), "", inst);

tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

 1571                 return new BitCastInst(
 1798               BitCastInst *bit_cast = new BitCastInst(
 1798               BitCastInst *bit_cast = new BitCastInst(
 1806               BitCastInst *bit_cast = new BitCastInst(
 1806               BitCastInst *bit_cast = new BitCastInst(

tools/llvm-stress/llvm-stress.cpp

  559         new BitCastInst(V, DestTy, "PC", BB->getTerminator()));
  568         new BitCastInst(V, DestTy, "BC", BB->getTerminator()));

tools/polly/lib/Analysis/ScopBuilder.cpp

 1396   const BitCastInst *Bitcast = nullptr;
 1401     Bitcast = dyn_cast<BitCastInst>(TypedMem);
 1404     Bitcast = dyn_cast<BitCastInst>(Address);
 1611   if (auto *BitCast = dyn_cast<BitCastInst>(Address)) {
 1611   if (auto *BitCast = dyn_cast<BitCastInst>(Address)) {
 1635   if (auto *BasePtrCast = dyn_cast<BitCastInst>(BasePtr))
 1635   if (auto *BasePtrCast = dyn_cast<BitCastInst>(BasePtr))

tools/polly/lib/Transform/RewriteByReferenceParameters.cpp

   56     auto *BitCast = dyn_cast<BitCastInst>(Call->getOperand(1));
   56     auto *BitCast = dyn_cast<BitCastInst>(Call->getOperand(1));
   76     auto *NewBitCast = new BitCastInst(NewAlloca, BitCast->getType(),
   76     auto *NewBitCast = new BitCastInst(NewAlloca, BitCast->getType(),

unittests/Analysis/CGSCCPassManagerTest.cpp

 1216         auto &H3F = *cast<Function>(cast<BitCastInst>(H2F.begin()->begin())->getOperand(0));

unittests/IR/InstructionsTest.cpp

  343   CastInst *BTC0 = new BitCastInst(Gep0, V2xi8PTy);
  344   CastInst *BTC1 = new BitCastInst(Gep1, V2xi8PTy);
  345   CastInst *BTC2 = new BitCastInst(Gep2, V2xi8PTy);
  346   CastInst *BTC3 = new BitCastInst(Gep3, V2xi8PTy);

unittests/IR/MetadataTest.cpp

  212   Instruction *I = new BitCastInst(C, Type::getInt32Ty(Context));

unittests/IR/ValueHandleTest.cpp

   24   std::unique_ptr<BitCastInst> BitcastV;
   28         BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))) {}
  514   BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
  533     BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));

unittests/IR/ValueMapTest.cpp

   26   std::unique_ptr<BitCastInst> BitcastV;
   31         BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))),

usr/include/c++/7.4.0/bits/unique_ptr.h

   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;

usr/include/c++/7.4.0/type_traits

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>

utils/unittest/googletest/include/gtest/gtest-printers.h

  407                     T* p, ::std::ostream* os) {
  416     if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {