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

Declarations

include/llvm/IR/Type.h

  461   PointerType *getPointerTo(unsigned AddrSpace = 0) const;

References

examples/BrainF/BrainFDriver.cpp

   78        Type::getInt8Ty(mod->getContext())->getPointerTo()->getPointerTo()},
   78        Type::getInt8Ty(mod->getContext())->getPointerTo()->getPointerTo()},

lib/Analysis/ConstantFolding.cpp

  526     C = FoldBitCast(C, MapTy->getPointerTo(AS), DL);
  812     NewPtrTy = ElemTy->getPointerTo(OldPtrTy->getAddressSpace());

lib/Analysis/InstructionSimplify.cpp

 4882   Type *Int32PtrTy = Int32Ty->getPointerTo();

lib/AsmParser/LLParser.cpp

 1383     Type *TyInProgAS = cast<PointerType>(Ty)->getElementType()->getPointerTo(

lib/CodeGen/AtomicExpandPass.cpp

  508     Addr = Builder.CreateBitCast(Addr, IntTy->getPointerTo(AS));
  658       Ret.WordType->getPointerTo(Addr->getType()->getPointerAddressSpace());

lib/CodeGen/CodeGenPrepare.cpp

 6740         SplitStoreType->getPointerTo(SI.getPointerAddressSpace()));

lib/CodeGen/ExpandMemCmp.cpp

  268         ByteType, Builder.CreateBitCast(Source, ByteType->getPointerTo()),
  271   return Builder.CreateBitCast(Source, LoadSizeType->getPointerTo());
  572     Source1 = Builder.CreateBitCast(Source1, LoadSizeType->getPointerTo());
  574     Source2 = Builder.CreateBitCast(Source2, LoadSizeType->getPointerTo());

lib/CodeGen/GlobalISel/IRTranslator.cpp

  538   Type *PtrIRTy = SValue.getType()->getPointerTo();

lib/CodeGen/InterleavedLoadCombinePass.cpp

 1218                                       ILTy->getPointerTo(),

lib/CodeGen/PreISelIntrinsicLowering.cpp

   34   Type *Int32PtrTy = Int32Ty->getPointerTo();

lib/CodeGen/SafeStack.cpp

  779         "__safestack_pointer_address", StackPtrTy->getPointerTo(0));

lib/CodeGen/ScalarizeMaskedMemIntrin.cpp

  156       EltTy->getPointerTo(Ptr->getType()->getPointerAddressSpace());
  292       EltTy->getPointerTo(Ptr->getType()->getPointerAddressSpace());

lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

 2220   Entry.Ty = RetTy->getPointerTo();
 2313   Entry.Ty = RetTy->getPointerTo();
 2321   Entry.Ty = RetTy->getPointerTo();

lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

 3449   Entry.Ty = PtrTy->getPointerTo();

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 1792                     F->getReturnType()->getPointerTo(
 9294     Type *PtrRetTy = OrigRetTy->getPointerTo(DL.getAllocaAddrSpace());
 9590                     F.getReturnType()->getPointerTo(
 9756                     F.getReturnType()->getPointerTo(

lib/CodeGen/ShadowStackGCLowering.cpp

  316       AtEntry.CreateLoad(StackEntryTy->getPointerTo(), Head, "gc_currhead");
  357     Value *SavedHead = AtExit->CreateLoad(StackEntryTy->getPointerTo(),

lib/CodeGen/TargetLoweringBase.cpp

 1718                                              StackPtrTy->getPointerTo(0));

lib/ExecutionEngine/ExecutionEngine.cpp

  436   Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo();

lib/ExecutionEngine/Orc/Speculation.cpp

   74         {SpeculatorVTy->getPointerTo(), Type::getInt64Ty(MContext)}, false);

lib/IR/AutoUpgrade.cpp

 2239                                           EltTy->getPointerTo());

lib/IR/Constants.cpp

 1941   Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo(0));
 2025   Type *ReqTy = DestTy->getPointerTo(AS);

lib/IR/Type.cpp

  189   return getHalfTy(C)->getPointerTo(AS);
  193   return getFloatTy(C)->getPointerTo(AS);
  197   return getDoubleTy(C)->getPointerTo(AS);
  201   return getX86_FP80Ty(C)->getPointerTo(AS);
  205   return getFP128Ty(C)->getPointerTo(AS);
  209   return getPPC_FP128Ty(C)->getPointerTo(AS);
  213   return getX86_MMXTy(C)->getPointerTo(AS);
  217   return getIntNTy(C, N)->getPointerTo(AS);
  221   return getInt1Ty(C)->getPointerTo(AS);
  225   return getInt8Ty(C)->getPointerTo(AS);
  229   return getInt16Ty(C)->getPointerTo(AS);
  233   return getInt32Ty(C)->getPointerTo(AS);
  237   return getInt64Ty(C)->getPointerTo(AS);

lib/IR/Verifier.cpp

  647           getPointerTo(DL.getProgramAddressSpace());

lib/Linker/IRMover.cpp

  859   PointerType *VoidPtrTy = Type::getInt8Ty(SrcGV->getContext())->getPointerTo();

lib/Target/AArch64/AArch64ISelLowering.cpp

 8826         BaseAddr, VecTy->getVectorElementType()->getPointerTo(
 8830   Type *PtrTy = VecTy->getPointerTo(LI->getPointerAddressSpace());
 8966         BaseAddr, SubVecTy->getVectorElementType()->getPointerTo(
 8972   Type *PtrTy = SubVecTy->getPointerTo(SI->getPointerAddressSpace());
12267       IRB.getInt8PtrTy()->getPointerTo(0));

lib/Target/AMDGPU/AMDGPULibFunc.cpp

  896     T = StructType::create(C,"ocl_image")->getPointerTo(); break;
  898     T = StructType::create(C,"ocl_sampler")->getPointerTo(); break;
  900     T = StructType::create(C,"ocl_event")->getPointerTo(); break;
  908     T = useAddrSpace ? T->getPointerTo((P.PtrKind & AMDGPULibFunc::ADDR_SPACE)
  910                      : T->getPointerTo();

lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp

  160     ArgPtr = Builder.CreateBitCast(ArgPtr, AdjustedArgTy->getPointerTo(AS),

lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

  428       Type *VecPtrTy = VectorTy->getPointerTo(AMDGPUAS::PRIVATE_ADDRESS);
  444       Type *VecPtrTy = VectorTy->getPointerTo(AMDGPUAS::PRIVATE_ADDRESS);

lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp

  460     Type *PtrTy = Val->getType()->getPointerTo(ArgType->getAddressSpace());

lib/Target/ARM/ARMISelLowering.cpp

 8755     Entry.Ty = RetTy->getPointerTo();
16781         BaseAddr, VecTy->getVectorElementType()->getPointerTo(
16927         BaseAddr, SubVecTy->getVectorElementType()->getPointerTo(

lib/Target/ARM/ARMParallelDSP.cpp

  773                                     LoadTy->getPointerTo(AddrSpace));

lib/Target/Hexagon/HexagonISelLowering.cpp

 3252     = Builder.getIntNTy(SZ)->getPointerTo(PT->getAddressSpace());
 3276   Addr = Builder.CreateBitCast(Addr, CastTy->getPointerTo(AS));

lib/Target/X86/X86ISelLowering.cpp

 2295       Type::getInt8PtrTy(IRB.getContext())->getPointerTo(AddressSpace));

lib/Target/X86/X86InterleavedAccess.cpp

  205     VecBasePtrTy = VecBaseTy->getPointerTo(LI->getPointerAddressSpace());
  210     VecBasePtrTy = VecBaseTy->getPointerTo(LI->getPointerAddressSpace());

lib/Target/X86/X86WinEHState.cpp

  219       EHLinkRegistrationTy->getPointerTo(0), // EHRegistrationNode *Next
  412       Builder.CreateBitCast(PersonalityFn, TargetFuncTy->getPointerTo());
  435       Constant::getNullValue(LinkTy->getPointerTo()->getPointerTo(257));
  435       Constant::getNullValue(LinkTy->getPointerTo()->getPointerTo(257));
  436   Value *Next = Builder.CreateLoad(LinkTy->getPointerTo(), FSZero);
  451   Value *Next = Builder.CreateLoad(LinkTy->getPointerTo(),
  454       Constant::getNullValue(LinkTy->getPointerTo()->getPointerTo(257));
  454       Constant::getNullValue(LinkTy->getPointerTo()->getPointerTo(257));

lib/Transforms/Coroutines/CoroCleanup.cpp

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

lib/Transforms/Coroutines/CoroEarly.cpp

   41                              ->getPointerTo()) {}
   97   PointerType *FramePtrTy = FrameTy->getPointerTo();
  115     auto *FramePtrTy = FrameTy->getPointerTo();
  118     auto *FnPtrTy = FnTy->getPointerTo();

lib/Transforms/Coroutines/CoroFrame.cpp

  408     auto *FramePtrTy = FrameTy->getPointerTo();
  411     auto *FnPtrTy = FnTy->getPointerTo();
  591   PointerType *FramePtrTy = FrameTy->getPointerTo();
 1167   auto Fn = ConstantPointerNull::get(FnTy->getPointerTo());
 1181   auto FnTy = FunctionType::get(V->getType()->getPointerTo(),
 1183   auto Fn = ConstantPointerNull::get(FnTy->getPointerTo());

lib/Transforms/Coroutines/CoroSplit.cpp

  622     auto FramePtrTy = Shape.FrameTy->getPointerTo();
  630       Builder.CreateBitCast(NewStorage, FramePtrTy->getPointerTo());
 1220                                       RawFramePtr->getType()->getPointerTo());

lib/Transforms/Coroutines/Coroutines.cpp

  118       new BitCastInst(Call, ResumeFnType->getPointerTo(), "", InsertPt);

lib/Transforms/IPO/LowerTypeTests.cpp

 1497       ConstantExpr::getPointerCast(JumpTableFn, JumpTableType->getPointerTo(0));

lib/Transforms/IPO/WholeProgramDevirt.cpp

 1381       Value *ValAddr = B.CreateBitCast(Addr, RetType->getPointerTo());

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

  463     NewPtr = IC.Builder.CreateBitCast(Ptr, NewTy->getPointerTo(AS));
  485       V, IC.Builder.CreateBitCast(Ptr, V->getType()->getPointerTo(AS)),

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 2836         Poison, IRB.CreateIntToPtr(Ptr, Poison->getType()->getPointerTo()), 1);

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  499   ArgTypes.push_back(T->getPointerTo());
  522       ArgTypes.push_back(getTrampolineFunctionType(FT)->getPointerTo());

lib/Transforms/Instrumentation/GCOVProfiling.cpp

  977       {Builder.getInt32Ty(), Builder.getInt64Ty()->getPointerTo()});
  980                           EmitFunctionCallArgsTy->getPointerTo(),
  981                           EmitArcsCallArgsTy->getPointerTo()});

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

  913         Ty->getPointerTo(0));
  991         IRB.CreateIntToPtr(ThreadLongMaybeUntagged, IntptrTy->getPointerTo(0));

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 2880                     IRB.CreatePointerCast(ShadowPtr, Ty->getPointerTo()));

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

  239     Type *PtrTy = Ty->getPointerTo();
  638     Type *PtrTy = Ty->getPointerTo();
  653     Type *PtrTy = Ty->getPointerTo();
  670     Type *PtrTy = Ty->getPointerTo();
  684     Type *PtrTy = Ty->getPointerTo();

lib/Transforms/Scalar/GVN.cpp

 1410                     Constant::getNullValue(Int8Ty->getPointerTo()),

lib/Transforms/Scalar/InferAddressSpaces.cpp

  420       Operand->getType()->getPointerElementType()->getPointerTo(NewAddrSpace);
  446       I->getType()->getPointerElementType()->getPointerTo(NewAddrSpace);
  507     CE->getType()->getPointerElementType()->getPointerTo(NewAddrSpace);

lib/Transforms/Scalar/NewGVN.cpp

 3702                 Constant::getNullValue(Int8Ty->getPointerTo()),

lib/Transforms/Scalar/SROA.cpp

 1604   PointerTy = TargetTy->getPointerTo(AS);
 2553       Type *LTy = TargetTy->getPointerTo(AS);
 2582           LI.getType(), UndefValue::get(LI.getType()->getPointerTo(AS)));
 2704       Value *NewPtr = getNewAllocaSlicePtr(IRB, V->getType()->getPointerTo(AS));
 3018     OtherPtrTy = OtherTy->getPointerTo(OtherAS);
 3860       auto *PartPtrTy = PartTy->getPointerTo(AS);
 3916             PLoad->getType()->getPointerTo(SI->getPointerAddressSpace());
 3993       auto *LoadPartPtrTy = PartTy->getPointerTo(LI->getPointerAddressSpace());
 3994       auto *StorePartPtrTy = PartTy->getPointerTo(SI->getPointerAddressSpace());

lib/Transforms/Utils/SimplifyLibCalls.cpp

 1014       LHSC = ConstantExpr::getBitCast(LHSC, IntType->getPointerTo());
 1019       RHSC = ConstantExpr::getBitCast(RHSC, IntType->getPointerTo());
 1029             IntType->getPointerTo(LHS->getType()->getPointerAddressSpace());
 1034             IntType->getPointerTo(RHS->getType()->getPointerAddressSpace());

lib/Transforms/Utils/ValueMapper.cpp

  971     VoidPtrTy = Type::getInt8Ty(GV.getContext())->getPointerTo();

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

 1079     Builder.CreateBitCast(S0->getPointerOperand(), VecTy->getPointerTo(AS)),
 1195       Builder.CreateBitCast(L0->getPointerOperand(), VecTy->getPointerTo(AS));

lib/Transforms/Vectorize/LoopVectorize.cpp

 2175   Type *PtrTy = VecTy->getPointerTo(getLoadStoreAddressSpace(Instr));
 2418     return Builder.CreateBitCast(PartPtr, DataTy->getPointerTo(AddressSpace));

lib/Transforms/Vectorize/SLPVectorizer.cpp

 4022                                             VecTy->getPointerTo(AS));
 4061       Value *VecPtr = Builder.CreateBitCast(ScalarPtr, VecTy->getPointerTo(AS));

tools/bugpoint/CrashDebugger.cpp

  231   UsedVar->mutateType(NewUsedVal->getType()->getPointerTo());

tools/clang/lib/CodeGen/Address.h

   93     return getBitCast(ty->getPointerTo(getAddressSpace()));

tools/clang/lib/CodeGen/BackendUtil.cpp

 1602   Type *UsedElementType = Type::getInt8Ty(M->getContext())->getPointerTo(0);

tools/clang/lib/CodeGen/CGAtomic.cpp

   91             CGF.Builder.getIntNTy(AtomicSizeInBits)->getPointerTo(),
  732                                                 SizeInBits)->getPointerTo();
  978       auto *DestType = T->getPointerElementType()->getPointerTo(DestAS);
 1194           Builder.CreateBitCast(Dest, ResVal->getType()->getPointerTo()));
 1201         Builder.CreateBitCast(Dest, ConvertTypeForMem(RValTy)->getPointerTo()),
 1252         Builder.CreateBitCast(Dest, ConvertTypeForMem(RValTy)->getPointerTo(
 1325       Builder.CreateBitCast(Dest, ConvertTypeForMem(RValTy)->getPointerTo(
 1335   return CGF.Builder.CreateBitCast(addr, ty->getPointerTo(addrspace));

tools/clang/lib/CodeGen/CGBlocks.cpp

 1501       BlockInfo->StructureType->getPointerTo(
 2040   llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
 2235   llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
 2289     field = CGF.Builder.CreateBitCast(field, CGF.Int8PtrTy->getPointerTo(0));
 2485     llvm::Type *byrefPtrType = byrefInfo.Type->getPointerTo(0);
 2562     auto byrefPtrType = byrefInfo.Type->getPointerTo(0);
 3013                                                 Int8PtrTy->getPointerTo(),
 3024                                                Int8PtrTy->getPointerTo(),

tools/clang/lib/CodeGen/CGBuilder.h

  158     auto PtrTy = Ty->getPointerTo(Addr.getAddressSpace());

tools/clang/lib/CodeGen/CGBuiltin.cpp

  132   llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
  193   llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
  233   llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
  328   Ptr = CGF.Builder.CreateBitCast(Ptr, ITy->getPointerTo());
  342   Ptr = CGF.Builder.CreateBitCast(Ptr, ITy->getPointerTo());
  717   llvm::Type *IntPtrType = IntType->getPointerTo();
 2845     Ptr = Builder.CreateBitCast(Ptr, ITy->getPointerTo());
 2901     Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
 2984     Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
 3400     llvm::Type *IntPtrType = IntType->getPointerTo();
 3848       llvm::PointerType *EventPtrTy = EventTy->getPointerTo(
 4184               ArgValue->getType()->getPointerTo(PtrTy->getAddressSpace()));
 4208             V, V->getType()->getPointerTo(PtrTy->getAddressSpace()));
 6189         getLLVMContext(), getContext().getTypeSize(Ty))->getPointerTo();
 6238     StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
 7180         getLLVMContext(), getContext().getTypeSize(Ty))->getPointerTo();
 7227     StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
12270     llvm::Type *Int128PtrTy = Int128Ty->getPointerTo();
14469                                             NewBase->getType()->getPointerTo());
14493                                             NewBase->getType()->getPointerTo());
14533         Builder.CreateBitCast(DestAddress, DestVal->getType()->getPointerTo());
14552         llvm::VectorType::get(Builder.getInt1Ty(), Size)->getPointerTo(0));
14558                                               Vprd->getType()->getPointerTo(0));
14574         llvm::VectorType::get(Builder.getInt1Ty(), Size)->getPointerTo(0));
14580                                               Vprd->getType()->getPointerTo(0));

tools/clang/lib/CodeGen/CGCUDANV.cpp

  168   VoidPtrPtrTy = VoidPtrTy->getPointerTo();
  202   llvm::Type *Params[] = {RegisterGlobalsFnTy->getPointerTo(), VoidPtrTy,
  203                           VoidPtrTy, CallbackFnTy->getPointerTo()};
  411       VoidPtrTy,    VoidPtrTy, VoidPtrTy, VoidPtrTy, IntTy->getPointerTo()};
  433         llvm::ConstantPointerNull::get(IntTy->getPointerTo())};

tools/clang/lib/CodeGen/CGCXX.cpp

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

tools/clang/lib/CodeGen/CGCXXABI.cpp

   53   llvm::Constant *FnPtr = llvm::Constant::getNullValue(FTy->getPointerTo());
   63                          ->getPointerTo(Base.getAddressSpace());

tools/clang/lib/CodeGen/CGCall.cpp

 1251                                     Ty->getPointerTo(Src.getAddressSpace()));
 1596     ArgTypes[IRFunctionArgs.getInallocaArgNo()] = ArgStruct->getPointerTo();
 1624       ArgTypes[FirstIRArg] = LTy->getPointerTo(
 2261     assert(ArgStruct.getType() == FI.getArgStruct()->getPointerTo());
 3038   llvm::Type *IRPtrTy = IRTy->getPointerTo();
 3039   llvm::Value *Placeholder = llvm::UndefValue::get(IRPtrTy->getPointerTo());
 3925         llvm::Type *MemType = ConvertTypeForMem(I->Ty)->getPointerTo(AS);
 4017           auto *T = V->getType()->getPointerElementType()->getPointerTo(
 4113                                       STy->getPointerTo(Src.getAddressSpace()));
 4203           Builder.CreateBitCast(CalleePtr, IRFuncTy->getPointerTo(CalleeAS));

tools/clang/lib/CodeGen/CGClass.cpp

  250   ptr = CGF.Builder.CreateBitCast(ptr, CGF.Int8Ty->getPointerTo(AddrSpace));
  307           ->getPointerTo(Value.getType()->getPointerAddressSpace());
  387   llvm::Type *DerivedPtrTy = ConvertType(DerivedTy)->getPointerTo(AddrSpace);
 2044         ThisPtr->getType()->getPointerElementType()->getPointerTo(TargetThisAS);
 2492           ->getPointerTo()
 2493           ->getPointerTo();
 2494   VTableField = Builder.CreateBitCast(VTableField, VTablePtrTy->getPointerTo());

tools/clang/lib/CodeGen/CGDecl.cpp

  269         LTy->getPointerTo(getContext().getTargetAddressSpace(ExpectedAS)));
 1167       Loc = Builder.CreateBitCast(Loc, Ty->getPointerTo(Loc.getAddressSpace()));
 1849   llvm::Type *BP = CGM.Int8Ty->getPointerTo(Loc.getAddressSpace());
 2376     llvm::Type *IRTy = ConvertTypeForMem(Ty)->getPointerTo(AS);
 2390       auto *T = V->getType()->getPointerElementType()->getPointerTo(DestAS);

tools/clang/lib/CodeGen/CGDeclCXX.cpp

  122       auto DestTy = CGF.getTypes().ConvertType(Type)->getPointerTo(
  133           Addr.getPointer(), CGF.getTypes().ConvertType(Type)->getPointerTo());

tools/clang/lib/CodeGen/CGException.cpp

  385   llvm::Type *ty = ConvertTypeForMem(e->getType())->getPointerTo();
 1941     SEHInfo = Builder.CreateBitCast(SEHInfo, Int8PtrTy->getPointerTo());
 1954   llvm::Type *RecordTy = CGM.Int32Ty->getPointerTo();
 1956   llvm::Value *Ptrs = Builder.CreateBitCast(SEHInfo, PtrsTy->getPointerTo());

tools/clang/lib/CodeGen/CGExpr.cpp

   97         Ty->getPointerTo(DestAddrSpace), /*non-null*/ true);
  400                 GV->getValueType()->getPointerTo(
  435                              ->getPointerTo(Object.getAddressSpace())),
  493                          ConvertTypeForMem(E->getType())->getPointerTo()),
 2289   return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name);
 3232       Builder.CreatePointerCast(Data, CfiCheckFailDataTy->getPointerTo(0)), 0,
 4935     CalleeTy = CalleeTy->getPointerTo();

tools/clang/lib/CodeGen/CGExprCXX.cpp

 2145     ConvertType(E->getType())->getPointerTo();

tools/clang/lib/CodeGen/CGExprConstant.cpp

 1792     llvm::Type *charPtrTy = CGM.Int8Ty->getPointerTo(AS);
 1892         CGM.getTypes().ConvertType(base.getTypeInfoType())->getPointerTo();

tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp

  547       llvm::PointerType *PtrTy = this->CGF->ConvertType(RT)->getPointerTo();
  557       llvm::PointerType *Ty = this->CGF->ConvertType(FT)->getPointerTo();

tools/clang/lib/CodeGen/CGObjC.cpp

 1062     bitcastType = bitcastType->getPointerTo(); // addrspace 0 okay
 1079       bitcastType = newTy->getPointerTo();

tools/clang/lib/CodeGen/CGObjCMac.cpp

  364     llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
  373     llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
  382     llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
  391     llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
  400     llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
  418     llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
  553     llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
  561     llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
  569     llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
  586     llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
 1959   auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
 1975   auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
 1997         CGM.Int32Ty->getPointerTo(),
 5957                  ->getPointerTo();
 6390         llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
 7266   if (!GV || GV->getType() != ObjCTypes.ClassnfABITy->getPointerTo()) {

tools/clang/lib/CodeGen/CGObjCRuntime.cpp

  369       CGM.getTypes().GetFunctionType(signature)->getPointerTo();
  383     CGM.getTypes().GetFunctionType(argsInfo)->getPointerTo();

tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp

 1762   return IdentTy->getPointerTo();
 1817                                 CGM.VoidPtrTy->getPointerTo()->getPointerTo()};
 1817                                 CGM.VoidPtrTy->getPointerTo()->getPointerTo()};
 1851                                 /*isVarArg*/ false)->getPointerTo();
 1857             ->getPointerTo();
 1861             ->getPointerTo();
 2029                                 CGM.VoidPtrTy, CpyFnTy->getPointerTo(),
 2045         CGM.VoidPtrTy, ReduceFnTy->getPointerTo(),
 2062         CGM.VoidPtrTy, ReduceFnTy->getPointerTo(),
 2250                                 CGM.Int64Ty->getPointerTo(),
 2251                                 CGM.Int64Ty->getPointerTo(),
 2286                                 CGM.Int64Ty->getPointerTo()};
 2296                                 CGM.Int64Ty->getPointerTo()};
 2358                                 CGM.Int64Ty->getPointerTo(),
 2359                                 CGM.Int64Ty->getPointerTo()};
 2374                                 CGM.Int64Ty->getPointerTo(),
 2375                                 CGM.Int64Ty->getPointerTo()};
 2390                                 CGM.Int64Ty->getPointerTo(),
 2391                                 CGM.Int64Ty->getPointerTo(),
 2408                                 CGM.Int64Ty->getPointerTo(),
 2409                                 CGM.Int64Ty->getPointerTo(),
 2452                                 CGM.Int64Ty->getPointerTo(),
 2453                                 CGM.Int64Ty->getPointerTo()};
 2467                                 CGM.Int64Ty->getPointerTo(),
 2468                                 CGM.Int64Ty->getPointerTo()};
 2481                                 CGM.Int64Ty->getPointerTo(),
 2482                                 CGM.Int64Ty->getPointerTo()};
 2496                                 CGM.Int64Ty->getPointerTo(),
 2497                                 CGM.Int64Ty->getPointerTo()};
 2510                                 CGM.Int64Ty->getPointerTo(),
 2511                                 CGM.Int64Ty->getPointerTo()};
 2525                                 CGM.Int64Ty->getPointerTo(),
 2526                                 CGM.Int64Ty->getPointerTo()};
 2837                            ->getPointerTo();
 2845                          ->getPointerTo();
 2851                          ->getPointerTo();
 3007           VarLVType->getPointerTo(/*AddrSpace=*/0)),
 3403         CGM, CGF.ConvertTypeForMem(CopyprivateArrayTy)->getPointerTo(),
 5032       KmpTaskTWithPrivatesTy->getPointerTo();
 5772       Loc, CGF.ConvertTypeForMem(ReductionArrayTy)->getPointerTo(), Privates,
 8637           BP, BPVal->getType()->getPointerTo(/*AddrSpace=*/0));
 8650           P, PVal->getType()->getPointerTo(/*AddrSpace=*/0));
 8697     SizesArrayArg = llvm::ConstantPointerNull::get(CGM.Int64Ty->getPointerTo());
 8699         llvm::ConstantPointerNull::get(CGM.Int64Ty->getPointerTo());

tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp

 1492       Bld.CreateBitCast(WorkID, ParallelFnTy->getPointerTo());
 1645                                 ShuffleReduceFnTy->getPointerTo(),
 1646                                 InterWarpCopyFnTy->getPointerTo()};
 1693                                 ShuffleReduceFnTy->getPointerTo(),
 1694                                 InterWarpCopyFnTy->getPointerTo(),
 1695                                 GlobalListFnTy->getPointerTo(),
 1696                                 GlobalListFnTy->getPointerTo(),
 1697                                 GlobalListFnTy->getPointerTo(),
 1698                                 GlobalListFnTy->getPointerTo()};
 1742     llvm::Type *TypeParams[] = {CGM.Int8PtrPtrTy->getPointerTo(), CGM.SizeTy};
 1757     llvm::Type *TypeParams[] = {CGM.Int8PtrPtrTy->getPointerTo()};
 2135         CGF.ConvertTypeForMem(GlobalRecTy)->getPointerTo();
 2269           GlobalRecValue, CGF.ConvertTypeForMem(GlobalRecTy)->getPointerTo());
 2295           CGF.ConvertTypeForMem(SecGlobalRecTy)->getPointerTo();
 2380         GlobalRecValue, CGF.ConvertTypeForMem(VD->getType())->getPointerTo());
 2828       CastItem, Val->getType()->getPointerTo(CastItem.getAddressSpace()));
 2893     Ptr = Bld.CreatePointerBitCastOrAddrSpaceCast(Ptr, IntTy->getPointerTo());
 2895         Bld.CreatePointerBitCastOrAddrSpaceCast(ElemPtr, IntTy->getPointerTo());
 3234           CGF.ConvertTypeForMem(ReductionArrayTy)->getPointerTo()),
 3505           CGF.ConvertTypeForMem(ReductionArrayTy)->getPointerTo()),
 3661           CGF.ConvertTypeForMem(ReductionArrayTy)->getPointerTo()),
 3668       LLVMReductionsBufferTy->getPointerTo());
 3681         ElemPtrPtr, CGF.ConvertTypeForMem(Private->getType())->getPointerTo());
 3767       LLVMReductionsBufferTy->getPointerTo());
 3861           CGF.ConvertTypeForMem(ReductionArrayTy)->getPointerTo()),
 3868       LLVMReductionsBufferTy->getPointerTo());
 3882         ElemPtrPtr, CGF.ConvertTypeForMem(Private->getType())->getPointerTo());
 3967       LLVMReductionsBufferTy->getPointerTo());
 4328       Loc, CGF.ConvertTypeForMem(ReductionArrayTy)->getPointerTo(), Privates,
 4496       TargetAddr, TargetAddr->getType()->getPointerElementType()->getPointerTo(
 4500       TargetAddr, TargetAddr->getType()->getPointerElementType()->getPointerTo(
 4527         NativeArg->getType()->getPointerElementType()->getPointerTo());
 4612         Src, CGF.SizeTy->getPointerTo());
 4622         Src, CGF.SizeTy->getPointerTo());

tools/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp

  507             getPointerTo()->getPointerTo()));
  507             getPointerTo()->getPointerTo()));

tools/clang/lib/CodeGen/CGStmt.cpp

 2334                                         ResultRegTypes[i]->getPointerTo());

tools/clang/lib/CodeGen/CodeGenModule.cpp

  122   Int8PtrTy = Int8Ty->getPointerTo(0);
  123   Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
  124   AllocaInt8PtrTy = Int8Ty->getPointerTo(
 2394     auto Ptr = llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
 3158       return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
 3199         F, Entry->getType()->getElementType()->getPointerTo());
 3779             GV->getValueType()->getPointerTo(
 5094         Type->getPointerTo(

tools/clang/lib/CodeGen/CodeGenTypes.cpp

  637     ResultType = T->getPointerTo();

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

  683       VirtualFn = Builder.CreateBitCast(VirtualFn, FTy->getPointerTo(),
  694           Builder.CreateBitCast(VFPAddr, FTy->getPointerTo()->getPointerTo());
  694           Builder.CreateBitCast(VFPAddr, FTy->getPointerTo()->getPointerTo());
  735     Builder.CreateIntToPtr(FnAsInt, FTy->getPointerTo(), "memptr.nonvirtualfn");
  776   llvm::PHINode *CalleePtr = Builder.CreatePHI(FTy->getPointerTo(), 2);
  803                             ->getPointerTo(Base.getAddressSpace());
 1183         CGF.GetVTablePtr(Ptr, CGF.IntPtrTy->getPointerTo(), ClassDecl);
 1386       CGF.GetVTablePtr(ThisPtr, StdTypeInfoPtrTy->getPointerTo(), ClassDecl);
 1452   llvm::Value *VTable = CGF.GetVTablePtr(ThisAddr, PtrDiffLTy->getPointerTo(),
 1492                                              CGM.PtrDiffTy->getPointerTo());
 1779   Ty = Ty->getPointerTo()->getPointerTo();
 1779   Ty = Ty->getPointerTo()->getPointerTo();
 1934     OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
 2059       llvm::FunctionType::get(CGF.SizeTy, CGF.SizeTy->getPointerTo(0), false);
 2209   llvm::PointerType *guardPtrTy = guardTy->getPointerTo();
 2371     llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
 2376       AddrAS ? CGF.Int8Ty->getPointerTo(AddrAS) : CGF.Int8PtrTy;
 4191     llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
 4216   llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok

tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp

  477         getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()),
  495             getBaseClassDescriptorType()->getPointerTo()->getPointerTo()),
  495             getBaseClassDescriptorType()->getPointerTo()->getPointerTo()),
  511         getImageRelativeType(getClassHierarchyDescriptorType()->getPointerTo()),
  706         getImageRelativeType(getCatchableTypeType()->getPointerTo());
  733     llvm::Type *Args[] = {CGM.Int8PtrTy, getThrowInfoType()->getPointerTo()};
  857       llvm::ConstantPointerNull::get(getThrowInfoType()->getPointerTo())};
 1196                                        CGF.Int8Ty->getPointerTo(AS));
 1201         VtorDispPtr, CGF.Int32Ty->getPointerTo(AS), "vtordisp.ptr");
 1500       llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS),
 1863   Ty = Ty->getPointerTo()->getPointerTo();
 1863   Ty = Ty->getPointerTo()->getPointerTo();
 2025       getThisAddress(CGF), ThunkTy->getPointerTo()->getPointerTo(), MD->getParent());
 2025       getThisAddress(CGF), ThunkTy->getPointerTo()->getPointerTo(), MD->getParent());
 2365                               CGM.IntTy->getPointerTo(), /*isVarArg=*/false);
 2377                               CGM.IntTy->getPointerTo(), /*isVarArg=*/false);
 2389                               CGM.IntTy->getPointerTo(), /*isVarArg=*/false);
 2951             CGM.Int32Ty->getPointerTo(0)->getPointerTo(This.getAddressSpace()));
 2951             CGM.Int32Ty->getPointerTo(0)->getPointerTo(This.getAddressSpace()));
 2970   VBaseOffs = Builder.CreateBitCast(VBaseOffs, CGM.Int32Ty->getPointerTo(0));
 3039       CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS);
 3068   Addr = Builder.CreateBitCast(Addr, CGF.Int8Ty->getPointerTo(AS));
 3371     Builder.CreateBitCast(FunctionPointer, FTy->getPointerTo());
 3630       ABI.getBaseClassDescriptorType()->getPointerTo());
 4179       getImageRelativeType(getCatchableTypeType()->getPointerTo());

tools/clang/lib/CodeGen/TargetInfo.cpp

  358     DirectTy = DirectTy->getPointerTo(0);
 1229                                                   CoerceTy->getPointerTo()));
 4245   if (isIndirect) DirectTy = DirectTy->getPointerTo(0);

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

 1799                   get_element_ptr, value->getType()->getPointerTo(), "",

tools/polly/lib/CodeGen/BlockGenerators.cpp

  279     auto OldPtrTy = ExpectedType->getPointerTo();
  804                 Address, Val->getType()->getPointerTo());

tools/polly/lib/CodeGen/IslNodeBuilder.cpp

 1213   Ptr = Builder.CreatePointerCast(Ptr, Ty->getPointerTo(AS), Name + ".cast");

tools/polly/lib/CodeGen/LoopGeneratorsGOMP.cpp

  181     Type *Params[] = {LongType->getPointerTo(), LongType->getPointerTo()};
  181     Type *Params[] = {LongType->getPointerTo(), LongType->getPointerTo()};

tools/polly/lib/CodeGen/LoopGeneratorsKMP.cpp

   30     Type *MicroParams[] = {Builder.getInt32Ty()->getPointerTo(),
   31                            Builder.getInt32Ty()->getPointerTo()};
   41     Type *Params[] = {IdentTy->getPointerTo(), Builder.getInt32Ty(),
   42                       KMPCMicroTy->getPointerTo()};
   49       SubFn, KMPCMicroTy->getPointerTo());
   77   std::vector<Type *> Arguments = {Builder.getInt32Ty()->getPointerTo(),
   78                                    Builder.getInt32Ty()->getPointerTo(),
  281     Type *Params[] = {IdentTy->getPointerTo()};
  300     Type *Params[] = {IdentTy->getPointerTo(), Builder.getInt32Ty(),
  326     Type *Params[] = {IdentTy->getPointerTo(),
  329                       Builder.getInt32Ty()->getPointerTo(),
  330                       LongType->getPointerTo(),
  331                       LongType->getPointerTo(),
  332                       LongType->getPointerTo(),
  364     Type *Params[] = {IdentTy->getPointerTo(), Builder.getInt32Ty()};
  387     Type *Params[] = {IdentTy->getPointerTo(),
  427     Type *Params[] = {IdentTy->getPointerTo(),
  429                       Builder.getInt32Ty()->getPointerTo(),
  430                       LongType->getPointerTo(),
  431                       LongType->getPointerTo(),
  432                       LongType->getPointerTo()};

tools/polly/lib/CodeGen/RuntimeDebugBuilder.cpp

  223     Ptr = Builder.CreatePointerBitCastOrAddrSpaceCast(Ptr, Ty->getPointerTo(5));

unittests/Analysis/BasicAliasAnalysisTest.cpp

   72       FunctionType::get(B.getVoidTy(), {B.getInt32Ty()->getPointerTo()}, false),

unittests/Analysis/ScalarEvolutionTest.cpp

  403   PointerType *IntPtrPtrTy = IntPtrTy->getPointerTo();
  754   Type *T_pint64 = T_int64->getPointerTo(10);
  828   Type *T_pint64 = T_int64->getPointerTo(10);
  926   Type *T_pint64 = T_int64->getPointerTo(10);
 1154   Type *T_pint64 = T_int64->getPointerTo(10);

unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

   35             {IntTy, Type::getInt8PtrTy(Context)->getPointerTo()},

unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp

  100                          Type::getInt8PtrTy(Ctx)->getPointerTo()},

unittests/IR/IRBuilderTest.cpp

  152   Type *PtrToVecTy = VecTy->getPointerTo();

unittests/IR/InstructionsTest.cpp

  508   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
  542   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
  569   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());

unittests/Transforms/Utils/ValueMapperTest.cpp

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