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

Declarations

include/llvm/Analysis/MemoryBuiltins.h

   49 class PointerType;

include/llvm/ExecutionEngine/Orc/IndirectionUtils.h

   43 class PointerType;

include/llvm/IR/Constants.h

   46 class PointerType;

include/llvm/IR/InlineAsm.h

   27 class PointerType;

include/llvm/IR/Type.h

   34 class PointerType;

tools/clang/lib/CodeGen/CGBlocks.h

   34 class PointerType;

tools/clang/lib/CodeGen/CodeGenTypeCache.h

   23   class PointerType;

References

examples/BrainF/BrainF.cpp

  157         PointerType::getUnqual(IntegerType::getInt8Ty(C)));
  303             PHINode::Create(PointerType::getUnqual(IntegerType::getInt8Ty(C)),
  458         CreatePHI(PointerType::getUnqual(IntegerType::getInt8Ty(C)), 1,

include/llvm/ADT/DenseMapInfo.h

   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }

include/llvm/ADT/STLExtras.h

 1014       std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
 1014       std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;

include/llvm/Analysis/MemoryBuiltins.h

  133 PointerType *getMallocType(const CallInst *CI, const TargetLibraryInfo *TLI);

include/llvm/Analysis/ObjCARCAnalysisUtils.h

  169   PointerType *Ty = dyn_cast<PointerType>(Op->getType());
  169   PointerType *Ty = dyn_cast<PointerType>(Op->getType());

include/llvm/Analysis/ScalarEvolutionExpander.h

  350                           PointerType *PTy, Type *Ty, Value *V);
  351     Value *expandAddToGEP(const SCEV *Op, PointerType *PTy, Type *Ty, Value *V);

include/llvm/CodeGen/TargetLowering.h

 1240     if (auto *PTy = dyn_cast<PointerType>(Ty))
 1240     if (auto *PTy = dyn_cast<PointerType>(Ty))
 1246       if (auto *PTy = dyn_cast<PointerType>(EltTy)) {
 1246       if (auto *PTy = dyn_cast<PointerType>(EltTy)) {
 1260     if (PointerType *PTy = dyn_cast<PointerType>(Ty))
 1260     if (PointerType *PTy = dyn_cast<PointerType>(Ty))
 1264       if (PointerType *PT = dyn_cast<PointerType>(Elm)) {
 1264       if (PointerType *PT = dyn_cast<PointerType>(Elm)) {

include/llvm/ExecutionEngine/Orc/IndirectionUtils.h

  417 GlobalVariable *createImplPointer(PointerType &PT, Module &M, const Twine &Name,

include/llvm/FuzzMutate/OpDescriptor.h

  137       Result.push_back(UndefValue::get(PointerType::getUnqual(T)));
  148     if (const auto *PtrT = dyn_cast<PointerType>(V->getType()))
  148     if (const auto *PtrT = dyn_cast<PointerType>(V->getType()))
  157         Result.push_back(UndefValue::get(PointerType::getUnqual(T)));

include/llvm/IR/Constants.h

  541   explicit ConstantPointerNull(PointerType *T)
  550   static ConstantPointerNull *get(PointerType *T);
  554   inline PointerType *getType() const {
  555     return cast<PointerType>(Value::getType());

include/llvm/IR/DataLayout.h

  380   bool isNonIntegralPointerType(PointerType *PT) const {
  385     auto *PTy = dyn_cast<PointerType>(Ty);
  385     auto *PTy = dyn_cast<PointerType>(Ty);

include/llvm/IR/DerivedTypes.h

  270   static typename std::enable_if<are_base_of<Type, Tys...>::value,
  272   create(StringRef Name, Type *elt1, Tys *... elts) {
  289   static typename std::enable_if<are_base_of<Type, Tys...>::value,
  291   get(Type *elt1, Tys *... elts) {
  327   typename std::enable_if<are_base_of<Type, Tys...>::value, void>::type
  328   setBody(Type *elt1, Tys *... elts) {
  585   PointerType(const PointerType &) = delete;
  586   PointerType &operator=(const PointerType &) = delete;
  586   PointerType &operator=(const PointerType &) = delete;
  590   static PointerType *get(Type *ElementType, unsigned AddressSpace);
  594   static PointerType *getUnqual(Type *ElementType) {
  595     return PointerType::get(ElementType, 0);
  636   return cast<PointerType>(getScalarType())->getAddressSpace();

include/llvm/IR/GlobalValue.h

   78       : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
  277   PointerType *getType() const { return cast<PointerType>(User::getType()); }
  277   PointerType *getType() const { return cast<PointerType>(User::getType()); }

include/llvm/IR/IRBuilder.h

  436   PointerType *getInt8PtrTy(unsigned AddrSpace = 0) {
  983             cast<PointerType>(Callee->getType())->getElementType()),
  994             cast<PointerType>(Callee->getType())->getElementType()),
 2420     auto *ArgType = cast<PointerType>(LHS->getType());
 2420     auto *ArgType = cast<PointerType>(LHS->getType());
 2437     auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
 2465     auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
 2646     auto *PtrTy = cast<PointerType>(PtrValue->getType());
 2646     auto *PtrTy = cast<PointerType>(PtrValue->getType());
 2672     auto *PtrTy = cast<PointerType>(PtrValue->getType());
 2672     auto *PtrTy = cast<PointerType>(PtrValue->getType());

include/llvm/IR/InlineAsm.h

   72   PointerType *getType() const {

include/llvm/IR/Instructions.h

   96   PointerType *getType() const {
   97     return cast<PointerType>(Instruction::getType());
  914           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
  930           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
 1044       cast<PointerType>(Ptr->getType()->getScalarType())->getElementType(),
 1049     Type *PtrTy = PointerType::get(checkGEPType(getIndexedType(ElTy, IdxList)),
 1533                       cast<PointerType>(Func->getType())->getElementType()),
 1542                       cast<PointerType>(Func->getType())->getElementType()),
 1552                       cast<PointerType>(Func->getType())->getElementType()),
 1560                       cast<PointerType>(Func->getType())->getElementType()),
 1568                       cast<PointerType>(Func->getType())->getElementType()),
 1577                       cast<PointerType>(Func->getType())->getElementType()),
 3784                       cast<PointerType>(Func->getType())->getElementType()),
 3796                       cast<PointerType>(Func->getType())->getElementType()),
 3806                       cast<PointerType>(Func->getType())->getElementType()),
 3816                       cast<PointerType>(Func->getType())->getElementType()),
 4147               cast<PointerType>(Func->getType())->getElementType())

include/llvm/IR/IntrinsicInst.h

  402       return cast<PointerType>(getRawDest()->getType())->getAddressSpace();
  450       return cast<PointerType>(getRawSource()->getType())->getAddressSpace();

include/llvm/IR/Operator.h

  578     return cast<PointerType>(getPointerOperandType())->getAddressSpace();

include/llvm/IR/Statepoint.h

  159         cast<PointerType>(getCalledValue()->getType())->getElementType());

include/llvm/IR/Type.h

  445   static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
  446   static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
  447   static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
  448   static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
  449   static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
  450   static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
  451   static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
  452   static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
  453   static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
  454   static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
  455   static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
  456   static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
  457   static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
  461   PointerType *getPointerTo(unsigned AddrSpace = 0) const;

include/llvm/Support/Casting.h

   66   static inline bool doit(const From &) { return true; }
  104   static inline bool doit(const From *Val) {
  106     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;
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  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) {
  342 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;

include/llvm/Support/PointerLikeTypeTraits.h

   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };

lib/Analysis/AliasAnalysisEvaluator.cpp

  143     Type *I1ElTy = cast<PointerType>((*I1)->getType())->getElementType();
  149       Type *I2ElTy = cast<PointerType>((*I2)->getType())->getElementType();
  234       Type *ElTy = cast<PointerType>(Pointer->getType())->getElementType();

lib/Analysis/ConstantFolding.cpp

  502   auto *PTy = cast<PointerType>(C->getType());
  502   auto *PTy = cast<PointerType>(C->getType());
  521       MapTy = PointerType::getIntNTy(C->getContext(),
  607   auto *SrcPtrTy = dyn_cast<PointerType>(SrcPtr->getType());
  607   auto *SrcPtrTy = dyn_cast<PointerType>(SrcPtr->getType());
  804   auto *OldPtrTy = cast<PointerType>(Ptr->getType());
  804   auto *OldPtrTy = cast<PointerType>(Ptr->getType());
  806   auto *NewPtrTy = cast<PointerType>(Ptr->getType());
  806   auto *NewPtrTy = cast<PointerType>(Ptr->getType());
  907   auto *PTy = cast<PointerType>(Ptr->getType());
  907   auto *PTy = cast<PointerType>(Ptr->getType());

lib/Analysis/InlineCost.cpp

 1976       PointerType *PTy = cast<PointerType>(Call.getArgOperand(I)->getType());
 1976       PointerType *PTy = cast<PointerType>(Call.getArgOperand(I)->getType());
 2031       PointerType *PTy = cast<PointerType>(Call.getArgOperand(I)->getType());
 2031       PointerType *PTy = cast<PointerType>(Call.getArgOperand(I)->getType());

lib/Analysis/InstructionSimplify.cpp

 2407       if (!cast<PointerType>(LHS->getType())->isEmptyTy() &&
 2408           !cast<PointerType>(RHS->getType())->isEmptyTy() &&
 3992       cast<PointerType>(Ops[0]->getType()->getScalarType())->getAddressSpace();
 4000   Type *GEPTy = PointerType::get(LastType, AS);

lib/Analysis/LazyValueInfo.cpp

  642   PointerType *PT = dyn_cast<PointerType>(BBI->getType());
  642   PointerType *PT = dyn_cast<PointerType>(BBI->getType());
  726     PointerType *PTy = dyn_cast<PointerType>(Val->getType());
  726     PointerType *PTy = dyn_cast<PointerType>(Val->getType());
  763       PointerType *PTy = dyn_cast<PointerType>(Val->getType());
  763       PointerType *PTy = dyn_cast<PointerType>(Val->getType());

lib/Analysis/Lint.cpp

  290             cast<PointerType>(Formal->getType())->getElementType();

lib/Analysis/LoopAccessAnalysis.cpp

  997   auto *PtrTy = cast<PointerType>(Ty);
  997   auto *PtrTy = cast<PointerType>(Ty);
 1191   Type *Ty = cast<PointerType>(PtrA->getType())->getElementType();
 1199   ASA = cast<PointerType>(PtrA->getType())->getAddressSpace();
 1200   ASB = cast<PointerType>(PtrB->getType())->getAddressSpace();

lib/Analysis/MemoryBuiltins.cpp

  356 PointerType *llvm::getMallocType(const CallInst *CI,
  360   PointerType *MallocType = nullptr;
  367       MallocType = cast<PointerType>(BCI->getDestTy());
  377     return cast<PointerType>(CI->getType());
  390   PointerType *PT = getMallocType(CI, TLI);
  659   PointerType *PT = cast<PointerType>(A.getType());
  659   PointerType *PT = cast<PointerType>(A.getType());

lib/Analysis/ScalarEvolution.cpp

  496               AllocTy = cast<PointerType>(CE->getOperand(0)->getType())
  511             cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
  538             cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
 8078         if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) {
 8078         if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) {
 8102           if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) {
 8102           if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) {
11143   Type *ETy = getEffectiveSCEVType(PointerType::getUnqual(Ty));

lib/Analysis/ScalarEvolutionExpander.cpp

  404                                     PointerType *PTy,
  596 Value *SCEVExpander::expandAddToGEP(const SCEV *Op, PointerType *PTy, Type *Ty,
  714     } else if (PointerType *PTy = dyn_cast<PointerType>(Sum->getType())) {
  714     } else if (PointerType *PTy = dyn_cast<PointerType>(Sum->getType())) {
  728     } else if (PointerType *PTy = dyn_cast<PointerType>(Op->getType())) {
  728     } else if (PointerType *PTy = dyn_cast<PointerType>(Op->getType())) {
  971       unsigned AS = cast<PointerType>(IncV->getType())->getAddressSpace();
 1058     PointerType *GEPPtrTy = cast<PointerType>(ExpandTy);
 1058     PointerType *GEPPtrTy = cast<PointerType>(ExpandTy);
 1062       GEPPtrTy = PointerType::get(Type::getInt1Ty(SE.getContext()),
 1467     if (PointerType *PTy = dyn_cast<PointerType>(ExpandTy)) {
 1467     if (PointerType *PTy = dyn_cast<PointerType>(ExpandTy)) {
 1539     if (PointerType *PTy = dyn_cast<PointerType>(Base->getType())) {
 1539     if (PointerType *PTy = dyn_cast<PointerType>(Base->getType())) {
 1882     if (PointerType *Vty = dyn_cast<PointerType>(V->getType())) {
 1882     if (PointerType *Vty = dyn_cast<PointerType>(V->getType())) {
 2295   if (PointerType *ARPtrTy = dyn_cast<PointerType>(ARExpandTy)) {
 2295   if (PointerType *ARPtrTy = dyn_cast<PointerType>(ARExpandTy)) {

lib/Analysis/ValueTracking.cpp

 3246           cast<PointerType>(CE->getType())->getAddressSpace());

lib/Analysis/VectorUtils.cpp

  186   auto *PtrTy = dyn_cast<PointerType>(Ptr->getType());
  186   auto *PtrTy = dyn_cast<PointerType>(Ptr->getType());
  835       PointerType *PtrTy = cast<PointerType>(Ptr->getType());
  835       PointerType *PtrTy = cast<PointerType>(Ptr->getType());

lib/AsmParser/LLParser.cpp

  920   auto *PTy = dyn_cast<PointerType>(AliaseeType);
  920   auto *PTy = dyn_cast<PointerType>(AliaseeType);
 1059   if (Ty->isFunctionTy() || !PointerType::isValidElementType(Ty))
 1364 static inline GlobalValue *createGlobalFwdRef(Module *M, PointerType *PTy,
 1382   if (IsCall && isa<PointerType>(Ty)) {
 1383     Type *TyInProgAS = cast<PointerType>(Ty)->getElementType()->getPointerTo(
 1403   PointerType *PTy = dyn_cast<PointerType>(Ty);
 1403   PointerType *PTy = dyn_cast<PointerType>(Ty);
 1434   PointerType *PTy = dyn_cast<PointerType>(Ty);
 1434   PointerType *PTy = dyn_cast<PointerType>(Ty);
 2393       if (!PointerType::isValidElementType(Result))
 2395       Result = PointerType::getUnqual(Result);
 2405       if (!PointerType::isValidElementType(Result))
 2412       Result = PointerType::get(Result, AddrSpace);
 3577       auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
 3577       auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
 5193     V = ConstantPointerNull::get(cast<PointerType>(Ty));
 5437   PointerType *PFT = PointerType::get(FT, AddrSpace);
 5437   PointerType *PFT = PointerType::get(FT, AddrSpace);
 6085   if (ConvertValIDToValue(PointerType::get(Ty, InvokeAddrSpace), CalleeID,
 6412   if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS,
 6814   if (ConvertValIDToValue(PointerType::get(Ty, CallAddrSpace), CalleeID, Callee,
 6883   if (Ty->isFunctionTy() || !PointerType::isValidElementType(Ty))
 6969   if (Ty != cast<PointerType>(Val->getType())->getElementType())
 7012   if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
 7063   if (cast<PointerType>(Ptr->getType())->getElementType() != Cmp->getType())
 7065   if (cast<PointerType>(Ptr->getType())->getElementType() != New->getType())
 7126   if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
 7196   PointerType *BasePointerType = dyn_cast<PointerType>(BaseType->getScalarType());
 7196   PointerType *BasePointerType = dyn_cast<PointerType>(BaseType->getScalarType());

lib/Bitcode/Reader/BitcodeReader.cpp

  607     return flattenPointerTypes(cast<PointerType>(Ty)->getElementType());
  614     Type *ElTy = cast<PointerType>(FullTy)->getElementType();
 1775           !PointerType::isValidElementType(ResultTy))
 1777       ResultTy = PointerType::get(ResultTy, AddressSpace);
 3109     AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
 3156   FullTy = PointerType::get(FullTy, AddressSpace);
 3206   if (isa<PointerType>(FTy))
 3303   Type *FullTy = PointerType::get(FullFTy, AddrSpace);
 3342     auto *PTy = dyn_cast<PointerType>(Ty);
 3342     auto *PTy = dyn_cast<PointerType>(Ty);
 3394   FullTy = PointerType::get(FullTy, AddrSpace);
 3668   if (!isa<PointerType>(PtrType))
 3670   Type *ElemType = cast<PointerType>(PtrType)->getElementType();
 3675   if (!PointerType::isLoadableOrStorableType(ElemType))
 4490       PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
 4490       PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
 4495             dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
 4577       PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
 4577       PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
 4582             dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
 4746         auto *PTy = dyn_cast_or_null<PointerType>(Ty);
 4746         auto *PTy = dyn_cast_or_null<PointerType>(Ty);
 4768       FullTy = PointerType::get(FullTy, AS);
 4779       if (!isa<PointerType>(Op->getType()))
 4807       if (!isa<PointerType>(Op->getType()))
 4865           !isa<PointerType>(Ptr->getType()) ||
 4900       if (!isa<PointerType>(Ptr->getType()))
 4910         FullTy = cast<PointerType>(FullTy)->getElementType();
 4955           !isa<PointerType>(Ptr->getType()) ||
 5018       PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
 5018       PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
 5023             dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());

lib/Bitcode/Writer/BitcodeWriter.cpp

  892       PointerType *PTy = cast<PointerType>(T);
  892       PointerType *PTy = cast<PointerType>(T);

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 1998       !isa<PointerType>(ETy->getTypeAtIndex(1U)) ||
 1999       !isa<PointerType>(ETy->getTypeAtIndex(2U)))

lib/CodeGen/AtomicExpandPass.cpp

  380   Type *PT = PointerType::get(NewTy,
  437   Type *Ty = cast<PointerType>(Addr->getType())->getElementType();
  467   Type *PT = PointerType::get(NewTy,
 1061   Type *PT = PointerType::get(NewTy,

lib/CodeGen/BuiltinGCs.cpp

   77     const PointerType *PT = cast<PointerType>(Ty);
   77     const PointerType *PT = cast<PointerType>(Ty);
  109     const PointerType *PT = cast<PointerType>(Ty);
  109     const PointerType *PT = cast<PointerType>(Ty);

lib/CodeGen/CodeGenPrepare.cpp

 1806                        cast<PointerType>(Arg->getType())->getAddressSpace()),
 4595     PointerType *AddrTy = dyn_cast<PointerType>(Address->getType());
 4595     PointerType *AddrTy = dyn_cast<PointerType>(Address->getType());
 4920     PointerType *BasePtrTy = dyn_cast_or_null<PointerType>(BaseTy);
 4920     PointerType *BasePtrTy = dyn_cast_or_null<PointerType>(BaseTy);
 4921     PointerType *ScalePtrTy = dyn_cast_or_null<PointerType>(ScaleTy);
 4921     PointerType *ScalePtrTy = dyn_cast_or_null<PointerType>(ScaleTy);

lib/CodeGen/GCRootLowering.cpp

  163           ConstantPointerNull::get(cast<PointerType>(Root->getAllocatedType())),

lib/CodeGen/GlobalISel/CallLowering.cpp

   97     Type *ElementTy = cast<PointerType>(Arg.Ty)->getElementType();

lib/CodeGen/GlobalMerge.cpp

  623     PointerType *PT = dyn_cast<PointerType>(GV.getType());
  623     PointerType *PT = dyn_cast<PointerType>(GV.getType());

lib/CodeGen/InterleavedLoadCombinePass.cpp

  959     PointerType *PtrTy = dyn_cast<PointerType>(Ptr.getType());
  959     PointerType *PtrTy = dyn_cast<PointerType>(Ptr.getType());

lib/CodeGen/IntrinsicLowering.cpp

  334         ConstantPointerNull::get(cast<PointerType>(CI->getType())));
  340         ConstantPointerNull::get(cast<PointerType>(CI->getType())));

lib/CodeGen/LowLevelType.cpp

   27   } else if (auto PTy = dyn_cast<PointerType>(&Ty)) {

lib/CodeGen/LowerEmuTLS.cpp

   86   PointerType *VoidPtrType = Type::getInt8PtrTy(C);
  115   PointerType *InitPtrType = InitValue ?
  116       PointerType::getUnqual(InitValue->getType()) : VoidPtrType;

lib/CodeGen/MachineFunction.cpp

 1042   if (isa<PointerType>(A->getType()))
 1048   if (isa<PointerType>(B->getType()))

lib/CodeGen/SelectionDAG/FastISel.cpp

 1176       FinalType = cast<PointerType>(Arg.Ty)->getElementType();
 1207       PointerType *Ty = cast<PointerType>(Arg.Ty);
 1207       PointerType *Ty = cast<PointerType>(Arg.Ty);

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

  990                    PointerType::get(Type::getInt8Ty(*getContext()), 0) :

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 1870               cast<PointerType>(I.getOperand(0)->getType())->getAddressSpace());
 7210                                          PointerType::getUnqual(LoadTy));
 7767       PointerType *PtrTy = dyn_cast<PointerType>(OpTy);
 7767       PointerType *PtrTy = dyn_cast<PointerType>(OpTy);
 9032     Type *StackSlotPtrType = PointerType::get(CLI.RetTy,
 9081               cast<PointerType>(CLI.RetTy)->getAddressSpace());
 9117       FinalType = cast<PointerType>(Args[i].Ty)->getElementType();
 9136             cast<PointerType>(Args[i].Ty)->getAddressSpace());
 9175         PointerType *Ty = cast<PointerType>(Args[i].Ty);
 9175         PointerType *Ty = cast<PointerType>(Args[i].Ty);
 9637             cast<PointerType>(Arg.getType())->getAddressSpace());

lib/CodeGen/SelectionDAG/StatepointLowering.cpp

  977     PointerType *CalleeType = cast<PointerType>(
  977     PointerType *CalleeType = cast<PointerType>(

lib/CodeGen/SelectionDAG/TargetLowering.cpp

 4235         llvm::PointerType *PtrTy = dyn_cast<PointerType>(OpTy);
 4235         llvm::PointerType *PtrTy = dyn_cast<PointerType>(OpTy);
 4262       } else if (PointerType *PT = dyn_cast<PointerType>(OpTy)) {
 4262       } else if (PointerType *PT = dyn_cast<PointerType>(OpTy)) {
 6825   PointerType *VoidPtrType = Type::getInt8PtrTy(*DAG.getContext());

lib/CodeGen/ShadowStackGCLowering.cpp

  189   PointerType *FrameMapPtrTy = PointerType::getUnqual(FrameMapTy);
  189   PointerType *FrameMapPtrTy = PointerType::getUnqual(FrameMapTy);
  200   EltTys.push_back(PointerType::getUnqual(StackEntryTy));
  203   PointerType *StackEntryPtrTy = PointerType::getUnqual(StackEntryTy);
  203   PointerType *StackEntryPtrTy = PointerType::getUnqual(StackEntryTy);

lib/CodeGen/SjLjEHPrepare.cpp

  476       PointerType::getUnqual(FunctionContextTy));
  479       PointerType::getUnqual(FunctionContextTy));

lib/CodeGen/StackProtector.cpp

  386   PointerType *PtrTy = Type::getInt8PtrTy(RI->getContext());

lib/CodeGen/TargetLoweringBase.cpp

 1772     PointerType *PtrTy = Type::getInt8PtrTy(M.getContext());

lib/ExecutionEngine/Orc/IndirectionUtils.cpp

  224                           PointerType::get(&FT, 0));
  228 GlobalVariable* createImplPointer(PointerType &PT, Module &M,

lib/FuzzMutate/Operations.cpp

  172     Type *Ty = cast<PointerType>(Srcs[0]->getType())->getElementType();

lib/FuzzMutate/RandomIRBuilder.cpp

   57         cast<PointerType>(Ptr->getType())->getElementType(), Ptr, "L", &*IP);
  127       Ptr = UndefValue::get(PointerType::get(V->getType(), 0));
  142     if (auto PtrTy = dyn_cast<PointerType>(Inst->getType())) {

lib/IR/AsmWriter.cpp

  609     PointerType *PTy = cast<PointerType>(Ty);
  609     PointerType *PTy = cast<PointerType>(Ty);

lib/IR/AutoUpgrade.cpp

 1217                               llvm::PointerType::getUnqual(Data->getType()));
 1237   Ptr = Builder.CreateBitCast(Ptr, llvm::PointerType::getUnqual(ValTy));
 1681       PointerType *EltPtrTy = PointerType::getUnqual(SrcEltTy);
 1681       PointerType *EltPtrTy = PointerType::getUnqual(SrcEltTy);
 1707                                         PointerType::getUnqual(Arg1->getType()),
 1727                                         PointerType::getUnqual(Elt->getType()),
 1743                                    PointerType::getUnqual(Arg1->getType()),
 2129                                          llvm::PointerType::getUnqual(PtrTy));
 2144                                          llvm::PointerType::getUnqual(PtrTy));
 2286                                             PointerType::getUnqual(VT));
 3032           Builder.CreateBitCast(Ptr, PointerType::getUnqual(VTy), "cast");
 3414                                  llvm::PointerType::getUnqual(Data->getType()));
 3636                                  llvm::PointerType::getUnqual(Data->getType()));

lib/IR/ConstantFold.cpp

  108   if (PointerType *PTy = dyn_cast<PointerType>(V->getType()))
  108   if (PointerType *PTy = dyn_cast<PointerType>(V->getType()))
  109     if (PointerType *DPTy = dyn_cast<PointerType>(DestTy))
  109     if (PointerType *DPTy = dyn_cast<PointerType>(DestTy))
  162     return ConstantPointerNull::get(cast<PointerType>(DestTy));
  384   if (PointerType *PTy = dyn_cast<PointerType>(Ty))
  384   if (PointerType *PTy = dyn_cast<PointerType>(Ty))
  387         getFoldedSizeOf(PointerType::get(IntegerType::get(PTy->getContext(), 1),
  447   if (PointerType *PTy = dyn_cast<PointerType>(Ty))
  447   if (PointerType *PTy = dyn_cast<PointerType>(Ty))
  450         getFoldedAlignOf(PointerType::get(IntegerType::get(PTy->getContext(),
  626       return ConstantPointerNull::get(cast<PointerType>(DestTy));
 2192       PointerType *PtrTy = cast<PointerType>(C->getType()->getScalarType());
 2192       PointerType *PtrTy = cast<PointerType>(C->getType()->getScalarType());
 2196       Type *OrigGEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
 2197       Type *GEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
 2311       PointerType *SrcPtrTy =
 2312         dyn_cast<PointerType>(CE->getOperand(0)->getType());
 2313       PointerType *DstPtrTy = dyn_cast<PointerType>(CE->getType());
 2313       PointerType *DstPtrTy = dyn_cast<PointerType>(CE->getType());

lib/IR/Constants.cpp

  313     return ConstantPointerNull::get(cast<PointerType>(Ty));
  333   if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy))
  333   if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy))
 1432 ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) {
 1823   PointerType *SrcScalarTy = cast<PointerType>(C->getType()->getScalarType());
 1823   PointerType *SrcScalarTy = cast<PointerType>(C->getType()->getScalarType());
 1824   PointerType *DstScalarTy = cast<PointerType>(DstTy->getScalarType());
 1824   PointerType *DstScalarTy = cast<PointerType>(DstTy->getScalarType());
 1827     Type *MidTy = PointerType::get(DstElemTy, SrcScalarTy->getAddressSpace());
 1932       Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
 1963       Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
 2012     Ty = cast<PointerType>(C->getType()->getScalarType())->getElementType();

lib/IR/ConstantsContext.h

  357   using TypeClass = PointerType;
  557                      : cast<PointerType>(Ops[0]->getType()->getScalarType())

lib/IR/Core.cpp

  748   return wrap(PointerType::get(unwrap(ElementType), AddressSpace));
  757   if (auto *PTy = dyn_cast<PointerType>(Ty))
  757   if (auto *PTy = dyn_cast<PointerType>(Ty))
  771   return unwrap<PointerType>(PointerTy)->getAddressSpace();
 1043   return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty)));
 1646       cast<PointerType>(Val->getType()->getScalarType())->getElementType();
 1657       cast<PointerType>(Val->getType()->getScalarType())->getElementType();
 2201   auto *PTy = cast<PointerType>(unwrap(Ty));
 2201   auto *PTy = cast<PointerType>(unwrap(Ty));
 3114       cast<FunctionType>(cast<PointerType>(V->getType())->getElementType());
 3484   PointerType *Ty = cast<PointerType>(V->getType());
 3484   PointerType *Ty = cast<PointerType>(V->getType());
 3589       cast<PointerType>(Val->getType()->getScalarType())->getElementType();
 3606       cast<PointerType>(Val->getType()->getScalarType())->getElementType();
 3622       cast<PointerType>(Val->getType()->getScalarType())->getElementType();
 3843       cast<FunctionType>(cast<PointerType>(V->getType())->getElementType());

lib/IR/DataLayout.cpp

  675   return getPointerSizeInBits(cast<PointerType>(Ty)->getAddressSpace());
  691   return getIndexSizeInBits(cast<PointerType>(Ty)->getAddressSpace());
  711     unsigned AS = cast<PointerType>(Ty)->getAddressSpace();

lib/IR/Function.cpp

  590   if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
  590   if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
  969     return PointerType::get(DecodeFixedType(Infos, Tys, Context),
 1015     return PointerType::getUnqual(Ty);
 1023     return PointerType::getUnqual(EltTy);
 1153       PointerType *PT = dyn_cast<PointerType>(Ty);
 1153       PointerType *PT = dyn_cast<PointerType>(Ty);
 1190         case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
 1257       PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
 1257       PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
 1265       PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
 1265       PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
 1296       PointerType *ThisArgEltTy =
 1297               dyn_cast<PointerType>(ThisArgVecTy->getVectorElementType());

lib/IR/Globals.cpp

  112   PointerType *PtrTy = getType();
  505   PointerType *PTy = Aliasee->getType();

lib/IR/IRBuilder.cpp

   62   auto *PT = cast<PointerType>(Ptr->getType());
   62   auto *PT = cast<PointerType>(Ptr->getType());
  473   auto *PtrTy = cast<PointerType>(Ptr->getType());
  473   auto *PtrTy = cast<PointerType>(Ptr->getType());
  493   auto *PtrTy = cast<PointerType>(Ptr->getType());
  493   auto *PtrTy = cast<PointerType>(Ptr->getType());
  526   auto PtrTy = cast<PointerType>(PtrsTy->getElementType());
  560   auto PtrTy = cast<PointerType>(PtrsTy->getElementType());
  607   auto *FuncPtrType = cast<PointerType>(ActualCallee->getType());
  607   auto *FuncPtrType = cast<PointerType>(ActualCallee->getType());
  658   auto *FuncPtrType = cast<PointerType>(ActualInvokee->getType());
  658   auto *FuncPtrType = cast<PointerType>(ActualInvokee->getType());

lib/IR/InlineAsm.cpp

   33     : Value(PointerType::getUnqual(FTy), Value::InlineAsmVal),
   48   return pImpl->InlineAsms.getOrCreate(PointerType::getUnqual(FTy), Key);

lib/IR/Instructions.cpp

  574   PointerType *AllocPtrType = PointerType::getUnqual(AllocTy);
  574   PointerType *AllocPtrType = PointerType::getUnqual(AllocTy);
 1230     : UnaryInstruction(PointerType::get(Ty, AddrSpace), Alloca,
 1241     : UnaryInstruction(PointerType::get(Ty, AddrSpace), Alloca,
 3039   if (PointerType *DestPtrTy = dyn_cast<PointerType>(DestTy)) {
 3039   if (PointerType *DestPtrTy = dyn_cast<PointerType>(DestTy)) {
 3040     if (PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy)) {
 3040     if (PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy)) {
 3065   if (auto *PtrTy = dyn_cast<PointerType>(SrcTy))
 3065   if (auto *PtrTy = dyn_cast<PointerType>(SrcTy))
 3069   if (auto *PtrTy = dyn_cast<PointerType>(DestTy))
 3069   if (auto *PtrTy = dyn_cast<PointerType>(DestTy))
 3249     PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
 3249     PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
 3250     PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType());
 3250     PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType());
 3279     PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
 3279     PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
 3283     PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType());
 3283     PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType());

lib/IR/LLVMContextImpl.h

 1302   DenseMap<PointerType *, std::unique_ptr<ConstantPointerNull>> CPNConstants;
 1338   DenseMap<Type*, PointerType*> PointerTypes;  // Pointers in AddrSpace = 0
 1339   DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;

lib/IR/Mangler.cpp

  102       Ty = cast<PointerType>(Ty)->getElementType();

lib/IR/Module.cpp

  159   auto *PTy = PointerType::get(Ty, F->getAddressSpace());
  159   auto *PTy = PointerType::get(Ty, F->getAddressSpace());
  216   PointerType *PTy = PointerType::get(Ty, GVTy->getPointerAddressSpace());
  216   PointerType *PTy = PointerType::get(Ty, GVTy->getPointerAddressSpace());

lib/IR/SafepointIRVerifier.cpp

  254   if (auto *PT = dyn_cast<PointerType>(T))
  254   if (auto *PT = dyn_cast<PointerType>(T))

lib/IR/Type.cpp

   90   if (auto *PTy = dyn_cast<PointerType>(this)) {
   91     if (auto *OtherPTy = dyn_cast<PointerType>(Ty))
   91     if (auto *OtherPTy = dyn_cast<PointerType>(Ty))
  188 PointerType *Type::getHalfPtrTy(LLVMContext &C, unsigned AS) {
  192 PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) {
  196 PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) {
  200 PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) {
  204 PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) {
  208 PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) {
  212 PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) {
  216 PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) {
  220 PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) {
  224 PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) {
  228 PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) {
  232 PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
  236 PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
  637 PointerType *PointerType::get(Type *EltTy, unsigned AddressSpace) {
  644   PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy]
  648     Entry = new (CImpl->Alloc) PointerType(EltTy, AddressSpace);
  659 PointerType *Type::getPointerTo(unsigned addrs) const {
  660   return PointerType::get(const_cast<Type*>(this), addrs);

lib/IR/Value.cpp

  617       Type *PT = cast<PointerType>(A->getType())->getElementType();
  707       Type *EltTy = cast<PointerType>(A->getType())->getElementType();

lib/IR/Verifier.cpp

  645       PointerType *FuncPtrTy =
  669       PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
  669       PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
 1662   if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
 1662   if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
 1670     if (!isa<PointerType>(PTy->getElementType()))
 1958   auto *PT = dyn_cast<PointerType>(Target->getType());
 1958   auto *PT = dyn_cast<PointerType>(Target->getType());
 2726   if (auto *PTy = dyn_cast<PointerType>(SrcTy->getScalarType()))
 2726   if (auto *PTy = dyn_cast<PointerType>(SrcTy->getScalarType()))
 2753   if (auto *PTy = dyn_cast<PointerType>(DestTy->getScalarType()))
 2753   if (auto *PTy = dyn_cast<PointerType>(DestTy->getScalarType()))
 2820   PointerType *FPTy = cast<PointerType>(Call.getCalledValue()->getType());
 2820   PointerType *FPTy = cast<PointerType>(Call.getCalledValue()->getType());
 3027   PointerType *PL = dyn_cast<PointerType>(L);
 3027   PointerType *PL = dyn_cast<PointerType>(L);
 3028   PointerType *PR = dyn_cast<PointerType>(R);
 3028   PointerType *PR = dyn_cast<PointerType>(R);
 3309   if (auto *PTy = dyn_cast<PointerType>(GEP.getType())) {
 3309   if (auto *PTy = dyn_cast<PointerType>(GEP.getType())) {
 3377   PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType());
 3377   PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType());
 3403   PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType());
 3403   PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType());
 3464   PointerType *PTy = AI.getType();
 3502   PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType());
 3502   PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType());
 3522   PointerType *PTy = dyn_cast<PointerType>(RMWI.getOperand(0)->getType());
 3522   PointerType *PTy = dyn_cast<PointerType>(RMWI.getOperand(0)->getType());
 4490     auto *PT = cast<PointerType>(Target->getType());
 4490     auto *PT = cast<PointerType>(Target->getType());
 4623     Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType();
 4644     Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType();

lib/Linker/IRMover.cpp

  165   if (PointerType *PT = dyn_cast<PointerType>(DstTy)) {
  165   if (PointerType *PT = dyn_cast<PointerType>(DstTy)) {
  166     if (PT->getAddressSpace() != cast<PointerType>(SrcTy)->getAddressSpace())
  310     return *Entry = PointerType::get(ElementTypes[0],
  311                                      cast<PointerType>(Ty)->getAddressSpace());
  859   PointerType *VoidPtrTy = Type::getInt8Ty(SrcGV->getContext())->getPointerTo();

lib/Linker/LinkModules.cpp

  441     PointerType &Ty = *cast<PointerType>(Alias.getType());
  441     PointerType &Ty = *cast<PointerType>(Alias.getType());

lib/Target/AArch64/AArch64FastISel.cpp

  596   if (auto *Ty = dyn_cast<PointerType>(Obj->getType()))
  596   if (auto *Ty = dyn_cast<PointerType>(Obj->getType()))

lib/Target/AArch64/AArch64ISelLowering.cpp

 8417     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(0)->getType());
 8417     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(0)->getType());
 8428     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(1)->getType());
 8428     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(1)->getType());
12172   Type *ValTy = cast<PointerType>(Addr->getType())->getElementType();
12199   Type *EltTy = cast<PointerType>(Addr->getType())->getElementType();

lib/Target/AMDGPU/AMDGPUCallLowering.cpp

  349   PointerType *PtrTy = PointerType::get(ParamTy, AMDGPUAS::CONSTANT_ADDRESS);
  349   PointerType *PtrTy = PointerType::get(ParamTy, AMDGPUAS::CONSTANT_ADDRESS);
  371   PointerType *PtrTy = PointerType::get(ParamTy, AMDGPUAS::CONSTANT_ADDRESS);
  371   PointerType *PtrTy = PointerType::get(ParamTy, AMDGPUAS::CONSTANT_ADDRESS);

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

  941     Type *PT = PointerType::get(I32Ty, I.getPointerAddressSpace());

lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp

  122              .Default(isa<PointerType>(Ty) ?
  349   if (auto PtrTy = dyn_cast<PointerType>(Ty)) {
  378   if (auto PtrTy = dyn_cast<PointerType>(Ty))
  564       .Default(isa<PointerType>(Ty)
  766   if (auto PtrTy = dyn_cast<PointerType>(Ty)) {
  805   if (auto PtrTy = dyn_cast<PointerType>(Ty))

lib/Target/AMDGPU/AMDGPUInline.cpp

  133     PointerType *Ty = dyn_cast<PointerType>(PtrArg->getType());
  133     PointerType *Ty = dyn_cast<PointerType>(PtrArg->getType());

lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp

 1189   Value *V = UndefValue::get(PointerType::get(

lib/Target/AMDGPU/AMDGPULibCalls.cpp

  608   auto *PtrTy = llvm::PointerType::get(PtrElemTy, PtrArgAS);
  608   auto *PtrTy = llvm::PointerType::get(PtrElemTy, PtrArgAS);

lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp

  107     if (PointerType *PT = dyn_cast<PointerType>(ArgTy)) {
  107     if (PointerType *PT = dyn_cast<PointerType>(ArgTy)) {
  168     if (isa<PointerType>(ArgTy)) {

lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp

  302   if (auto PT = dyn_cast<PointerType>(V->getType())) {
  311   if (auto PT = dyn_cast<PointerType>(V->getType()))
  343   if (auto PT = dyn_cast<PointerType>(V->getType())) {

lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

  138   const PointerType *PT = dyn_cast<PointerType>(OpType);
  138   const PointerType *PT = dyn_cast<PointerType>(OpType);
  328       Type *I8Ptr = PointerType::get(Type::getInt8Ty(Ctx), 1);
  360           ConstantPointerNull::get(PointerType::get(Type::getInt8Ty(Ctx), 1));
  385       Type *idPointer = PointerType::get(I32Ty, AMDGPUAS::GLOBAL_ADDRESS);
  539           Type *ArgPointer = PointerType::get(TheBtCast->getType(), 1);

lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

  246     DispatchPtr, PointerType::get(I32Ty, AMDGPUAS::CONSTANT_ADDRESS));
  633     PointerType *PtrTy = dyn_cast<PointerType>(ParamTy);
  633     PointerType *PtrTy = dyn_cast<PointerType>(ParamTy);
  835         PointerType *NewTy = PointerType::get(EltTy, AMDGPUAS::LOCAL_ADDRESS);
  835         PointerType *NewTy = PointerType::get(EltTy, AMDGPUAS::LOCAL_ADDRESS);
  852       PointerType *NewTy = PointerType::get(EltTy, AMDGPUAS::LOCAL_ADDRESS);
  852       PointerType *NewTy = PointerType::get(EltTy, AMDGPUAS::LOCAL_ADDRESS);
  921         { Intr->getType(), PointerType::get(SrcTy, AMDGPUAS::LOCAL_ADDRESS) }

lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp

  190   PointerType *ArgTy = dyn_cast<PointerType>(Arg.getType());
  190   PointerType *ArgTy = dyn_cast<PointerType>(Arg.getType());
  452     PointerType *ArgType = cast<PointerType>(Arg.getType());
  452     PointerType *ArgType = cast<PointerType>(Arg.getType());

lib/Target/AMDGPU/R600ISelLowering.cpp

  905   PointerType * PtrType = PointerType::get(VT.getTypeForEVT(*DAG.getContext()),
  905   PointerType * PtrType = PointerType::get(VT.getTypeForEVT(*DAG.getContext()),
 1611     PointerType *PtrTy = PointerType::get(VT.getTypeForEVT(*DAG.getContext()),
 1611     PointerType *PtrTy = PointerType::get(VT.getTypeForEVT(*DAG.getContext()),

lib/Target/AMDGPU/SIFrameLowering.cpp

  581     PointerType *PtrTy =
  582       PointerType::get(Type::getInt64Ty(MF.getFunction().getContext()),
  626         PointerType *PtrTy =
  627           PointerType::get(Type::getInt64Ty(MF.getFunction().getContext()),

lib/Target/AMDGPU/SIISelLowering.cpp

 1463   PointerType *PtrTy = PointerType::get(Ty, AMDGPUAS::CONSTANT_ADDRESS);
 1463   PointerType *PtrTy = PointerType::get(Ty, AMDGPUAS::CONSTANT_ADDRESS);
 2142       auto *ParamTy =
 2143         dyn_cast<PointerType>(FType->getParamType(Ins[i].getOrigArgIndex()));
 4690   Value *V = UndefValue::get(PointerType::get(Type::getInt8Ty(*DAG.getContext()),
 5096   PointerType *PtrTy = PointerType::get(Ty, AMDGPUAS::CONSTANT_ADDRESS);
 5096   PointerType *PtrTy = PointerType::get(Ty, AMDGPUAS::CONSTANT_ADDRESS);

lib/Target/ARM/ARMCodeGenPrepare.cpp

  218     Ty = cast<PointerType>(Ld->getPointerOperandType())->getElementType();
  829       if (isa<PointerType>(I->getOperand(0)->getType()))

lib/Target/ARM/ARMFastISel.cpp

  730   if (PointerType *Ty = dyn_cast<PointerType>(Obj->getType()))
  730   if (PointerType *Ty = dyn_cast<PointerType>(Obj->getType()))

lib/Target/ARM/ARMISelLowering.cpp

16333     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(0)->getType());
16333     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(0)->getType());
16345     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(1)->getType());
16345     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(1)->getType());
16609   Type *ValTy = cast<PointerType>(Addr->getType())->getElementType();
16639       cast<PointerType>(Addr->getType())->getElementType());

lib/Target/ARM/MVETailPredication.cpp

  285   auto *PtrTy = cast<PointerType>(I->getOperand(TypeOp)->getType());
  285   auto *PtrTy = cast<PointerType>(I->getOperand(TypeOp)->getType());

lib/Target/AVR/AVR.h

   44   return cast<PointerType>(V->getType())->getAddressSpace() == ProgramMemory;

lib/Target/AVR/AVRISelLowering.cpp

  755   if (isa<PointerType>(Ty) && AS == AVR::ProgramMemory) {

lib/Target/Hexagon/HexagonCommonGEP.cpp

  204     if (auto *PTy = dyn_cast<PointerType>(Ty))
  204     if (auto *PTy = dyn_cast<PointerType>(Ty))
  382   Type *PtrTy = cast<PointerType>(PtrOp->getType())->getElementType();
 1127     Type *ElTy = cast<PointerType>(InpTy->getScalarType())->getElementType();

lib/Target/Hexagon/HexagonISelLowering.cpp

 3243   auto PT = cast<PointerType>(Addr->getType());
 3251   PointerType *NewPtrTy

lib/Target/Hexagon/HexagonOptimizeSZextends.cpp

   75       if (!isa<PointerType>(Arg.getType())) {

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

  361     } else if (isa<PointerType>(Ty)) {
  666   PointerType *Pty = gv->getType();
 1012   PointerType *PTy = GVar->getType();
 1487       auto *PTy = dyn_cast<PointerType>(Ty);
 1487       auto *PTy = dyn_cast<PointerType>(Ty);
 1535       } else if (isa<PointerType>(Ty))
 1553     auto *PTy = dyn_cast<PointerType>(Ty);
 1553     auto *PTy = dyn_cast<PointerType>(Ty);
 1740     PointerType *PTy = dyn_cast<PointerType>(Cexpr->getType());
 1740     PointerType *PTy = dyn_cast<PointerType>(Cexpr->getType());
 2016     PointerType *DstTy = cast<PointerType>(CE->getType());
 2016     PointerType *DstTy = cast<PointerType>(CE->getType());

lib/Target/NVPTX/NVPTXAsmPrinter.h

  163               PointerType *PTy = dyn_cast<PointerType>(v0->getType());
  163               PointerType *PTy = dyn_cast<PointerType>(v0->getType());

lib/Target/NVPTX/NVPTXGenericToNVVM.cpp

  177           PointerType::get(GV->getValueType(), llvm::ADDRESS_SPACE_GENERIC));

lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp

  661   if (auto *PT = dyn_cast<PointerType>(Src->getType())) {
  661   if (auto *PT = dyn_cast<PointerType>(Src->getType())) {
 3684   if (auto *PT = dyn_cast<PointerType>(Src->getType()))
 3684   if (auto *PT = dyn_cast<PointerType>(Src->getType()))

lib/Target/NVPTX/NVPTXISelLowering.cpp

 1292     } else if (isa<PointerType>(retTy)) {
 1343       } else if (isa<PointerType>(Ty)) {
 1356     auto *PTy = dyn_cast<PointerType>(Ty);
 1356     auto *PTy = dyn_cast<PointerType>(Ty);
 1580     auto *PTy = dyn_cast<PointerType>(Args[i].Ty);
 1580     auto *PTy = dyn_cast<PointerType>(Args[i].Ty);
 2446   auto *PTy = dyn_cast<PointerType>(Ty);
 2446   auto *PTy = dyn_cast<PointerType>(Ty);
 2589           Value *srcValue = Constant::getNullValue(PointerType::get(

lib/Target/NVPTX/NVPTXLowerAlloca.cpp

   73         auto PTy = dyn_cast<PointerType>(allocaInst->getType());
   75         auto LocalAddrTy = PointerType::get(ETy, ADDRESS_SPACE_LOCAL);
   77         auto GenericAddrTy = PointerType::get(ETy, ADDRESS_SPACE_GENERIC);

lib/Target/NVPTX/NVPTXLowerArgs.cpp

  157   PointerType *PType = dyn_cast<PointerType>(Arg->getType());
  157   PointerType *PType = dyn_cast<PointerType>(Arg->getType());
  171       Arg, PointerType::get(StructType, ADDRESS_SPACE_PARAM), Arg->getName(),
  195       Ptr, PointerType::get(Ptr->getType()->getPointerElementType(),

lib/Target/RISCV/RISCVISelLowering.cpp

  240     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(0)->getType());
  240     PointerType *PtrTy = cast<PointerType>(I.getArgOperand(0)->getType());

lib/Target/Sparc/SparcISelLowering.cpp

  830       PointerType *Ty = cast<PointerType>(CLI.getArgs()[0].Ty);
  830       PointerType *Ty = cast<PointerType>(CLI.getArgs()[0].Ty);
 2140     Entry.Ty   = PointerType::getUnqual(ArgTy);
 2168     Entry.Ty   = PointerType::getUnqual(RetTy);

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

  225   if (auto *Ty = dyn_cast<PointerType>(Obj->getType()))
  225   if (auto *Ty = dyn_cast<PointerType>(Obj->getType()))

lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

  257                             PointerType::get(Type::getInt8PtrTy(C), 0)};
  266             ConstantExpr::getBitCast(Main, PointerType::get(MainTy, 0));
  279     auto *PTy = cast<PointerType>(U->get()->getType());
  279     auto *PTy = cast<PointerType>(U->get()->getType());

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

  356   PointerType *Int8PtrTy = Type::getInt8PtrTy(M.getContext());
  454     auto *CalleeTy = cast<PointerType>(Callee->getType())->getElementType();
  463   ArgTys.push_back(PointerType::getUnqual(CalleeFTy));

lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp

  106   PointerType *VoidStar = Type::getInt8PtrTy(C);
  115                         {PointerType::get(AtExitFuncTy, 0), VoidStar, VoidStar},

lib/Target/X86/X86FastISel.cpp

  847   if (PointerType *Ty = dyn_cast<PointerType>(V->getType()))
  847   if (PointerType *Ty = dyn_cast<PointerType>(V->getType()))

lib/Target/X86/X86ISelLowering.cpp

25415     Entry.Ty = PointerType::get(ArgTy,0);

lib/Target/X86/X86TargetTransformInfo.cpp

 3221   PointerType *PtrTy = dyn_cast<PointerType>(Ptr->getType());
 3221   PointerType *PtrTy = dyn_cast<PointerType>(Ptr->getType());
 3223     PtrTy = dyn_cast<PointerType>(Ptr->getType()->getVectorElementType());

lib/Transforms/CFGuard/CFGuard.cpp

  152   PointerType *GuardFnPtrType = nullptr;
  194   PointerType *PTy = PointerType::get(CalledOperandType, 0);
  194   PointerType *PTy = PointerType::get(CalledOperandType, 0);
  240   GuardFnPtrType = PointerType::get(GuardFnType, 0);

lib/Transforms/Coroutines/CoroCleanup.cpp

   47   PointerType *FramePtrTy = FrameTy->getPointerTo();

lib/Transforms/Coroutines/CoroEarly.cpp

   28   PointerType *const AnyResumeFnPtrTy;
   96   auto *FrameTy = Int8Ptr;
   97   PointerType *FramePtrTy = FrameTy->getPointerTo();
  115     auto *FramePtrTy = FrameTy->getPointerTo();
  118     auto *FnPtrTy = FnTy->getPointerTo();

lib/Transforms/Coroutines/CoroElide.cpp

   95   return cast<PointerType>(ArgType)->getElementType();

lib/Transforms/Coroutines/CoroFrame.cpp

  408     auto *FramePtrTy = FrameTy->getPointerTo();
  411     auto *FnPtrTy = FnTy->getPointerTo();
  591   PointerType *FramePtrTy = FrameTy->getPointerTo();
 1262   auto ArgTy = cast<PointerType>(Arg.getType());

lib/Transforms/Coroutines/CoroInstr.h

  188     auto *const Int8PtrTy = Type::getInt8PtrTy(getContext());

lib/Transforms/Coroutines/CoroInternal.h

   57   PointerType *const Int8Ptr;
  152   PointerType *getSwitchResumePointerType() const {
  155   return cast<PointerType>(FrameTy->getElementType(SwitchFieldIndex::Resume));
  161       auto *FnPtrTy = getSwitchResumePointerType();

lib/Transforms/Coroutines/CoroSplit.cpp

  201     PointerType *ContinuationTy =
  202       cast<PointerType>(RetStructTy ? RetStructTy->getElementType(0) : RetTy);
  305       auto *NullPtr = ConstantPointerNull::get(cast<PointerType>(
  306           cast<PointerType>(GepIndex->getType())->getElementType()));

lib/Transforms/IPO/ArgumentPromotion.cpp

  143       Type *AgTy = cast<PointerType>(I->getType())->getElementType();
  199             cast<PointerType>(I->getType()->getScalarType())->getElementType(),
  260         Type *AgTy = cast<PointerType>(I->getType())->getElementType();
  294               if (auto *ElPTy = dyn_cast<PointerType>(ElTy))
  294               if (auto *ElPTy = dyn_cast<PointerType>(ElTy))
  388       Type *AgTy = cast<PointerType>(I->getType())->getElementType();
  935     Type *AgTy = cast<PointerType>(PtrArg->getType())->getElementType();

lib/Transforms/IPO/Attributor.cpp

 3583       unsigned AS = cast<PointerType>(MallocCall->getType())->getAddressSpace();

lib/Transforms/IPO/GlobalOpt.cpp

  143           if (isa<PointerType>(InnerTy)) return true;
 1180     PointerType *PTy = cast<PointerType>(PN->getType());
 1180     PointerType *PTy = cast<PointerType>(PN->getType());
 1185       PHINode::Create(PointerType::get(ST->getElementType(FieldNo), AS),
 1301     PointerType *PFieldTy = PointerType::get(FieldTy, AS);
 1301     PointerType *PFieldTy = PointerType::get(FieldTy, AS);
 2607   PointerType *Int8PtrTy = Type::getInt8PtrTy(V.getContext(), 0);

lib/Transforms/IPO/LowerTypeTests.cpp

  391   PointerType *Int8PtrTy = Type::getInt8PtrTy(M.getContext());
  394   PointerType *Int32PtrTy = PointerType::getUnqual(Int32Ty);
  394   PointerType *Int32PtrTy = PointerType::getUnqual(Int32Ty);

lib/Transforms/IPO/MergeFunctions.cpp

  767   PointerType *PtrType = G->getType();

lib/Transforms/IPO/WholeProgramDevirt.cpp

  451   PointerType *Int8PtrTy;
 1115       PointerType *NewFTPtr = PointerType::getUnqual(NewFT);
 1115       PointerType *NewFTPtr = PointerType::getUnqual(NewFT);
 1631     Value *GEPPtr = LoadB.CreateBitCast(GEP, PointerType::getUnqual(Int8PtrTy));

lib/Transforms/InstCombine/InstCombineCalls.cpp

  159     cast<PointerType>(MI->getArgOperand(1)->getType())->getAddressSpace();
  161     cast<PointerType>(MI->getArgOperand(0)->getType())->getAddressSpace();
  164   Type *NewSrcPtrTy = PointerType::get(IntType, SrcAddrSp);
  165   Type *NewDstPtrTy = PointerType::get(IntType, DstAddrSp);
  266     unsigned DstAddrSp = cast<PointerType>(Dest->getType())->getAddressSpace();
  267     Type *NewDstPtrTy = PointerType::get(ITy, DstAddrSp);
 1317   unsigned AddrSpace = cast<PointerType>(Ptr->getType())->getAddressSpace();
 1318   PointerType *VecPtrTy = PointerType::get(II.getType(), AddrSpace);
 1318   PointerType *VecPtrTy = PointerType::get(II.getType(), AddrSpace);
 1360   unsigned AddrSpace = cast<PointerType>(Ptr->getType())->getAddressSpace();
 1361   PointerType *VecPtrTy = PointerType::get(Vec->getType(), AddrSpace);
 1361   PointerType *VecPtrTy = PointerType::get(Vec->getType(), AddrSpace);
 1454                                           PointerType::get(II.getType(), 0));
 2337                                          PointerType::getUnqual(II->getType()));
 2345                                        PointerType::getUnqual(II->getType()));
 2354         PointerType::getUnqual(II->getArgOperand(0)->getType());
 2362     Type *OpPtrTy = PointerType::getUnqual(II->getArgOperand(0)->getType());
 2373                                          PointerType::getUnqual(VTy));
 2383                                          PointerType::getUnqual(II->getType()));
 2394       Type *OpPtrTy = PointerType::getUnqual(VTy);
 2404         PointerType::getUnqual(II->getArgOperand(0)->getType());
 4008     if (auto *PT = dyn_cast<PointerType>(II->getType())) {
 4008     if (auto *PT = dyn_cast<PointerType>(II->getType())) {
 4111             cast<PointerType>(CI->getOperand(0)->getType())->getElementType();
 4114                     : cast<PointerType>(CI->getType())->getElementType();
 4359   PointerType *PTy = cast<PointerType>(Callee->getType());
 4359   PointerType *PTy = cast<PointerType>(Callee->getType());
 4508       PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
 4508       PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
 4527     PointerType *APTy = cast<PointerType>(Call.getCalledValue()->getType());
 4527     PointerType *APTy = cast<PointerType>(Call.getCalledValue()->getType());
 4796         NestF->getType() == PointerType::getUnqual(NewFTy) ?
 4798                                          PointerType::getUnqual(NewFTy));

lib/Transforms/InstCombine/InstCombineCasts.cpp

   85   PointerType *PTy = cast<PointerType>(CI.getType());
   85   PointerType *PTy = cast<PointerType>(CI.getType());
 2301   if (PointerType *DstPTy = dyn_cast<PointerType>(DestTy)) {
 2301   if (PointerType *DstPTy = dyn_cast<PointerType>(DestTy)) {
 2302     PointerType *SrcPTy = cast<PointerType>(SrcTy);
 2302     PointerType *SrcPTy = cast<PointerType>(SrcTy);
 2323         cast<PointerType>(Src->getType()->getScalarType())->getElementType();
 2476   PointerType *SrcTy = cast<PointerType>(Src->getType()->getScalarType());
 2476   PointerType *SrcTy = cast<PointerType>(Src->getType()->getScalarType());
 2477   PointerType *DestTy = cast<PointerType>(CI.getType()->getScalarType());
 2477   PointerType *DestTy = cast<PointerType>(CI.getType()->getScalarType());
 2481     Type *MidTy = PointerType::get(DestElemTy, SrcTy->getAddressSpace());

lib/Transforms/InstCombine/InstCombineInternal.h

  472   Type *FindElementAtOffset(PointerType *PtrTy, int64_t Offset,

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

  319     auto *NewT = PointerType::get(BC->getType()->getPointerElementType(),
  319     auto *NewT = PointerType::get(BC->getType()->getPointerElementType(),
  332   auto *PT = cast<PointerType>(I.getType());
  332   auto *PT = cast<PointerType>(I.getType());
  333   auto *NT = cast<PointerType>(V->getType());
  333   auto *NT = cast<PointerType>(V->getType());
  414         auto *DestTy = PointerType::get(AI.getType()->getPointerElementType(),
  414         auto *DestTy = PointerType::get(AI.getType()->getPointerElementType(),

lib/Transforms/InstCombine/InstructionCombining.cpp

 1092 Type *InstCombiner::FindElementAtOffset(PointerType *PtrTy, int64_t Offset,
 1962   PointerType *StrippedPtrTy = cast<PointerType>(StrippedPtr->getType());
 1962   PointerType *StrippedPtrTy = cast<PointerType>(StrippedPtr->getType());
 2150     PointerType *SrcType = cast<PointerType>(BCI->getSrcTy());
 2150     PointerType *SrcType = cast<PointerType>(BCI->getSrcTy());

lib/Transforms/Instrumentation/AddressSanitizer.cpp

  916         IntptrPtrTy(PointerType::get(IntptrTy, 0)), Mapping(ASan.Mapping),
 1399       auto Ty = cast<PointerType>(BasePtr->getType())->getElementType();
 1415     Type *PtrTy = cast<PointerType>(PtrOperand->getType()->getScalarType());
 1515   auto *VTy = cast<PointerType>(Addr->getType())->getElementType();
 1697   Type *ShadowPtrTy = PointerType::get(ShadowTy, 0);

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  326   PointerType *ShadowPtrTy;
  519     if (isa<PointerType>(param_type) && (FT = dyn_cast<FunctionType>(
  520             cast<PointerType>(param_type)->getElementType()))) {
  553   ShadowPtrTy = PointerType::getUnqual(ShadowTy);
  586     GetArgTLSTy = FunctionType::get(PointerType::getUnqual(ArgTLSTy), false);
  589         PointerType::getUnqual(GetArgTLSTy));
  593     GetRetvalTLSTy = FunctionType::get(PointerType::getUnqual(ShadowTy), false);
  596         PointerType::getUnqual(GetRetvalTLSTy));
  865             ConstantExpr::getBitCast(NewF, PointerType::getUnqual(FT)));
  895           ConstantExpr::getBitCast(NewF, PointerType::getUnqual(FT));
 1345         IRB.CreateBitCast(ShadowAddr, PointerType::getUnqual(ShadowTy));
 1360         IRB.CreateBitCast(ShadowAddr, PointerType::getUnqual(ShadowVecTy));
 1595           if (isa<PointerType>(T) &&
 1597                    cast<PointerType>(T)->getElementType()))) {
 1710         IRB.CreateBitCast(CS.getCalledValue(), PointerType::getUnqual(NewFT));

lib/Transforms/Instrumentation/GCOVProfiling.cpp

  868       PointerType::get(FTy, 0),
  869       PointerType::get(FTy, 0)

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

  549     Type *PtrTy = cast<PointerType>(PtrOperand->getType()->getScalarType());

lib/Transforms/Instrumentation/InstrProfiling.cpp

  792   auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
  947   auto *VoidPtrTy = Type::getInt8PtrTy(M->getContext());

lib/Transforms/Instrumentation/MemorySanitizer.cpp

  717       "__msan_get_context_state", PointerType::get(MsanContextStateTy, 0));
  719   Type *RetTy = StructType::get(PointerType::get(IRB.getInt8Ty(), 0),
  720                                 PointerType::get(IRB.getInt32Ty(), 0));
  728         name_load, RetTy, PointerType::get(IRB.getInt8Ty(), 0));
  730         name_store, RetTy, PointerType::get(IRB.getInt8Ty(), 0));
  735       PointerType::get(IRB.getInt8Ty(), 0), IRB.getInt64Ty());
  738       PointerType::get(IRB.getInt8Ty(), 0), IRB.getInt64Ty());
  842                             PointerType::get(IRB.getInt8Ty(), 0), IntptrTy);
 1101           IRB.CreatePointerCast(OriginPtr, PointerType::get(MS.IntptrTy, 0));
 1419         IRB.CreateIntToPtr(ShadowLong, PointerType::get(ShadowTy, 0));
 1433           IRB.CreateIntToPtr(OriginLong, PointerType::get(MS.OriginTy, 0));
 1447         IRB.CreatePointerCast(Addr, PointerType::get(IRB.getInt8Ty(), 0));
 1457     ShadowPtr = IRB.CreatePointerCast(ShadowPtr, PointerType::get(ShadowTy, 0));
 1483     return IRB.CreateIntToPtr(Base, PointerType::get(getShadowTy(A), 0),
 1495     return IRB.CreateIntToPtr(Base, PointerType::get(MS.OriginTy, 0),
 1502                                  PointerType::get(getShadowTy(A), 0),
 3891     return IRB.CreateIntToPtr(Base, PointerType::get(MSV.getShadowTy(Ty), 0),
 3902     return IRB.CreateIntToPtr(Base, PointerType::get(MS.OriginTy, 0),
 3966           PointerType::get(RegSaveAreaPtrTy, 0));
 3983           PointerType::get(OverflowArgAreaPtrTy, 0));
 4055     return IRB.CreateIntToPtr(Base, PointerType::get(MSV.getShadowTy(Ty), 0),
 4107                              PointerType::get(RegSaveAreaPtrTy, 0));
 4224     return IRB.CreateIntToPtr(Base, PointerType::get(MSV.getShadowTy(Ty), 0),
 4491     return IRB.CreateIntToPtr(Base, PointerType::get(MSV.getShadowTy(Ty), 0),
 4544                              PointerType::get(RegSaveAreaPtrTy, 0));

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

  371   IntptrPtrTy = PointerType::getUnqual(IntptrTy);
  374   Int64PtrTy = PointerType::getUnqual(IRB.getInt64Ty());
  375   Int32PtrTy = PointerType::getUnqual(IRB.getInt32Ty());
  376   Int8PtrTy = PointerType::getUnqual(IRB.getInt8Ty());

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

  330     Type *PtrTy = cast<PointerType>(Addr->getType()->getScalarType());
  562   Type *OrigTy = cast<PointerType>(Addr->getType())->getElementType();
  641     Type *OrigTy = cast<PointerType>(Addr->getType())->getElementType();
  723   Type *OrigTy = cast<PointerType>(OrigPtrTy)->getElementType();

lib/Transforms/ObjCARC/ObjCARCContract.cpp

  415   Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
  416   Type *I8XX = PointerType::getUnqual(I8X);
  509       Value *Null = ConstantPointerNull::get(cast<PointerType>(CI->getType()));

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

  804         new StoreInst(UndefValue::get(cast<PointerType>(Ty)->getElementType()),
  825         new StoreInst(UndefValue::get(cast<PointerType>(Ty)->getElementType()),
 1572   Type *ParamTy = PointerType::getUnqual(Type::getInt8Ty(ArgTy->getContext()));

lib/Transforms/Scalar/ConstantHoisting.cpp

  404   PointerType *GVPtrTy = cast<PointerType>(BaseGV->getType());
  404   PointerType *GVPtrTy = cast<PointerType>(BaseGV->getType());
  743       PointerType *Int8PtrTy = Type::getInt8PtrTy(*Ctx,
  744           cast<PointerType>(Ty)->getAddressSpace());

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  580     PointerType *Type = dyn_cast<PointerType>(V->getType());
  580     PointerType *Type = dyn_cast<PointerType>(V->getType());

lib/Transforms/Scalar/LICM.cpp

  989   auto *PtrInt8Ty = PointerType::get(Type::getInt8Ty(LI->getContext()),
  989   auto *PtrInt8Ty = PointerType::get(Type::getInt8Ty(LI->getContext()),

lib/Transforms/Scalar/LoopStrengthReduce.cpp

  875   if (PointerType *PTy = dyn_cast<PointerType>(AccessTy.MemTy))
  875   if (PointerType *PTy = dyn_cast<PointerType>(AccessTy.MemTy))
  876     AccessTy.MemTy = PointerType::get(IntegerType::get(PTy->getContext(), 1),

lib/Transforms/Scalar/MemCpyOptimizer.cpp

  393         cast<PointerType>(StartPtr->getType())->getElementType();
  789       Type *StructTy = cast<PointerType>(A->getType())->getElementType();
 1262   Type *ByValTy = cast<PointerType>(ByValArg->getType())->getElementType();

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

  313   if (auto *PT = dyn_cast<PointerType>(T))
  313   if (auto *PT = dyn_cast<PointerType>(T))
  516         ConstantPointerNull::get(cast<PointerType>(I->getType())), true);
 1780           auto PT = cast<PointerType>(AI->getAllocatedType());
 2403     if (isa<PointerType>(A.getType()))
 2407   if (isa<PointerType>(F.getReturnType()))
 2475         if (isa<PointerType>(Call->getArgOperand(i)->getType()))
 2478       if (isa<PointerType>(Call->getType()))

lib/Transforms/Scalar/SROA.cpp

 1542   PointerType *Ty = cast<PointerType>(Ptr->getType());
 1542   PointerType *Ty = cast<PointerType>(Ptr->getType());
 1597   PointerType *TargetPtrTy = cast<PointerType>(PointerTy);
 1597   PointerType *TargetPtrTy = cast<PointerType>(PointerTy);
 1603   auto AS = cast<PointerType>(Ptr->getType())->getAddressSpace();
 1673   if (cast<PointerType>(Ptr->getType()) != TargetPtrTy) {
 1734       return cast<PointerType>(NewTy)->getPointerAddressSpace() ==
 1735         cast<PointerType>(OldTy)->getPointerAddressSpace();
 3860       auto *PartPtrTy = PartTy->getPointerTo(AS);
 3915         auto *PartPtrTy =
 3993       auto *LoadPartPtrTy = PartTy->getPointerTo(LI->getPointerAddressSpace());
 3994       auto *StorePartPtrTy = PartTy->getPointerTo(SI->getPointerAddressSpace());

lib/Transforms/Scalar/Scalarizer.cpp

   96   PointerType *PtrTy;
  242   PtrTy = dyn_cast<PointerType>(Ty);
  264       Type *NewPtrTy = PointerType::get(ElTy, PtrTy->getAddressSpace());

lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

 1301                    cast<PointerType>(First->getType())->getAddressSpace()),

lib/Transforms/Utils/CallPromotionUtils.cpp

  421             NewTy ? NewTy : cast<PointerType>(FormalTy)->getElementType());

lib/Transforms/Utils/CodeExtractor.cpp

  798       paramTy.push_back(PointerType::getUnqual(output->getType()));
  812     paramTy.push_back(PointerType::getUnqual(StructTy));

lib/Transforms/Utils/Evaluator.cpp

  134   if (!cast<PointerType>(C->getType())->getElementType()->isSingleValueType())
  190     Type *Ty = cast<PointerType>(Ptr->getType())->getElementType();
  376             Type *Ty = cast<PointerType>(P->getType())->getElementType();

lib/Transforms/Utils/FunctionComparator.cpp

  239       PointerType *PTyL = dyn_cast<PointerType>(TyL);
  239       PointerType *PTyL = dyn_cast<PointerType>(TyL);
  240       PointerType *PTyR = dyn_cast<PointerType>(TyR);
  240       PointerType *PTyR = dyn_cast<PointerType>(TyR);
  407   PointerType *PTyL = dyn_cast<PointerType>(TyL);
  407   PointerType *PTyL = dyn_cast<PointerType>(TyL);
  408   PointerType *PTyR = dyn_cast<PointerType>(TyR);
  408   PointerType *PTyR = dyn_cast<PointerType>(TyR);

lib/Transforms/Utils/GlobalStatus.cpp

   74       if (!isa<PointerType>(CE->getType()))

lib/Transforms/Utils/InlineFunction.cpp

 1249   Type *AggTy = cast<PointerType>(Src->getType())->getElementType();
 1266   PointerType *ArgTy = cast<PointerType>(Arg->getType());
 1266   PointerType *ArgTy = cast<PointerType>(Arg->getType());

lib/Transforms/Utils/Local.cpp

 2560       ConstantPointerNull::get(cast<PointerType>(Ptr->getType())), ITy);

lib/Transforms/Utils/LowerMemIntrinsics.cpp

   46   unsigned SrcAS = cast<PointerType>(SrcAddr->getType())->getAddressSpace();
   47   unsigned DstAS = cast<PointerType>(DstAddr->getType())->getAddressSpace();
   60     PointerType *SrcOpType = PointerType::get(LoopOpType, SrcAS);
   60     PointerType *SrcOpType = PointerType::get(LoopOpType, SrcAS);
   61     PointerType *DstOpType = PointerType::get(LoopOpType, DstAS);
   61     PointerType *DstOpType = PointerType::get(LoopOpType, DstAS);
  111       PointerType *SrcPtrType = PointerType::get(OpTy, SrcAS);
  111       PointerType *SrcPtrType = PointerType::get(OpTy, SrcAS);
  120       PointerType *DstPtrType = PointerType::get(OpTy, DstAS);
  120       PointerType *DstPtrType = PointerType::get(OpTy, DstAS);
  154   unsigned SrcAS = cast<PointerType>(SrcAddr->getType())->getAddressSpace();
  155   unsigned DstAS = cast<PointerType>(DstAddr->getType())->getAddressSpace();
  156   PointerType *SrcOpType = PointerType::get(LoopOpType, SrcAS);
  156   PointerType *SrcOpType = PointerType::get(LoopOpType, SrcAS);
  157   PointerType *DstOpType = PointerType::get(LoopOpType, DstAS);
  157   PointerType *DstOpType = PointerType::get(LoopOpType, DstAS);
  231         ResBuilder.CreateBitCast(SrcAddr, PointerType::get(Int8Type, SrcAS));
  233         ResBuilder.CreateBitCast(DstAddr, PointerType::get(Int8Type, DstAS));
  295   Type *EltTy = cast<PointerType>(SrcAddr->getType())->getElementType();
  382   unsigned dstAS = cast<PointerType>(DstAddr->getType())->getAddressSpace();
  384                                   PointerType::get(SetValue->getType(), dstAS));

lib/Transforms/Utils/ModuleUtils.cpp

   31       IRB.getInt32Ty(), PointerType::getUnqual(FnTy), IRB.getInt8PtrTy());

lib/Transforms/Utils/SanitizerStats.cpp

   45   PointerType *Int8PtrTy = B.getInt8PtrTy();
   77   PointerType *Int8PtrTy = Type::getInt8PtrTy(M->getContext());

lib/Transforms/Utils/VNCoercion.cpp

  337   Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
  353       cast<PointerType>(SrcVal->getType())->getAddressSpace() ==
  354           cast<PointerType>(LoadTy)->getAddressSpace()) {
  429         PointerType::get(DestTy, PtrVal->getType()->getPointerAddressSpace());
  513   Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));

lib/Transforms/Utils/ValueMapper.cpp

  487   return getVM()[V] = ConstantPointerNull::get(cast<PointerType>(NewTy));
  966   PointerType *VoidPtrTy;

lib/Transforms/Vectorize/SLPVectorizer.cpp

 3829         PointerType *PtrTy = PointerType::get(VecTy, LI->getPointerAddressSpace());
 3829         PointerType *PtrTy = PointerType::get(VecTy, LI->getPointerAddressSpace());

tools/bugpoint/CrashDebugger.cpp

  281       PointerType *Ty = cast<PointerType>(Alias.getType());
  281       PointerType *Ty = cast<PointerType>(Alias.getType());
  289         PointerType *Ty = cast<PointerType>(I.getType());
  289         PointerType *Ty = cast<PointerType>(I.getType());

tools/bugpoint/Miscompilation.cpp

  896               Resolver, PointerType::getUnqual(F->getFunctionType()),

tools/clang/include/clang/CodeGen/ConstantInitBuilder.h

  203   void addNullPointer(llvm::PointerType *ptrTy) {

tools/clang/lib/CodeGen/Address.h

   43   llvm::PointerType *getType() const {
   44     return llvm::cast<llvm::PointerType>(getPointer()->getType());
  108 template <class U> inline U cast(CodeGen::Address addr) {

tools/clang/lib/CodeGen/CGAtomic.cpp

  978       auto *DestType = T->getPointerElementType()->getPointerTo(DestAS);
 1332     cast<llvm::PointerType>(addr.getPointer()->getType())->getAddressSpace();
 1587       if (isa<llvm::PointerType>(Value->getType()))

tools/clang/lib/CodeGen/CGBlocks.cpp

  190   llvm::PointerType *i8p = nullptr;
 1213   BlockDescriptorType = llvm::PointerType::get(BlockDescriptorType, AddrSpace);
 1287         BlockPtr, llvm::PointerType::get(GenBlockTy, 0), "block.literal");
 1308   llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy);
 1335     auto byrefPointerType = llvm::PointerType::get(byrefInfo.Type, 0);
 2083         auto *ty = cast<llvm::PointerType>(srcValue->getType());
 2083         auto *ty = cast<llvm::PointerType>(srcValue->getType());
 2334       llvm::ConstantPointerNull::get(cast<llvm::PointerType>(value->getType()));
 2749   types.push_back(llvm::PointerType::getUnqual(byrefType));
 2824     cast<llvm::PointerType>(addr.getPointer()->getType())->getElementType());

tools/clang/lib/CodeGen/CGBuiltin.cpp

  152       Address, llvm::PointerType::getUnqual(Val->getType()), "cast");
 3573     llvm::Type *I8PTy = llvm::PointerType::get(
 3721     auto NewArgT = llvm::PointerType::get(Int8Ty,
 3723     auto NewRetT = llvm::PointerType::get(Int8Ty,
 3848       llvm::PointerType *EventPtrTy = EventTy->getPointerTo(
 4179         if (auto *PtrTy = dyn_cast<llvm::PointerType>(PTy)) {
 4179         if (auto *PtrTy = dyn_cast<llvm::PointerType>(PTy)) {
 4205       if (auto *PtrTy = dyn_cast<llvm::PointerType>(RetTy)) {
 4205       if (auto *PtrTy = dyn_cast<llvm::PointerType>(RetTy)) {
 5491     llvm::Type *PTy = llvm::PointerType::getUnqual(VTy->getVectorElementType());
 5496     Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
 5516     Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
 5523     Ty = llvm::PointerType::getUnqual(VTy->getElementType());
 5542     Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
 5670     llvm::Type *PTy = llvm::PointerType::getUnqual(VTy->getVectorElementType());
 5700     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 5728     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 5746     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 6221     Address LdPtr = Builder.CreateBitCast(Tmp,llvm::PointerType::getUnqual(STy));
 6758     Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
 7209     Tmp = Builder.CreateBitCast(Tmp, llvm::PointerType::getUnqual(STy));
 7509     llvm::Type *Int128PTy = llvm::PointerType::get(Int128Ty, 0);
 9125     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
 9132     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
 9138     Ty = llvm::PointerType::getUnqual(VTy->getElementType());
 9149     Ty = llvm::PointerType::getUnqual(VTy->getElementType());
 9163     Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
 9168     llvm::Type *PTy = llvm::PointerType::getUnqual(VTy);
 9174                 llvm::PointerType::getUnqual(Ops[1]->getType()));
 9179     llvm::Type *PTy = llvm::PointerType::getUnqual(VTy);
 9185                 llvm::PointerType::getUnqual(Ops[1]->getType()));
 9190     llvm::Type *PTy = llvm::PointerType::getUnqual(VTy);
 9196                 llvm::PointerType::getUnqual(Ops[1]->getType()));
 9202       llvm::PointerType::getUnqual(VTy->getElementType());
 9208                 llvm::PointerType::getUnqual(Ops[1]->getType()));
 9214       llvm::PointerType::getUnqual(VTy->getElementType());
 9220                 llvm::PointerType::getUnqual(Ops[1]->getType()));
 9226       llvm::PointerType::getUnqual(VTy->getElementType());
 9232                 llvm::PointerType::getUnqual(Ops[1]->getType()));
 9245     Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
 9260     Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
 9276     Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
 9333     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 9352     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 9370     Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
 9515                                llvm::PointerType::getUnqual(Ops[1]->getType()));
 9527                                llvm::PointerType::getUnqual(Ops[1]->getType()));
 9542                                          llvm::PointerType::getUnqual(PtrTy));
 9573                                          llvm::PointerType::getUnqual(PtrTy));
11351         Ptr, llvm::PointerType::getUnqual(Src->getType()), "cast");
12330         Builder.CreateIntToPtr(Ops[0], llvm::PointerType::get(IntTy, 257));
12342         Builder.CreateIntToPtr(Ops[0], llvm::PointerType::get(IntTy, 256));

tools/clang/lib/CodeGen/CGCUDANV.cpp

   38   llvm::PointerType *CharPtrTy, *VoidPtrTy, *VoidPtrPtrTy;
  166   CharPtrTy = llvm::PointerType::getUnqual(Types.ConvertType(Ctx.CharTy));
  167   VoidPtrTy = cast<llvm::PointerType>(Types.ConvertType(Ctx.VoidPtrTy));

tools/clang/lib/CodeGen/CGCXX.cpp

  135   llvm::PointerType *AliasType = AliasValueType->getPointerTo();

tools/clang/lib/CodeGen/CGCall.cpp

 1169   if (isa<llvm::PointerType>(Val->getType())) {
 1171     if (isa<llvm::PointerType>(Ty))
 1179   if (isa<llvm::PointerType>(DestIntTy))
 1203   if (isa<llvm::PointerType>(Ty))
 1236   if ((isa<llvm::IntegerType>(Ty) || isa<llvm::PointerType>(Ty)) &&
 1237       (isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy))) {
 1310   if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) &&
 1311       (isa<llvm::IntegerType>(DstTy) || isa<llvm::PointerType>(DstTy))) {
 1564       resultType = llvm::PointerType::get(ty, addressSpace);
 1589         llvm::PointerType::get(Ty, AddressSpace);
 3083       llvm::ConstantPointerNull::get(cast<llvm::PointerType>(ptr->getType()));
 3228   llvm::PointerType *destType =
 3229     cast<llvm::PointerType>(CGF.ConvertType(CRE->getType()));
 3253         cast<llvm::PointerType>(destType->getElementType()));
 4017           auto *T = V->getType()->getPointerElementType()->getPointerTo(
 4212             cast<llvm::PointerType>(LastParamTy)->getElementType());

tools/clang/lib/CodeGen/CGClass.cpp

  980       llvm::PointerType *DPT = DestPtr.getType();
  985       llvm::PointerType *SPT = SrcPtr.getType();
 2832       cast<llvm::PointerType>(VTable->getType())->getElementType());

tools/clang/lib/CodeGen/CGDecl.cpp

  781     auto ty = cast<llvm::PointerType>(tempLV.getAddress().getElementType());
 1133   llvm::Type *BP = llvm::PointerType::getInt8PtrTy(CGM.getLLVMContext(),
 2390       auto *T = V->getType()->getPointerElementType()->getPointerTo(DestAS);

tools/clang/lib/CodeGen/CGDeclCXX.cpp

  198     llvm::PointerType *PTy = llvm::PointerType::get(LTy, ExpectedAddrSpace);
  198     llvm::PointerType *PTy = llvm::PointerType::get(LTy, ExpectedAddrSpace);

tools/clang/lib/CodeGen/CGException.cpp

  248   llvm::PointerType* Int8PtrTy = llvm::PointerType::get(
  248   llvm::PointerType* Int8PtrTy = llvm::PointerType::get(

tools/clang/lib/CodeGen/CGExpr.cpp

   52       cast<llvm::PointerType>(value->getType())->getAddressSpace();
   54   llvm::PointerType *destType = Int8PtrTy;
  811       llvm::Type *VPtrTy = llvm::PointerType::get(IntPtrTy, 0);
 1179   llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
 2288   unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace();
 2545         auto *PTy = llvm::PointerType::get(
 2545         auto *PTy = llvm::PointerType::get(
 4807           CalleePtr, llvm::PointerType::getUnqual(PrefixStructTy));

tools/clang/lib/CodeGen/CGExprConstant.cpp

 1718 llvm::Constant *CodeGenModule::getNullPointer(llvm::PointerType *T, QualType QT) {
 1835   if (isa<llvm::PointerType>(destTy))
 1846   auto destPtrTy = cast<llvm::PointerType>(destTy);
 2297         cast<llvm::PointerType>(getTypes().ConvertTypeForMem(T)), T);

tools/clang/lib/CodeGen/CGExprScalar.cpp

  393     Value *Zero = CGF.CGM.getNullPointer(cast<llvm::PointerType>(V->getType()), QT);
 1259   if (auto DstPT = dyn_cast<llvm::PointerType>(DstTy)) {
 1261     if (isa<llvm::PointerType>(SrcTy))
 1275   if (isa<llvm::PointerType>(SrcTy)) {
 2046       return CGF.CGM.getNullPointer(cast<llvm::PointerType>(
 2107     return CGF.CGM.getNullPointer(cast<llvm::PointerType>(ConvertType(DestTy)),
 3179   auto PtrTy = cast<llvm::PointerType>(pointer->getType());

tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp

  230   return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(Ty));
  547       llvm::PointerType *PtrTy = this->CGF->ConvertType(RT)->getPointerTo();
  557       llvm::PointerType *Ty = this->CGF->ConvertType(FT)->getPointerTo();

tools/clang/lib/CodeGen/CGObjC.cpp

   41   return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(type));

tools/clang/lib/CodeGen/CGObjCGNU.cpp

   74             Tys *... Types) {
  114   llvm::PointerType *PtrToObjCSuperTy;
  118   llvm::PointerType *SelectorTy;
  124   llvm::PointerType *PtrToInt8Ty;
  128   llvm::PointerType *ProtocolPtrTy;
  134   llvm::PointerType *IMPTy;
  139   llvm::PointerType *IdTy;
  142   llvm::PointerType *PtrToIdTy;
  151   llvm::PointerType *PtrTy;
  164   llvm::PointerType *PtrToIntTy;
  812       SlotTy = llvm::PointerType::getUnqual(SlotStructTy);
 2141   PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
 2142   ProtocolPtrTy = llvm::PointerType::getUnqual(
 2153     SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy));
 2156   PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
 2170     IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
 2174   PtrToIdTy = llvm::PointerType::getUnqual(IdTy);
 2202   PtrToObjCSuperTy = llvm::PointerType::getUnqual(ObjCSuperTy);
 2232   IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs,
 2531                                             llvm::PointerType::getUnqual(IdTy));
 2573                                           llvm::PointerType::getUnqual(CastTy));
 2663   IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
 3038   return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
 3620     selStructPtrTy = llvm::PointerType::getUnqual(selStructTy);

tools/clang/lib/CodeGen/CGObjCMac.cpp

  173   llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy;
  177   llvm::PointerType *ObjectPtrTy;
  180   llvm::PointerType *PtrObjectPtrTy;
  183   llvm::PointerType *SelectorPtrTy;
  198       ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
  212   llvm::PointerType *SuperPtrTy;
  222   llvm::PointerType *PropertyListPtrTy;
  230   llvm::PointerType *CachePtrTy;
  500   llvm::PointerType *SymtabPtrTy;
  507   llvm::PointerType *ProtocolPtrTy;
  513   llvm::PointerType *ProtocolExtensionPtrTy;
  522   llvm::PointerType *MethodDescriptionListPtrTy;
  526   llvm::PointerType *ProtocolListPtrTy;
  532   llvm::PointerType *ClassPtrTy;
  536   llvm::PointerType *ClassExtensionPtrTy;
  542   llvm::PointerType *IvarListPtrTy;
  546   llvm::PointerType *MethodListPtrTy;
  606   llvm::PointerType *MethodListnfABIPtrTy;
  612   llvm::PointerType *ProtocolnfABIPtrTy;
  618   llvm::PointerType *ProtocolListnfABIPtrTy;
  624   llvm::PointerType *ClassnfABIPtrTy;
  633   llvm::PointerType *IvarListnfABIPtrTy;
  639   llvm::PointerType *ImpnfABITy;
  668   llvm::PointerType *SuperMessageRefPtrTy;
 4805   if (!isa<llvm::PointerType>(SrcTy)) {
 4826   if (!isa<llvm::PointerType>(SrcTy)) {
 4852   if (!isa<llvm::PointerType>(SrcTy)) {
 4871   if (!isa<llvm::PointerType>(SrcTy)) {
 5631     cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
 5633     llvm::PointerType::getUnqual(ObjectPtrTy);
 5635     cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
 5665   SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
 5681   PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
 5693   CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
 5715     llvm::PointerType::getUnqual(MethodDescriptionListTy);
 5733   ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
 5742   ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
 5753                       llvm::PointerType::getUnqual(ProtocolListTy),
 5757   ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
 5759   ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
 5774   IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
 5779   MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
 5784   ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
 5802   ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
 5803                    llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
 5807   ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
 5836   SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
 5870   MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
 5894       llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
 5900   ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
 5910   ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
 5920       "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
 5932   IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
 5968   ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
 5969                         llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy,
 5970                         llvm::PointerType::getUnqual(ImpnfABITy),
 5971                         llvm::PointerType::getUnqual(ClassRonfABITy));
 5974   ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
 6019   MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
 6030   SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
 6039                                       llvm::PointerType::getUnqual(Int8PtrTy),
 6041   EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
 7517   if (!isa<llvm::PointerType>(SrcTy)) {
 7537   if (!isa<llvm::PointerType>(SrcTy)) {
 7583   if (!isa<llvm::PointerType>(SrcTy)) {
 7604   if (!isa<llvm::PointerType>(SrcTy)) {

tools/clang/lib/CodeGen/CGObjCRuntime.cpp

   69     V = CGF.Builder.CreateBitCast(V, llvm::PointerType::getUnqual(LTy));
  368     llvm::PointerType *signatureType =
  382   llvm::PointerType *signatureType =

tools/clang/lib/CodeGen/CGObjCRuntime.h

  290     llvm::PointerType *MessengerType;
  293                     llvm::PointerType *messengerType)

tools/clang/lib/CodeGen/CGOpenCLRuntime.cpp

   53     return llvm::PointerType::get(
   56     return llvm::PointerType::get(
   59     return llvm::PointerType::get(
   62     return llvm::PointerType::get(
   82     PipeTy = llvm::PointerType::get(llvm::StructType::create(
   89 llvm::PointerType *CGOpenCLRuntime::getSamplerType(const Type *T) {
   91     SamplerTy = llvm::PointerType::get(llvm::StructType::create(
  118 llvm::PointerType *CGOpenCLRuntime::getGenericVoidPointerType() {

tools/clang/lib/CodeGen/CGOpenCLRuntime.h

   40   llvm::PointerType *SamplerTy;
   69   llvm::PointerType *getSamplerType(const Type *T);
   80   llvm::PointerType *getGenericVoidPointerType();

tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp

 1010       cast<llvm::PointerType>(SharedAddresses[N].first.getPointer()->getType())
 1768     llvm::Type *MicroParams[] = {llvm::PointerType::getUnqual(CGM.Int32Ty),
 1769                                  llvm::PointerType::getUnqual(CGM.Int32Ty)};
 1772   return llvm::PointerType::getUnqual(Kmpc_MicroTy);
 1828         llvm::PointerType::getUnqual(KmpCriticalNameTy)};
 1838                                 llvm::PointerType::getUnqual(KmpCriticalNameTy),
 1849     auto *KmpcCtorTy =
 1854     auto *KmpcCopyCtorTy =
 1859     auto *KmpcDtorTy =
 1874         llvm::PointerType::getUnqual(KmpCriticalNameTy)};
 2046         llvm::PointerType::getUnqual(KmpCriticalNameTy)};
 2063         llvm::PointerType::getUnqual(KmpCriticalNameTy)};
 2074         llvm::PointerType::getUnqual(KmpCriticalNameTy)};
 2085         llvm::PointerType::getUnqual(KmpCriticalNameTy)};
 2564   auto *PtrTy = llvm::PointerType::getUnqual(ITy);
 2564   auto *PtrTy = llvm::PointerType::getUnqual(ITy);
 2569     llvm::PointerType::getUnqual(CGM.Int32Ty), // p_lastiter
 2629   auto *PtrTy = llvm::PointerType::getUnqual(ITy);
 2629   auto *PtrTy = llvm::PointerType::getUnqual(ITy);
 2633     llvm::PointerType::getUnqual(CGM.Int32Ty), // p_lastiter
 2835     auto *CopyCtorTy = llvm::FunctionType::get(CGM.VoidPtrTy, CopyCtorTyArgs,
 2843       auto *CtorTy = llvm::FunctionType::get(CGM.VoidPtrTy, CGM.VoidPtrTy,
 2849       auto *DtorTy = llvm::FunctionType::get(CGM.VoidTy, CGM.VoidPtrTy,
 5050         cast<llvm::PointerType>(TaskPrivatesMapTy));

tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp

 2134     llvm::PointerType *GlobalRecPtrTy =
 2294       llvm::PointerType *SecGlobalRecPtrTy =
 2720           cast<llvm::PointerType>(getIdentTyPointerTy())),

tools/clang/lib/CodeGen/CGStmt.cpp

 1831         Ty = llvm::PointerType::getUnqual(Ty);
 2174         if (isa<llvm::PointerType>(Arg->getType()))
 2179         else if (isa<llvm::PointerType>(OutputTy))

tools/clang/lib/CodeGen/CodeGenModule.cpp

 1155   llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
 2405                                     llvm::PointerType::getUnqual(DeclTy),
 2928         llvm::PointerType::get(DeclTy,
 3050         llvm::PointerType::get(
 3262   llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
 3408                                      llvm::PointerType *Ty,
 3671   llvm::PointerType *PTy =
 3672     llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
 3685           ? llvm::PointerType::get(
 3687           : llvm::PointerType::getUnqual(Ty);
 4466                                     llvm::PointerType::getUnqual(DeclTy),

tools/clang/lib/CodeGen/CodeGenModule.h

 1367   llvm::Constant *getNullPointer(llvm::PointerType *T, QualType QT);
 1382                                         llvm::PointerType *PTy,

tools/clang/lib/CodeGen/CodeGenPGO.cpp

  900   auto *I8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());

tools/clang/lib/CodeGen/CodeGenTypeCache.h

   53     llvm::PointerType *VoidPtrTy;
   54     llvm::PointerType *Int8PtrTy;
   59     llvm::PointerType *VoidPtrPtrTy;
   60     llvm::PointerType *Int8PtrPtrTy;
   65     llvm::PointerType *AllocaVoidPtrTy;
   66     llvm::PointerType *AllocaInt8PtrTy;

tools/clang/lib/CodeGen/CodeGenTypes.cpp

  554     ResultType = llvm::PointerType::get(PointeeType, AS);
  564     ResultType = llvm::PointerType::get(PointeeType, AS);
  658     ResultType = llvm::PointerType::get(PointeeType, AS);

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

 2119                                               llvm::PointerType *GuardPtrTy) {
 2132                                               llvm::PointerType *GuardPtrTy) {
 2144                                             llvm::PointerType *GuardPtrTy) {
 2209   llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
 4141           cast<llvm::PointerType>(LLVMCatchTy)->getElementType();

tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp

 1499       unsigned AS = cast<llvm::PointerType>(This->getType())->getAddressSpace();

tools/clang/lib/CodeGen/PatternInit.cpp

   45     auto *PtrTy = cast<llvm::PointerType>(
   45     auto *PtrTy = cast<llvm::PointerType>(

tools/clang/lib/CodeGen/TargetInfo.cpp

  433     llvm::PointerType *T, QualType QT) const {
  631         llvm::PointerType::getUnqual(CGF.ConvertTypeForMem(Ty));
 3188     if ((isa<llvm::PointerType>(IRType) && Has64BitPointers) ||
 3200         (isa<llvm::PointerType>(IRType) && !Has64BitPointers)) {
 3201       unsigned BitWidth = isa<llvm::PointerType>(IRType) ? 32 :
 3701                               llvm::PointerType::getUnqual(LTy));
 3804     llvm::Type *PTyLo = llvm::PointerType::getUnqual(TyLo);
 3805     llvm::Type *PTyHi = llvm::PointerType::getUnqual(TyHi);
 5307     BaseTy = llvm::PointerType::getUnqual(BaseTy);
 5424     MemTy = llvm::PointerType::getUnqual(MemTy);
 6698     DirectTy = llvm::PointerType::getUnqual(DirectTy);
 7898       llvm::PointerType *T, QualType QT) const override;
 8040     const CodeGen::CodeGenModule &CGM, llvm::PointerType *PT,
 8046   auto NPT = llvm::PointerType::get(PT->getElementType(),
 8362   llvm::Type *ArgPtrTy = llvm::PointerType::getUnqual(ArgTy);
 8725   llvm::Type *ArgPtrTy = llvm::PointerType::getUnqual(ArgTy);

tools/clang/lib/CodeGen/TargetInfo.h

  237       llvm::PointerType *T, QualType QT) const;

tools/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp

   98   PointerType *getEntryPtrTy() { return PointerType::getUnqual(getEntryTy()); }
   98   PointerType *getEntryPtrTy() { return PointerType::getUnqual(getEntryTy()); }
  114   PointerType *getDeviceImagePtrTy() {
  115     return PointerType::getUnqual(getDeviceImageTy());
  132   PointerType *getBinDescPtrTy() {
  133     return PointerType::getUnqual(getBinDescTy());

tools/lldb/source/Expression/IRInterpreter.cpp

 1287       PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty);
 1287       PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty);
 1379       PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty);
 1379       PointerType *pointer_ptr_ty = dyn_cast<PointerType>(pointer_ty);

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

  249     PointerType *fun_ptr_ty = PointerType::getUnqual(fun_ty);
  249     PointerType *fun_ptr_ty = PointerType::getUnqual(fun_ty);
  273     PointerType *fun_ptr_ty = PointerType::getUnqual(fun_ty);
  273     PointerType *fun_ptr_ty = PointerType::getUnqual(fun_ty);
  279   PointerType *GetI8PtrTy() {
  306   PointerType *m_i8ptr_ty;

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

  480     PointerType *CFSCWB_ptr_ty = PointerType::getUnqual(CFSCWB_ty);
  480     PointerType *CFSCWB_ptr_ty = PointerType::getUnqual(CFSCWB_ty);
  864     PointerType *srN_ptr_ty = PointerType::getUnqual(srN_type);
  864     PointerType *srN_ptr_ty = PointerType::getUnqual(srN_type);
 1015     PointerType *ogC_ptr_ty = PointerType::getUnqual(ogC_type);
 1015     PointerType *ogC_ptr_ty = PointerType::getUnqual(ogC_type);
 1245       value_type = PointerType::get(global_variable->getType(), 0);

tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp

  108   llvm::PointerType *return_type_ptr_type =
  109       llvm::PointerType::getUnqual(orig->getReturnType());
  178     llvm::PointerType *new_func_ptr_type =
  179         llvm::PointerType::get(new_func_type, 0);

tools/llvm-exegesis/lib/Assembler.cpp

   77   Type *const MemParamType = PointerType::get(

tools/llvm-stress/llvm-stress.cpp

  285     return PointerType::get(Ty, 0);
  358     PointerType *Tp = cast<PointerType>(Ptr->getType());
  358     PointerType *Tp = cast<PointerType>(Ptr->getType());
  557         DestTy = PointerType::get(DestTy, 0);

tools/polly/lib/Analysis/ScopBuilder.cpp

 1329   PointerType *PTy = dyn_cast<PointerType>(V->getType());
 1329   PointerType *PTy = dyn_cast<PointerType>(V->getType());

tools/polly/lib/Analysis/ScopDetection.cpp

 1081         SE.getEffectiveSCEVType(PointerType::getInt8PtrTy(SE.getContext()));

tools/polly/lib/CodeGen/BlockGenerators.cpp

  281     OldPtrTy = PointerType::get(OldPtrTy->getElementType(),
 1040   PointerType *PointerTy = dyn_cast<PointerType>(Val->getType());
 1040   PointerType *PointerTy = dyn_cast<PointerType>(Val->getType());
 1046   return PointerType::getUnqual(VectorType);
 1108       dyn_cast<PointerType>(Pointer->getType())->getElementType(), VectorWidth);

tools/polly/lib/CodeGen/IslExprBuilder.cpp

  273   auto PointerTy = PointerType::get(SAI->getElementType(),

tools/polly/lib/CodeGen/LoopGeneratorsGOMP.cpp

   32     Type *Params[] = {PointerType::getUnqual(FunctionType::get(

tools/polly/lib/CodeGen/RuntimeDebugBuilder.cpp

   49         PointerType::get(Builder.getIntNTy(DstBits), Dst),
   50         PointerType::get(Builder.getIntNTy(SrcBits), Src), false);
  111   if (isa<PointerType>(Ty))
  134     } else if (isa<PointerType>(Ty)) {
  209     } else if (auto PtTy = dyn_cast<PointerType>(Ty)) {

tools/polly/lib/Support/ScopHelper.cpp

  675       if (auto *PtrTy = dyn_cast<PointerType>(Ty)) {
  675       if (auto *PtrTy = dyn_cast<PointerType>(Ty)) {

unittests/Analysis/ScalarEvolutionTest.cpp

  149   auto *I8PtrTy = Type::getInt8PtrTy(Context);
  151   auto *I32PtrTy = Type::getInt32PtrTy(Context);
  403   PointerType *IntPtrPtrTy = IntPtrTy->getPointerTo();

unittests/Analysis/TBAATest.cpp

   39   auto *PtrType = Type::getInt32PtrTy(C);

unittests/AsmParser/AsmParserTest.cpp

  254   PointerType *PT = cast<PointerType>(Ty);
  254   PointerType *PT = cast<PointerType>(Ty);
  264   PT = cast<PointerType>(Ty);
  268   PT = cast<PointerType>(Ty);
  388   PointerType *PT = cast<PointerType>(Ty);
  388   PointerType *PT = cast<PointerType>(Ty);
  399   PT = cast<PointerType>(Ty);
  403   PT = cast<PointerType>(Ty);

unittests/CodeGen/LowLevelTypeTest.cpp

  200       Type *IRTy = PointerType::get(IntegerType::get(C, 8), AS);
  203         VectorType::get(PointerType::get(IntegerType::get(C, 8), AS), NumElts);

unittests/FuzzMutate/OperationsTest.cpp

   98       ConstantPointerNull::get(PointerType::get(i32->getType(), 0));

unittests/IR/ConstantsTest.cpp

  203                                          PointerType::getUnqual(Int32Ty));
  205                                          PointerType::getUnqual(Int32Ty));
  312       M->getOrInsertGlobal("dummy", PointerType::getUnqual(Int32Ty));
  314       PointerType::getUnqual(Int32Ty), Global, One);
  377   Type *PtrTy = PointerType::get(IntTy, 0);
  404   Type *I16PTy = PointerType::get(I16Ty, 0);
  473   auto *PtrTy = PointerType::get(i32, 0);
  473   auto *PtrTy = PointerType::get(i32, 0);

unittests/IR/InstructionsTest.cpp

  201   Type *Int32PtrTy = PointerType::get(Int32Ty, 0);
  202   Type *Int64PtrTy = PointerType::get(Int64Ty, 0);
  204   Type *Int32PtrAS1Ty = PointerType::get(Int32Ty, 1);
  205   Type *Int64PtrAS1Ty = PointerType::get(Int64Ty, 1);
  311   PointerType *Ptri8Ty = PointerType::get(I8Ty, 0);
  311   PointerType *Ptri8Ty = PointerType::get(I8Ty, 0);
  312   PointerType *Ptri32Ty = PointerType::get(I32Ty, 0);
  312   PointerType *Ptri32Ty = PointerType::get(I32Ty, 0);
  668   Value *V = Builder.CreateGEP(ArrTy, UndefValue::get(PointerType::getUnqual(ArrTy)),

unittests/Linker/LinkModulesTest.cpp

  161   StructType *STy = StructType::create(Ctx, PointerType::get(FTy, 0));

unittests/Transforms/Utils/ValueMapperTest.cpp

   68   auto *PtrTy = Type::getInt8Ty(Context)->getPointerTo();

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };

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

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