Lines Matching defs:CGF
376 CodeGenFunction &CGF) const;
386 CodeGenFunction &CGF) const {
439 CodeGenFunction &CGF) const;
457 CodeGenFunction &CGF) const {
503 static llvm::Type* X86AdjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
512 return llvm::Type::getX86_MMXTy(CGF.getLLVMContext());
564 CodeGenFunction &CGF) const;
590 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
593 llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
596 return X86AdjustInlineAsmType(CGF, Constraint, Ty);
981 CodeGenFunction &CGF) const {
982 llvm::Type *BPP = CGF.Int8PtrPtrTy;
984 CGBuilderTy &Builder = CGF.Builder;
990 unsigned Align = CGF.getContext().getTypeAlignInChars(Ty).getQuantity();
996 llvm::ConstantInt::get(CGF.Int32Ty, Align - 1);
997 Addr = CGF.Builder.CreateGEP(Addr, Offset);
998 llvm::Value *AsInt = CGF.Builder.CreatePtrToInt(Addr,
999 CGF.Int32Ty);
1000 llvm::Value *Mask = llvm::ConstantInt::get(CGF.Int32Ty, -Align);
1001 Addr = CGF.Builder.CreateIntToPtr(CGF.Builder.CreateAnd(AsInt, Mask),
1007 llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
1011 llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, Align);
1013 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset),
1040 CodeGen::CodeGenFunction &CGF,
1042 CodeGen::CGBuilderTy &Builder = CGF.Builder;
1044 llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
1051 if (CGF.CGM.getTarget().getTriple().isOSDarwin()) {
1055 llvm::Value *Sixteen8 = llvm::ConstantInt::get(CGF.Int8Ty, 16);
1066 llvm::Value *Twelve8 = llvm::ConstantInt::get(CGF.Int8Ty, 12);
1211 CodeGenFunction &CGF) const;
1225 CodeGenFunction &CGF) const;
1241 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
1243 llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
1247 AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
1251 llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
1254 return X86AdjustInlineAsmType(CGF, Constraint, Ty);
1323 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
1325 llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
1329 AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
2387 CodeGenFunction &CGF) {
2389 CGF.Builder.CreateStructGEP(VAListAddr, 2, "overflow_arg_area_p");
2391 CGF.Builder.CreateLoad(overflow_arg_area_p, "overflow_arg_area");
2397 uint64_t Align = CGF.getContext().getTypeAlign(Ty) / 8;
2401 llvm::ConstantInt::get(CGF.Int64Ty, Align - 1);
2402 overflow_arg_area = CGF.Builder.CreateGEP(overflow_arg_area, Offset);
2403 llvm::Value *AsInt = CGF.Builder.CreatePtrToInt(overflow_arg_area,
2404 CGF.Int64Ty);
2405 llvm::Value *Mask = llvm::ConstantInt::get(CGF.Int64Ty, -(uint64_t)Align);
2407 CGF.Builder.CreateIntToPtr(CGF.Builder.CreateAnd(AsInt, Mask),
2413 llvm::Type *LTy = CGF.ConvertTypeForMem(Ty);
2415 CGF.Builder.CreateBitCast(overflow_arg_area,
2423 uint64_t SizeInBytes = (CGF.getContext().getTypeSize(Ty) + 7) / 8;
2425 llvm::ConstantInt::get(CGF.Int32Ty, (SizeInBytes + 7) & ~7);
2426 overflow_arg_area = CGF.Builder.CreateGEP(overflow_arg_area, Offset,
2428 CGF.Builder.CreateStore(overflow_arg_area, overflow_arg_area_p);
2435 CodeGenFunction &CGF) const {
2445 Ty = CGF.getContext().getCanonicalType(Ty);
2452 return EmitVAArgFromMemory(VAListAddr, Ty, CGF);
2469 gp_offset_p = CGF.Builder.CreateStructGEP(VAListAddr, 0, "gp_offset_p");
2470 gp_offset = CGF.Builder.CreateLoad(gp_offset_p, "gp_offset");
2471 InRegs = llvm::ConstantInt::get(CGF.Int32Ty, 48 - neededInt * 8);
2472 InRegs = CGF.Builder.CreateICmpULE(gp_offset, InRegs, "fits_in_gp");
2476 fp_offset_p = CGF.Builder.CreateStructGEP(VAListAddr, 1, "fp_offset_p");
2477 fp_offset = CGF.Builder.CreateLoad(fp_offset_p, "fp_offset");
2479 llvm::ConstantInt::get(CGF.Int32Ty, 176 - neededSSE * 16);
2480 FitsInFP = CGF.Builder.CreateICmpULE(fp_offset, FitsInFP, "fits_in_fp");
2481 InRegs = InRegs ? CGF.Builder.CreateAnd(InRegs, FitsInFP) : FitsInFP;
2484 llvm::BasicBlock *InRegBlock = CGF.createBasicBlock("vaarg.in_reg");
2485 llvm::BasicBlock *InMemBlock = CGF.createBasicBlock("vaarg.in_mem");
2486 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("vaarg.end");
2487 CGF.Builder.CreateCondBr(InRegs, InRegBlock, InMemBlock);
2491 CGF.EmitBlock(InRegBlock);
2503 llvm::Type *LTy = CGF.ConvertTypeForMem(Ty);
2505 CGF.Builder.CreateLoad(CGF.Builder.CreateStructGEP(VAListAddr, 3),
2511 llvm::Value *Tmp = CGF.CreateMemTemp(Ty);
2512 Tmp = CGF.Builder.CreateBitCast(Tmp, ST->getPointerTo());
2520 llvm::Value *GPAddr = CGF.Builder.CreateGEP(RegAddr, gp_offset);
2521 llvm::Value *FPAddr = CGF.Builder.CreateGEP(RegAddr, fp_offset);
2525 CGF.Builder.CreateLoad(CGF.Builder.CreateBitCast(RegLoAddr, PTyLo));
2526 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 0));
2527 V = CGF.Builder.CreateLoad(CGF.Builder.CreateBitCast(RegHiAddr, PTyHi));
2528 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1));
2530 RegAddr = CGF.Builder.CreateBitCast(Tmp,
2533 RegAddr = CGF.Builder.CreateGEP(RegAddr, gp_offset);
2534 RegAddr = CGF.Builder.CreateBitCast(RegAddr,
2539 CGF.getContext().getTypeInfoInChars(Ty);
2543 llvm::Value *Tmp = CGF.CreateMemTemp(Ty);
2544 CGF.Builder.CreateMemCpy(Tmp, RegAddr, TySize, 8, false);
2548 RegAddr = CGF.Builder.CreateGEP(RegAddr, fp_offset);
2549 RegAddr = CGF.Builder.CreateBitCast(RegAddr,
2555 llvm::Value *RegAddrLo = CGF.Builder.CreateGEP(RegAddr, fp_offset);
2556 llvm::Value *RegAddrHi = CGF.Builder.CreateConstGEP1_32(RegAddrLo, 16);
2557 llvm::Type *DoubleTy = CGF.DoubleTy;
2561 llvm::Value *V, *Tmp = CGF.CreateMemTemp(Ty);
2562 Tmp = CGF.Builder.CreateBitCast(Tmp, ST->getPointerTo());
2563 V = CGF.Builder.CreateLoad(CGF.Builder.CreateBitCast(RegAddrLo,
2565 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 0));
2566 V = CGF.Builder.CreateLoad(CGF.Builder.CreateBitCast(RegAddrHi,
2568 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1));
2569 RegAddr = CGF.Builder.CreateBitCast(Tmp,
2577 llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int32Ty, neededInt * 8);
2578 CGF.Builder.CreateStore(CGF.Builder.CreateAdd(gp_offset, Offset),
2582 llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int32Ty, neededSSE * 16);
2583 CGF.Builder.CreateStore(CGF.Builder.CreateAdd(fp_offset, Offset),
2586 CGF.EmitBranch(ContBlock);
2590 CGF.EmitBlock(InMemBlock);
2591 llvm::Value *MemAddr = EmitVAArgFromMemory(VAListAddr, Ty, CGF);
2595 CGF.EmitBlock(ContBlock);
2596 llvm::PHINode *ResAddr = CGF.Builder.CreatePHI(RegAddr->getType(), 2,
2657 CodeGenFunction &CGF) const {
2658 llvm::Type *BPP = CGF.Int8PtrPtrTy;
2660 CGBuilderTy &Builder = CGF.Builder;
2665 llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
2669 llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, 8);
2671 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset),
2686 CodeGenFunction &CGF) const;
2708 CodeGenFunction &CGF) const {
2711 return NInfo.EmitVAArg(VAListAddr, Ty, CGF);
2727 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2734 PPC32TargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2739 CodeGen::CGBuilderTy &Builder = CGF.Builder;
2741 llvm::IntegerType *i8 = CGF.Int8Ty;
2816 CodeGenFunction &CGF) const;
2829 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2842 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2908 CodeGenFunction &CGF) const {
2909 llvm::Type *BP = CGF.Int8PtrTy;
2910 llvm::Type *BPP = CGF.Int8PtrPtrTy;
2912 CGBuilderTy &Builder = CGF.Builder;
2920 unsigned SizeInBytes = CGF.getContext().getTypeSize(Ty) / 8;
2926 CplxBaseSize = CGF.getContext().getTypeSize(BaseTy) / 8;
2933 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int64Ty, Offset),
2944 llvm::Value *RealAddr = Builder.CreatePtrToInt(Addr, CGF.Int64Ty);
2948 llvm::Type *PBaseTy = llvm::PointerType::getUnqual(CGF.ConvertType(BaseTy));
2953 llvm::Value *Ptr = CGF.CreateTempAlloca(CGT.ConvertTypeForMem(Ty),
2966 llvm::Value *AddrAsInt = Builder.CreatePtrToInt(Addr, CGF.Int64Ty);
2971 llvm::Type *PTy = llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
2976 PPC64_initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
2981 CodeGen::CGBuilderTy &Builder = CGF.Builder;
2983 llvm::IntegerType *i8 = CGF.Int8Ty;
3018 CodeGen::CodeGenFunction &CGF,
3021 return PPC64_initDwarfEHRegSizeTable(CGF, Address);
3025 PPC64TargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
3028 return PPC64_initDwarfEHRegSizeTable(CGF, Address);
3071 CodeGenFunction &CGF) const;
3095 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
3097 llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
3100 AssignToArrayRange(CGF.Builder, Address, Four8, 0, 15);
3583 CodeGenFunction &CGF) const {
3584 llvm::Type *BP = CGF.Int8PtrTy;
3585 llvm::Type *BPP = CGF.Int8PtrPtrTy;
3587 CGBuilderTy &Builder = CGF.Builder;
3593 llvm::Type *PTy = llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
3597 uint64_t Size = CGF.getContext().getTypeSize(Ty) / 8;
3598 uint64_t TyAlign = CGF.getContext().getTypeAlign(Ty) / 8;
3619 llvm::Value *AddrAsInt = Builder.CreatePtrToInt(Addr, CGF.Int32Ty);
3628 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset),
3634 else if (TyAlign < CGF.getContext().getTypeAlign(Ty) / 8) {
3642 llvm::Value *AlignedTemp = CGF.CreateTempAlloca(CGF.ConvertType(Ty),
3647 llvm::ConstantInt::get(CGF.IntPtrTy, CharSize.getQuantity()),
3652 llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
3666 CodeGenFunction &CGF) const;
3688 CodeGenFunction &CGF) const {
3691 return static_cast<const ABIInfo&>(NInfo).EmitVAArg(VAListAddr, Ty, CGF);
3717 CodeGenFunction &CGF) const;
3733 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
3736 llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
3737 AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 31);
3740 llvm::Value *Sixteen8 = llvm::ConstantInt::get(CGF.Int8Ty, 16);
3741 AssignToArrayRange(CGF.Builder, Address, Sixteen8, 64, 95);
3901 CodeGenFunction &CGF) const {
3913 assert(!CGF.CGM.getDataLayout().isBigEndian()
3917 Ty = CGF.getContext().getCanonicalType(Ty);
3920 llvm::BasicBlock *MaybeRegBlock = CGF.createBasicBlock("vaarg.maybe_reg");
3921 llvm::BasicBlock *InRegBlock = CGF.createBasicBlock("vaarg.in_reg");
3922 llvm::BasicBlock *OnStackBlock = CGF.createBasicBlock("vaarg.on_stack");
3923 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("vaarg.end");
3931 reg_offs_p = CGF.Builder.CreateStructGEP(VAListAddr, 3, "gr_offs_p");
3932 reg_offs = CGF.Builder.CreateLoad(reg_offs_p, "gr_offs");
3938 reg_offs_p = CGF.Builder.CreateStructGEP(VAListAddr, 4, "vr_offs_p");
3939 reg_offs = CGF.Builder.CreateLoad(reg_offs_p, "vr_offs");
3953 UsingStack = CGF.Builder.CreateICmpSGE(reg_offs,
3954 llvm::ConstantInt::get(CGF.Int32Ty, 0));
3956 CGF.Builder.CreateCondBr(UsingStack, OnStackBlock, MaybeRegBlock);
3960 CGF.EmitBlock(MaybeRegBlock);
3968 reg_offs = CGF.Builder.CreateAdd(reg_offs,
3969 llvm::ConstantInt::get(CGF.Int32Ty, Align - 1),
3971 reg_offs = CGF.Builder.CreateAnd(reg_offs,
3972 llvm::ConstantInt::get(CGF.Int32Ty, -Align),
3978 NewOffset = CGF.Builder.CreateAdd(reg_offs,
3979 llvm::ConstantInt::get(CGF.Int32Ty, RegSize),
3981 CGF.Builder.CreateStore(NewOffset, reg_offs_p);
3986 InRegs = CGF.Builder.CreateICmpSLE(NewOffset,
3987 llvm::ConstantInt::get(CGF.Int32Ty, 0),
3990 CGF.Builder.CreateCondBr(InRegs, InRegBlock, OnStackBlock);
3998 CGF.EmitBlock(InRegBlock);
4001 reg_top_p = CGF.Builder.CreateStructGEP(VAListAddr, reg_top_index, "reg_top_p");
4002 reg_top = CGF.Builder.CreateLoad(reg_top_p, "reg_top");
4003 llvm::Value *BaseAddr = CGF.Builder.CreateGEP(reg_top, reg_offs);
4005 llvm::Type *MemTy = llvm::PointerType::getUnqual(CGF.ConvertTypeForMem(Ty));
4022 llvm::Type *BaseTy = CGF.ConvertType(QualType(Base, 0));
4024 llvm::Value *Tmp = CGF.CreateTempAlloca(HFATy);
4027 llvm::Value *BaseOffset = llvm::ConstantInt::get(CGF.Int32Ty, 16 * i);
4028 llvm::Value *LoadAddr = CGF.Builder.CreateGEP(BaseAddr, BaseOffset);
4029 LoadAddr = CGF.Builder.CreateBitCast(LoadAddr,
4031 llvm::Value *StoreAddr = CGF.Builder.CreateStructGEP(Tmp, i);
4033 llvm::Value *Elem = CGF.Builder.CreateLoad(LoadAddr);
4034 CGF.Builder.CreateStore(Elem, StoreAddr);
4037 RegAddr = CGF.Builder.CreateBitCast(Tmp, MemTy);
4040 RegAddr = CGF.Builder.CreateBitCast(BaseAddr, MemTy);
4043 CGF.EmitBranch(ContBlock);
4048 CGF.EmitBlock(OnStackBlock);
4051 stack_p = CGF.Builder.CreateStructGEP(VAListAddr, 0, "stack_p");
4052 OnStackAddr = CGF.Builder.CreateLoad(stack_p, "stack");
4059 OnStackAddr = CGF.Builder.CreatePtrToInt(OnStackAddr, CGF.Int64Ty);
4061 OnStackAddr = CGF.Builder.CreateAdd(OnStackAddr,
4062 llvm::ConstantInt::get(CGF.Int64Ty, Align - 1),
4064 OnStackAddr = CGF.Builder.CreateAnd(OnStackAddr,
4065 llvm::ConstantInt::get(CGF.Int64Ty, -Align),
4068 OnStackAddr = CGF.Builder.CreateIntToPtr(OnStackAddr, CGF.Int8PtrTy);
4080 llvm::Value *StackSizeC = llvm::ConstantInt::get(CGF.Int32Ty, StackSize);
4081 llvm::Value *NewStack = CGF.Builder.CreateGEP(OnStackAddr, StackSizeC,
4085 CGF.Builder.CreateStore(NewStack, stack_p);
4087 OnStackAddr = CGF.Builder.CreateBitCast(OnStackAddr, MemTy);
4089 CGF.EmitBranch(ContBlock);
4094 CGF.EmitBlock(ContBlock);
4096 llvm::PHINode *ResAddr = CGF.Builder.CreatePHI(MemTy, 2, "vaarg.addr");
4103 return CGF.Builder.CreateLoad(ResAddr, "vaarg.addr");
4242 CodeGenFunction &CGF) const;
4338 CodeGenFunction &CGF) const {
4349 Ty = CGF.getContext().getCanonicalType(Ty);
4353 llvm::Type *APTy = llvm::PointerType::getUnqual(CGF.ConvertTypeForMem(Ty));
4381 CGF.Builder.CreateStructGEP(VAListAddr, RegCountField, "reg_count_ptr");
4382 llvm::Value *RegCount = CGF.Builder.CreateLoad(RegCountPtr, "reg_count");
4385 llvm::Value *InRegs = CGF.Builder.CreateICmpULT(RegCount, MaxRegsV,
4388 llvm::BasicBlock *InRegBlock = CGF.createBasicBlock("vaarg.in_reg");
4389 llvm::BasicBlock *InMemBlock = CGF.createBasicBlock("vaarg.in_mem");
4390 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("vaarg.end");
4391 CGF.Builder.CreateCondBr(InRegs, InRegBlock, InMemBlock);
4394 CGF.EmitBlock(InRegBlock);
4399 CGF.Builder.CreateMul(RegCount, PaddedSizeV, "scaled_reg_count");
4403 CGF.Builder.CreateAdd(ScaledRegCount, RegBase, "reg_offset");
4405 CGF.Builder.CreateStructGEP(VAListAddr, 3, "reg_save_area_ptr");
4407 CGF.Builder.CreateLoad(RegSaveAreaPtr, "reg_save_area");
4409 CGF.Builder.CreateGEP(RegSaveArea, RegOffset, "raw_reg_addr");
4411 CGF.Builder.CreateBitCast(RawRegAddr, APTy, "reg_addr");
4416 CGF.Builder.CreateAdd(RegCount, One, "reg_count");
4417 CGF.Builder.CreateStore(NewRegCount, RegCountPtr);
4418 CGF.EmitBranch(ContBlock);
4421 CGF.EmitBlock(InMemBlock);
4425 CGF.Builder.CreateStructGEP(VAListAddr, 2, "overflow_arg_area_ptr");
4427 CGF.Builder.CreateLoad(OverflowArgAreaPtr, "overflow_arg_area");
4430 CGF.Builder.CreateGEP(OverflowArgArea, PaddingV, "raw_mem_addr");
4432 CGF.Builder.CreateBitCast(RawMemAddr, APTy, "mem_addr");
4436 CGF.Builder.CreateGEP(OverflowArgArea, PaddedSizeV, "overflow_arg_area");
4437 CGF.Builder.CreateStore(NewOverflowArgArea, OverflowArgAreaPtr);
4438 CGF.EmitBranch(ContBlock);
4441 CGF.EmitBlock(ContBlock);
4442 llvm::PHINode *ResAddr = CGF.Builder.CreatePHI(APTy, 2, "va_arg.addr");
4447 return CGF.Builder.CreateLoad(ResAddr, "indirect_arg");
4596 CodeGenFunction &CGF) const;
4623 bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
4842 CodeGenFunction &CGF) const {
4843 llvm::Type *BP = CGF.Int8PtrTy;
4844 llvm::Type *BPP = CGF.Int8PtrPtrTy;
4846 CGBuilderTy &Builder = CGF.Builder;
4850 llvm::Type *PTy = llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
4853 llvm::IntegerType *IntTy = (PtrWidth == 32) ? CGF.Int32Ty : CGF.Int64Ty;
4856 llvm::Value *AddrAsInt = CGF.Builder.CreatePtrToInt(Addr, IntTy);
4859 llvm::Value *Add = CGF.Builder.CreateAdd(AddrAsInt, Inc);
4860 llvm::Value *And = CGF.Builder.CreateAnd(Add, Mask);
4861 AddrTyped = CGF.Builder.CreateIntToPtr(And, PTy);
4869 llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, TypeAlign);
4879 MIPSTargetCodeGenInfo::initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
4886 llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
4892 AssignToArrayRange(CGF.Builder, Address, Four8, 0, 65);
4902 AssignToArrayRange(CGF.Builder, Address, Four8, 80, 181);
4988 CodeGenFunction &CGF) const;
5084 CodeGenFunction &CGF) const {
5086 llvm::Type *BPP = CGF.Int8PtrPtrTy;
5088 CGBuilderTy &Builder = CGF.Builder;
5093 llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
5097 llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, 4);
5099 Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset),
5142 CodeGenFunction &CGF) const;
5301 CodeGenFunction &CGF) const {
5307 llvm::Type *BPP = CGF.Int8PtrPtrTy;
5308 CGBuilderTy &Builder = CGF.Builder;