|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
gen/tools/clang/include/clang/Basic/arm_mve_builtin_cg.inc 17 Value *Val1 = Builder.CreateLoad(Val0);
19 Value *Val3 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vldr_gather_base_wb, llvm::SmallVector<llvm::Type *, 2> {Param0, llvm::VectorType::get(Int32Ty, 4)}), llvm::SmallVector<Value *, 2> {Val1, Val2});
20 Value *Val4 = Builder.CreateExtractValue(Val3, 1);
21 Builder.CreateStore(Val4, Val0);
22 return Builder.CreateExtractValue(Val3, 0);
27 Value *Val1 = Builder.CreateLoad(Val0);
30 Value *Val4 = Builder.CreateIntCast(Val3, Int32Ty, false);
31 Value *Val5 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_pred_i2v, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 1> {Val4});
31 Value *Val5 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_pred_i2v, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 1> {Val4});
32 Value *Val6 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vldr_gather_base_wb_predicated, llvm::SmallVector<llvm::Type *, 3> {llvm::VectorType::get(Int64Ty, 2), llvm::VectorType::get(Int64Ty, 2), llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 3> {Val1, Val2, Val5});
32 Value *Val6 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vldr_gather_base_wb_predicated, llvm::SmallVector<llvm::Type *, 3> {llvm::VectorType::get(Int64Ty, 2), llvm::VectorType::get(Int64Ty, 2), llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 3> {Val1, Val2, Val5});
33 Value *Val7 = Builder.CreateExtractValue(Val6, 1);
34 Builder.CreateStore(Val7, Val0);
35 return Builder.CreateExtractValue(Val6, 0);
160 Value *Val1 = Builder.CreateIntCast(Val0, Int32Ty, false);
162 Value *Val3 = Builder.CreateCall(CGM.getIntrinsic(Param0, llvm::SmallVector<llvm::Type *, 1> {Param1}), llvm::SmallVector<Value *, 2> {Val1, Val2});
163 return Builder.CreateIntCast(Val3, Param2, Param3);
170 Value *Val3 = Builder.CreateLoad(Val2);
172 Value *Val5 = Builder.CreateShl(Val3, Val4);
173 Value *Val6 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vadc, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Int32Ty, 4)}), llvm::SmallVector<Value *, 3> {Val0, Val1, Val5});
175 Value *Val8 = Builder.CreateExtractValue(Val6, 1);
177 Value *Val10 = Builder.CreateLShr(Val8, Val9);
178 Value *Val11 = Builder.CreateAnd(Val7, Val10);
179 Builder.CreateStore(Val11, Val2);
180 return Builder.CreateExtractValue(Val6, 0);
208 Value *Val2 = Builder.CreateCall(CGM.getIntrinsic(Param0, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Int32Ty, 4)}), llvm::SmallVector<Value *, 2> {Val0, Val1});
209 return Builder.CreateIntCast(Val2, Int32Ty, Param1);
217 Value *Val4 = Builder.CreateLoad(Val3);
219 Value *Val6 = Builder.CreateShl(Val4, Val5);
221 Value *Val8 = Builder.CreateIntCast(Val7, Int32Ty, false);
222 Value *Val9 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_pred_i2v, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 1> {Val8});
222 Value *Val9 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_pred_i2v, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 1> {Val8});
223 Value *Val10 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vadc_predicated, llvm::SmallVector<llvm::Type *, 2> {llvm::VectorType::get(Int32Ty, 4), llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 5> {Val0, Val1, Val2, Val6, Val9});
223 Value *Val10 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vadc_predicated, llvm::SmallVector<llvm::Type *, 2> {llvm::VectorType::get(Int32Ty, 4), llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 5> {Val0, Val1, Val2, Val6, Val9});
225 Value *Val12 = Builder.CreateExtractValue(Val10, 1);
227 Value *Val14 = Builder.CreateLShr(Val12, Val13);
228 Value *Val15 = Builder.CreateAnd(Val11, Val14);
229 Builder.CreateStore(Val15, Val3);
230 return Builder.CreateExtractValue(Val10, 0);
239 Value *Val5 = Builder.CreateIntCast(Val4, Int32Ty, false);
240 Value *Val6 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_pred_i2v, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 1> {Val5});
240 Value *Val6 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_pred_i2v, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 1> {Val5});
241 Value *Val7 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vadc_predicated, llvm::SmallVector<llvm::Type *, 2> {llvm::VectorType::get(Int32Ty, 4), llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 5> {Val0, Val1, Val2, Val3, Val6});
241 Value *Val7 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vadc_predicated, llvm::SmallVector<llvm::Type *, 2> {llvm::VectorType::get(Int32Ty, 4), llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 5> {Val0, Val1, Val2, Val3, Val6});
243 Value *Val9 = Builder.CreateExtractValue(Val7, 1);
245 Value *Val11 = Builder.CreateLShr(Val9, Val10);
246 Value *Val12 = Builder.CreateAnd(Val8, Val11);
248 Builder.CreateStore(Val12, Val13);
249 return Builder.CreateExtractValue(Val7, 0);
256 Value *Val3 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vadc, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Int32Ty, 4)}), llvm::SmallVector<Value *, 3> {Val0, Val1, Val2});
258 Value *Val5 = Builder.CreateExtractValue(Val3, 1);
260 Value *Val7 = Builder.CreateLShr(Val5, Val6);
261 Value *Val8 = Builder.CreateAnd(Val4, Val7);
263 Builder.CreateStore(Val8, Val9);
264 return Builder.CreateExtractValue(Val3, 0);
281 Value *Val4 = Builder.CreateIntCast(Val3, Int32Ty, false);
282 Value *Val5 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_pred_i2v, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 1> {Val4});
282 Value *Val5 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_pred_i2v, llvm::SmallVector<llvm::Type *, 1> {llvm::VectorType::get(Builder.getInt1Ty(), 4)}), llvm::SmallVector<Value *, 1> {Val4});
283 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vcvt_narrow_predicated), llvm::SmallVector<Value *, 4> {Val0, Val1, Val2, Val5});
299 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_vcvt_narrow), llvm::SmallVector<Value *, 3> {Val0, Val1, Val2});
309 return Builder.CreateAdd(Val0, Val1);
315 return Builder.CreateFAdd(Val0, Val1);
321 return Builder.CreateFSub(Val0, Val1);
331 return Builder.CreateSub(Val0, Val1);
336 Value *Val2 = Builder.CreateLShr(Val0, Val1);
337 Value *Val3 = Builder.CreateIntCast(Val2, Int32Ty, false);
338 Value *Val4 = Builder.CreateIntCast(Val0, Int32Ty, false);
340 Value *Val6 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_urshrl), llvm::SmallVector<Value *, 3> {Val4, Val3, Val5});
341 Value *Val7 = Builder.CreateExtractValue(Val6, 1);
342 Value *Val8 = Builder.CreateIntCast(Val7, Int64Ty, false);
344 Value *Val10 = Builder.CreateShl(Val8, Val9);
345 Value *Val11 = Builder.CreateExtractValue(Val6, 0);
346 Value *Val12 = Builder.CreateIntCast(Val11, Int64Ty, false);
347 return Builder.CreateOr(Val10, Val12);
370 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 8);
375 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 4);
380 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 8);
385 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 4);
390 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 16);
395 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 8);
400 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 4);
405 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 16);
410 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 8);
415 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 4);
420 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 8);
425 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 4);
430 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 16);
435 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 8);
440 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 4);
445 Param0 = llvm::VectorType::get(Builder.getInt1Ty(), 16);
453 Value *Val3 = Builder.CreateIntCast(Val2, Int32Ty, false);
454 Value *Val4 = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_mve_pred_i2v, llvm::SmallVector<llvm::Type *, 1> {Param0}), llvm::SmallVector<Value *, 1> {Val3});
456 return Builder.CreateCall(CGM.getIntrinsic(Param1, llvm::SmallVector<llvm::Type *, 2> {Param2, Param0}), llvm::SmallVector<Value *, 4> {Val0, Val1, Val4, Val5});
tools/clang/lib/CodeGen/CGAtomic.cpp 87 VoidPtrAddr = CGF.Builder.CreateConstGEP1_64(
89 auto Addr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
91 CGF.Builder.getIntNTy(AtomicSizeInBits)->getPointerTo(),
203 addr = CGF.Builder.CreateStructGEP(addr, 0);
297 return CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
350 CGF.Builder.CreateMemSet(
365 llvm::Value *Expected = CGF.Builder.CreateLoad(Val1);
366 llvm::Value *Desired = CGF.Builder.CreateLoad(Val2);
368 llvm::AtomicCmpXchgInst *Pair = CGF.Builder.CreateAtomicCmpXchg(
376 llvm::Value *Old = CGF.Builder.CreateExtractValue(Pair, 0);
377 llvm::Value *Cmp = CGF.Builder.CreateExtractValue(Pair, 1);
391 CGF.Builder.CreateCondBr(Cmp, ContinueBB, StoreExpectedBB);
393 CGF.Builder.SetInsertPoint(StoreExpectedBB);
395 CGF.Builder.CreateStore(Old, Val1);
397 CGF.Builder.CreateBr(ContinueBB);
399 CGF.Builder.SetInsertPoint(ContinueBB);
457 llvm::SwitchInst *SI = CGF.Builder.CreateSwitch(FailureOrderVal, MonotonicBB);
464 CGF.Builder.SetInsertPoint(MonotonicBB);
467 CGF.Builder.CreateBr(ContBB);
470 CGF.Builder.SetInsertPoint(AcquireBB);
473 CGF.Builder.CreateBr(ContBB);
474 SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::consume),
476 SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::acquire),
480 CGF.Builder.SetInsertPoint(SeqCstBB);
483 CGF.Builder.CreateBr(ContBB);
484 SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::seq_cst),
488 CGF.Builder.SetInsertPoint(ContBB);
527 llvm::SwitchInst *SI = CGF.Builder.CreateSwitch(IsWeak, WeakBB);
528 SI->addCase(CGF.Builder.getInt1(false), StrongBB);
530 CGF.Builder.SetInsertPoint(StrongBB);
533 CGF.Builder.CreateBr(ContBB);
535 CGF.Builder.SetInsertPoint(WeakBB);
538 CGF.Builder.CreateBr(ContBB);
540 CGF.Builder.SetInsertPoint(ContBB);
548 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Ptr);
551 CGF.Builder.CreateStore(Load, Dest);
559 llvm::Value *LoadVal1 = CGF.Builder.CreateLoad(Val1);
560 llvm::StoreInst *Store = CGF.Builder.CreateStore(LoadVal1, Ptr);
638 llvm::Value *LoadVal1 = CGF.Builder.CreateLoad(Val1);
640 CGF.Builder.CreateAtomicRMW(Op, Ptr.getPointer(), LoadVal1, Order, Scope);
647 Result = CGF.Builder.CreateBinOp(PostOp, RMWI, LoadVal1);
649 Result = CGF.Builder.CreateNot(Result);
650 CGF.Builder.CreateStore(Result, Dest);
689 auto &Builder = CGF.Builder;
733 Address Ptr = Address(CGF.Builder.CreateBitCast(Val, IPtrTy), Align);
836 Val1Scalar = Builder.CreateMul(Val1Scalar, CGM.getSize(PointeeIncAmt));
1187 ResVal = Builder.CreateBinOp(PostOp, ResVal, LoadVal1);
1190 ResVal = Builder.CreateNot(ResVal);
1192 Builder.CreateStore(
1194 Builder.CreateBitCast(Dest, ResVal->getType()->getPointerTo()));
1201 Builder.CreateBitCast(Dest, ConvertTypeForMem(RValTy)->getPointerTo()),
1252 Builder.CreateBitCast(Dest, ConvertTypeForMem(RValTy)->getPointerTo(
1277 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1277 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1278 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, MonotonicBB);
1281 Builder.SetInsertPoint(MonotonicBB);
1284 Builder.CreateBr(ContBB);
1286 Builder.SetInsertPoint(AcquireBB);
1289 Builder.CreateBr(ContBB);
1290 SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::consume),
1292 SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::acquire),
1296 Builder.SetInsertPoint(ReleaseBB);
1299 Builder.CreateBr(ContBB);
1300 SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::release),
1304 Builder.SetInsertPoint(AcqRelBB);
1307 Builder.CreateBr(ContBB);
1308 SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::acq_rel),
1311 Builder.SetInsertPoint(SeqCstBB);
1314 Builder.CreateBr(ContBB);
1315 SI->addCase(Builder.getInt32((int)llvm::AtomicOrderingCABI::seq_cst),
1319 Builder.SetInsertPoint(ContBB);
1325 Builder.CreateBitCast(Dest, ConvertTypeForMem(RValTy)->getPointerTo(
1335 return CGF.Builder.CreateBitCast(addr, ty->getPointerTo(addrspace));
1343 CGF.Builder.CreateMemCpy(Tmp, Addr,
1361 addr = CGF.Builder.CreateStructGEP(addr, 0);
1369 return RValue::get(CGF.Builder.CreateLoad(addr));
1402 return RValue::get(CGF.Builder.CreateIntToPtr(IntVal, ValTy));
1404 return RValue::get(CGF.Builder.CreateBitCast(IntVal, ValTy));
1421 CGF.Builder.CreateStore(IntVal, CastTemp)
1446 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Addr, "atomic-load");
1588 return CGF.Builder.CreatePtrToInt(Value, InputIntTy);
1590 return CGF.Builder.CreateBitCast(Value, InputIntTy);
1599 return CGF.Builder.CreateLoad(Addr);
1607 auto *Inst = CGF.Builder.CreateAtomicCmpXchg(Addr.getPointer(),
1615 auto *PreviousVal = CGF.Builder.CreateExtractValue(Inst, /*Idxs=*/0);
1616 auto *SuccessFailureVal = CGF.Builder.CreateExtractValue(Inst, /*Idxs=*/1);
1750 auto *OldVal = CGF.Builder.CreateLoad(ExpectedAddr);
1751 CGF.Builder.CreateStore(OldVal, DesiredAddr);
1761 CGF.Builder.CreateCondBr(Res, ExitBB, ContBB);
1775 auto *CurBB = CGF.Builder.GetInsertBlock();
1777 llvm::PHINode *PHI = CGF.Builder.CreatePHI(OldVal->getType(),
1784 CGF.Builder.CreateStore(PHI, NewAtomicIntAddr);
1789 auto *DesiredVal = CGF.Builder.CreateLoad(NewAtomicIntAddr);
1792 PHI->addIncoming(Res.first, CGF.Builder.GetInsertBlock());
1793 CGF.Builder.CreateCondBr(Res.second, ExitBB, ContBB);
1836 auto *OldVal = CGF.Builder.CreateLoad(ExpectedAddr);
1837 CGF.Builder.CreateStore(OldVal, DesiredAddr);
1844 CGF.Builder.CreateCondBr(Res, ExitBB, ContBB);
1857 auto *CurBB = CGF.Builder.GetInsertBlock();
1859 llvm::PHINode *PHI = CGF.Builder.CreatePHI(OldVal->getType(),
1866 CGF.Builder.CreateStore(PHI, NewAtomicIntAddr);
1869 auto *DesiredVal = CGF.Builder.CreateLoad(NewAtomicIntAddr);
1872 PHI->addIncoming(Res.first, CGF.Builder.GetInsertBlock());
1873 CGF.Builder.CreateCondBr(Res.second, ExitBB, ContBB);
1959 intValue = Builder.CreateIntCast(
1961 llvm::StoreInst *store = Builder.CreateStore(intValue, addr);
tools/clang/lib/CodeGen/CGBlocks.cpp 842 CGF.Builder.CreateStructGEP(blockInfo.LocalAddress, capture.getIndex());
980 return Builder.CreateStructGEP(blockAddr, index, name);
983 Builder.CreateStore(value, projectField(index, name));
1034 Builder.CreateStore(LoadCXXThis(), addr);
1066 src = Builder.CreateStructGEP(LoadBlockStruct(),
1090 byrefPointer = Builder.CreateLoad(src, "byref.capture");
1092 byrefPointer = Builder.CreateBitCast(src.getPointer(), VoidPtrTy);
1095 Builder.CreateStore(byrefPointer, blockField);
1115 Builder.CreateStore(src.getPointer(), blockField);
1121 llvm::Value *value = Builder.CreateLoad(src, "captured");
1122 Builder.CreateStore(value, blockField);
1134 llvm::Value *value = Builder.CreateLoad(src, "block.captured_block");
1138 Builder.CreateStore(value, blockField);
1173 llvm::Value *result = Builder.CreatePointerCast(
1269 llvm::Value *BlockDescriptor = Builder.CreatePointerCast(
1281 llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 2);
1282 Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign());
1286 BlockPtr = Builder.CreatePointerCast(
1289 llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 3);
1292 BlockPtr = Builder.CreatePointerCast(BlockPtr, VoidPtrTy);
1298 Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign());
1309 Func = Builder.CreatePointerCast(Func, BlockFTyPtr);
1325 Address addr = Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(),
1333 addr = Address(Builder.CreateLoad(addr), byrefInfo.ByrefAlignment);
1336 addr = Builder.CreateBitCast(addr, byrefPointerType, "byref.addr");
1483 Builder.CreateStore(arg, alloc);
1490 cast<llvm::AllocaInst>(alloc.getPointer()), Builder);
1499 BlockPointer = Builder.CreatePointerCast(
1604 Builder.CreateStore(BlockPointer, Alloca);
1611 Address addr = Builder.CreateStructGEP(
1613 CXXThisValue = Builder.CreateLoad(addr, "this");
1626 Builder.CreateStore(capture.getConstant(), alloca);
1632 llvm::BasicBlock *entry = Builder.GetInsertBlock();
1633 llvm::BasicBlock::iterator entry_ptr = Builder.GetInsertPoint();
1645 llvm::BasicBlock *resume = Builder.GetInsertBlock();
1649 Builder.SetInsertPoint(entry, entry_ptr);
1656 DI->EmitLocation(Builder, variable->getLocation());
1664 Builder);
1669 variable, BlockPointerDbgLoc, Builder, blockInfo,
1674 DI->EmitLocation(Builder,
1680 Builder.ClearInsertionPoint();
1682 Builder.SetInsertPoint(resume);
1789 BlockVarAddr = CGF.Builder.CreateLoad(Addr);
1790 BlockVarAddr = CGF.Builder.CreateBitCast(BlockVarAddr, CGF.VoidPtrTy);
2043 src = Address(Builder.CreateLoad(src), blockInfo.BlockAlign);
2044 src = Builder.CreateBitCast(src, structPtrTy, "block.source");
2047 dst = Address(Builder.CreateLoad(dst), blockInfo.BlockAlign);
2048 dst = Builder.CreateBitCast(dst, structPtrTy, "block.dest");
2057 Address srcField = Builder.CreateStructGEP(src, index);
2058 Address dstField = Builder.CreateStructGEP(dst, index);
2078 llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src");
2085 Builder.CreateStore(null, dstField);
2103 llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src");
2104 srcValue = Builder.CreateBitCast(srcValue, VoidPtrTy);
2106 Builder.CreateBitCast(dstField.getPointer(), VoidPtrTy);
2238 src = Address(Builder.CreateLoad(src), blockInfo.BlockAlign);
2239 src = Builder.CreateBitCast(src, structPtrTy, "block");
2248 Address srcField = Builder.CreateStructGEP(src, capture.getIndex());
2274 destField = CGF.Builder.CreateBitCast(destField, CGF.VoidPtrTy);
2276 srcField = CGF.Builder.CreateBitCast(srcField, CGF.VoidPtrPtrTy);
2277 llvm::Value *srcValue = CGF.Builder.CreateLoad(srcField);
2289 field = CGF.Builder.CreateBitCast(field, CGF.Int8PtrTy->getPointerTo(0));
2290 llvm::Value *value = CGF.Builder.CreateLoad(field);
2331 llvm::Value *value = CGF.Builder.CreateLoad(srcField);
2337 CGF.Builder.CreateStore(null, destField);
2342 CGF.Builder.CreateStore(value, destField);
2343 CGF.Builder.CreateStore(null, srcField);
2368 llvm::Value *oldValue = CGF.Builder.CreateLoad(srcField);
2370 CGF.Builder.CreateStore(copy, destField);
2489 destField = Address(CGF.Builder.CreateLoad(destField),
2491 destField = CGF.Builder.CreateBitCast(destField, byrefPtrType);
2497 srcField = Address(CGF.Builder.CreateLoad(srcField),
2499 srcField = CGF.Builder.CreateBitCast(srcField, byrefPtrType);
2561 addr = Address(CGF.Builder.CreateLoad(addr), byrefInfo.ByrefAlignment);
2563 addr = CGF.Builder.CreateBitCast(addr, byrefPtrType);
2708 Address forwardingAddr = Builder.CreateStructGEP(baseAddr, 1, "forwarding");
2709 baseAddr = Address(Builder.CreateLoad(forwardingAddr), info.ByrefAlignment);
2712 return Builder.CreateStructGEP(baseAddr, info.FieldIndex, name);
2830 auto fieldAddr = Builder.CreateStructGEP(addr, nextHeaderIndex, name);
2831 Builder.CreateStore(value, fieldAddr);
2854 V = Builder.CreateIntToPtr(Builder.getInt32(isa), Int8PtrTy, "isa");
2854 V = Builder.CreateIntToPtr(Builder.getInt32(isa), Int8PtrTy, "isa");
2928 Builder.CreateBitCast(V, Int8PtrTy),
tools/clang/lib/CodeGen/CGBuiltin.cpp 55 Byte = CGF.Builder.getInt8(0x00);
64 CGF.Builder.CreateMemSet(AI, Byte, Size, AlignmentInBytes);
98 return CGF.Builder.CreatePtrToInt(V, IntType);
109 return CGF.Builder.CreateIntToPtr(V, ResultType);
135 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
140 llvm::Value *Result = CGF.Builder.CreateAtomicRMW(
151 Value *BC = CGF.Builder.CreateBitCast(
199 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
201 llvm::Value *Result = CGF.Builder.CreateAtomicRMW(
203 Result = CGF.Builder.CreateBinOp(Op, Result, Args[1]);
205 Result = CGF.Builder.CreateBinOp(llvm::Instruction::Xor, Result,
236 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
242 Value *Pair = CGF.Builder.CreateAtomicCmpXchg(
247 return CGF.Builder.CreateZExt(CGF.Builder.CreateExtractValue(Pair, 1),
247 return CGF.Builder.CreateZExt(CGF.Builder.CreateExtractValue(Pair, 1),
251 return EmitFromInt(CGF, CGF.Builder.CreateExtractValue(Pair, 0), T,
288 auto *Result = CGF.Builder.CreateAtomicCmpXchg(
292 return CGF.Builder.CreateExtractValue(Result, 0);
300 auto *Result = CGF.Builder.CreateAtomicRMW(
305 return CGF.Builder.CreateAdd(Result, ConstantInt::get(IntTy, 1));
313 auto *Result = CGF.Builder.CreateAtomicRMW(
318 return CGF.Builder.CreateSub(Result, ConstantInt::get(IntTy, 1));
328 Ptr = CGF.Builder.CreateBitCast(Ptr, ITy->getPointerTo());
329 llvm::LoadInst *Load = CGF.Builder.CreateAlignedLoad(Ptr, LoadSize);
342 Ptr = CGF.Builder.CreateBitCast(Ptr, ITy->getPointerTo());
344 CGF.Builder.CreateAlignedStore(Value, Ptr, StoreSize);
357 return CGF.Builder.CreateCall(F, Src0);
368 return CGF.Builder.CreateCall(F, { Src0, Src1 });
380 return CGF.Builder.CreateCall(F, { Src0, Src1, Src2 });
391 return CGF.Builder.CreateCall(F, {Src0, Src1});
403 return CGF.Builder.CreateCall(F, Src0);
409 llvm::CallInst *Call = CGF.Builder.CreateCall(F, V);
422 V = CGF.Builder.CreateBitCast(V, IntTy);
434 V = CGF.Builder.CreateLShr(V, ShiftCst);
439 V = CGF.Builder.CreateTrunc(V, IntTy);
442 return CGF.Builder.CreateICmpSLT(V, Zero);
470 llvm::Value *Tmp = CGF.Builder.CreateCall(Callee, {X, Y});
471 Carry = CGF.Builder.CreateExtractValue(Tmp, 1);
472 return CGF.Builder.CreateExtractValue(Tmp, 0);
481 llvm::Instruction *Call = CGF.Builder.CreateCall(F);
534 Builder.CreateBitCast(ArgValue, DestType, ArgValue->getName().data());
537 return Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue);
611 Value *Min = Builder.getInt1((Type & 2) != 0);
613 Value *NullIsUnknown = Builder.getTrue();
614 Value *Dynamic = Builder.getInt1(IsDynamic);
615 return Builder.CreateCall(F, {Ptr, Min, NullIsUnknown, Dynamic});
723 return CGF.Builder.CreateCall(IA, {BitBase, BitPos});
760 Value *ByteIndex = CGF.Builder.CreateAShr(
762 Value *BitBaseI8 = CGF.Builder.CreatePointerCast(BitBase, CGF.Int8PtrTy);
763 Address ByteAddr(CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, BitBaseI8,
767 CGF.Builder.CreateAnd(CGF.Builder.CreateTrunc(BitPos, CGF.Int8Ty),
767 CGF.Builder.CreateAnd(CGF.Builder.CreateTrunc(BitPos, CGF.Int8Ty),
773 Mask = CGF.Builder.CreateShl(llvm::ConstantInt::get(CGF.Int8Ty, 1), PosLow,
786 Mask = CGF.Builder.CreateNot(Mask);
789 OldByte = CGF.Builder.CreateAtomicRMW(RMWOp, ByteAddr.getPointer(), Mask,
793 OldByte = CGF.Builder.CreateLoad(ByteAddr, "bittest.byte");
800 NewByte = CGF.Builder.CreateXor(OldByte, Mask);
803 NewByte = CGF.Builder.CreateAnd(OldByte, CGF.Builder.CreateNot(Mask));
803 NewByte = CGF.Builder.CreateAnd(OldByte, CGF.Builder.CreateNot(Mask));
806 NewByte = CGF.Builder.CreateOr(OldByte, Mask);
810 CGF.Builder.CreateStore(NewByte, ByteAddr);
815 Value *ShiftedByte = CGF.Builder.CreateLShr(OldByte, PosLow, "bittest.shr");
816 return CGF.Builder.CreateAnd(
846 Arg1 = CGF.Builder.CreateCall(
849 Arg1 = CGF.Builder.CreateCall(
863 llvm::Value *Buf = CGF.Builder.CreateBitOrPointerCast(
927 BasicBlock *Begin = Builder.GetInsertBlock();
929 Builder.SetInsertPoint(End);
930 PHINode *Result = Builder.CreatePHI(ResultType, 2, "bitscan_result");
932 Builder.SetInsertPoint(Begin);
933 Value *IsZero = Builder.CreateICmpEQ(ArgValue, ArgZero);
935 Builder.CreateCondBr(IsZero, End, NotZero);
938 Builder.SetInsertPoint(NotZero);
943 Value *ZeroCount = Builder.CreateCall(F, {ArgValue, Builder.getTrue()});
943 Value *ZeroCount = Builder.CreateCall(F, {ArgValue, Builder.getTrue()});
944 ZeroCount = Builder.CreateIntCast(ZeroCount, IndexType, false);
945 Builder.CreateStore(ZeroCount, IndexAddress, false);
951 Value *ZeroCount = Builder.CreateCall(F, {ArgValue, Builder.getTrue()});
951 Value *ZeroCount = Builder.CreateCall(F, {ArgValue, Builder.getTrue()});
952 ZeroCount = Builder.CreateIntCast(ZeroCount, IndexType, false);
953 Value *Index = Builder.CreateNSWSub(ArgTypeLastIndex, ZeroCount);
954 Builder.CreateStore(Index, IndexAddress, false);
956 Builder.CreateBr(End);
959 Builder.SetInsertPoint(End);
1072 llvm::CallInst *CI = Builder.CreateCall(IA, EmitScalarExpr(E->getArg(0)));
1102 Value *Cond = Builder.CreateICmpNE(
1107 llvm::ConstantInt::get(Builder.getInt8Ty(), Kind)},
1190 Address BufAddr(Builder.CreateLoad(GetAddrOfLocalVar(Args[0]), "buf"),
1192 Builder.CreateStore(Builder.getInt8(Layout.getSummaryByte()),
1192 Builder.CreateStore(Builder.getInt8(Layout.getSummaryByte()),
1193 Builder.CreateConstByteGEP(BufAddr, Offset++, "summary"));
1194 Builder.CreateStore(Builder.getInt8(Layout.getNumArgsByte()),
1194 Builder.CreateStore(Builder.getInt8(Layout.getNumArgsByte()),
1195 Builder.CreateConstByteGEP(BufAddr, Offset++, "numArgs"));
1199 Builder.CreateStore(
1200 Builder.getInt8(Item.getDescriptorByte()),
1201 Builder.CreateConstByteGEP(BufAddr, Offset++, "argDescriptor"));
1202 Builder.CreateStore(
1203 Builder.getInt8(Item.getSizeByte()),
1204 Builder.CreateConstByteGEP(BufAddr, Offset++, "argSize"));
1211 Address Addr = Builder.CreateConstByteGEP(BufAddr, Offset, "argData");
1212 Addr = Builder.CreateBitCast(Addr, Arg.getPointer()->getType(),
1214 Builder.CreateStore(Builder.CreateLoad(Arg), Addr);
1214 Builder.CreateStore(Builder.CreateLoad(Arg), Addr);
1262 ArgVal = Builder.getInt32(Item.getConstValue().getQuantity());
1269 ArgVal = Builder.CreateBitOrPointerCast(ArgVal, IntTy);
1272 ArgVal = Builder.CreateZExtOrBitCast(ArgVal, ConvertType(ArgTy));
1328 Signed = CGF.Builder.CreateSExt(Signed, Unsigned->getType(), "op.sext");
1330 Unsigned = CGF.Builder.CreateZExt(Unsigned, Signed->getType(), "op.zext");
1339 llvm::Value *IsNegative = CGF.Builder.CreateICmpSLT(Signed, Zero);
1340 llvm::Value *AbsOfNegative = CGF.Builder.CreateSub(Zero, Signed);
1342 CGF.Builder.CreateSelect(IsNegative, AbsOfNegative, Signed);
1357 CGF.Builder.CreateAdd(llvm::ConstantInt::get(OpTy, IntMax),
1358 CGF.Builder.CreateZExt(IsNegative, OpTy));
1360 CGF.Builder.CreateICmpUGT(UnsignedResult, MaxResult);
1361 Overflow = CGF.Builder.CreateOr(UnsignedOverflow, SignedOverflow);
1364 llvm::Value *NegativeResult = CGF.Builder.CreateNeg(UnsignedResult);
1366 CGF.Builder.CreateSelect(IsNegative, NegativeResult, UnsignedResult);
1367 Result = CGF.Builder.CreateTrunc(SignedResult, ResTy);
1370 llvm::Value *Underflow = CGF.Builder.CreateAnd(
1371 IsNegative, CGF.Builder.CreateIsNotNull(UnsignedResult));
1372 Overflow = CGF.Builder.CreateOr(UnsignedOverflow, Underflow);
1376 llvm::Value *TruncOverflow = CGF.Builder.CreateICmpUGT(
1378 Overflow = CGF.Builder.CreateOr(Overflow, TruncOverflow);
1382 Result = CGF.Builder.CreateSelect(
1383 IsNegative, CGF.Builder.CreateNeg(UnsignedResult), UnsignedResult);
1385 Result = CGF.Builder.CreateTrunc(Result, ResTy);
1391 CGF.Builder.CreateStore(CGF.EmitToMemory(Result, ResultQTy), ResultPtr,
1404 CGF.Builder.CreateGlobalStringPtr(RType.getAsString() + " {\n");
1405 Value *Res = CGF.Builder.CreateCall(Func, {GString});
1432 FieldPtr = CGF.Builder.CreatePointerCast(
1435 FieldPtr = CGF.Builder.CreateStructGEP(CGF.ConvertType(RType), FieldPtr,
1438 GString = CGF.Builder.CreateGlobalStringPtr(
1445 Value *TmpRes = CGF.Builder.CreateCall(Func, {GString});
1446 Res = CGF.Builder.CreateAdd(Res, TmpRes);
1455 Res = CGF.Builder.CreateAdd(TmpRes, Res);
1465 FieldPtr = CGF.Builder.CreateLoad(FieldAddress);
1468 GString = CGF.Builder.CreateGlobalStringPtr(
1470 TmpRes = CGF.Builder.CreateCall(Func, {GString, FieldPtr});
1471 Res = CGF.Builder.CreateAdd(Res, TmpRes);
1474 GString = CGF.Builder.CreateGlobalStringPtr(Pad + "}\n");
1475 Value *TmpRes = CGF.Builder.CreateCall(Func, {GString});
1476 Res = CGF.Builder.CreateAdd(Res, TmpRes);
1523 ShiftAmt = Builder.CreateIntCast(ShiftAmt, Ty, false);
1528 return RValue::get(Builder.CreateCall(F, { Src, Src, ShiftAmt }));
1657 return RValue::get(Builder.CreateFRem(Arg1, Arg2, "fmod"));
1806 DstPtr = Builder.CreateBitCast(DstPtr, Type);
1807 SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
1808 return RValue::get(Builder.CreateCall(CGM.getIntrinsic(Intrinsic::vacopy),
1817 Value *NegOp = Builder.CreateNSWNeg(ArgValue, "neg");
1819 Value *CmpResult = Builder.CreateICmpSLT(ArgValue, Zero, "abscond");
1820 Value *Result = Builder.CreateSelect(CmpResult, NegOp, ArgValue, "abs");
1834 Imag = Builder.CreateFSub(Zero, Imag, "sub");
1906 Value *IsNeg = Builder.CreateICmpSLT(ArgValue, Zero, "isneg");
1907 Value *Inverse = Builder.CreateNot(ArgValue, "not");
1908 Value *Tmp = Builder.CreateSelect(IsNeg, Inverse, ArgValue);
1909 Value *Ctlz = Builder.CreateCall(F, {Tmp, Builder.getFalse()});
1909 Value *Ctlz = Builder.CreateCall(F, {Tmp, Builder.getFalse()});
1910 Value *Result = Builder.CreateSub(Ctlz, llvm::ConstantInt::get(ArgType, 1));
1911 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
1925 Value *ZeroUndef = Builder.getInt1(getTarget().isCLZForZeroUndef());
1926 Value *Result = Builder.CreateCall(F, {ArgValue, ZeroUndef});
1928 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
1942 Value *ZeroUndef = Builder.getInt1(getTarget().isCLZForZeroUndef());
1943 Value *Result = Builder.CreateCall(F, {ArgValue, ZeroUndef});
1945 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
1960 Builder.CreateAdd(Builder.CreateCall(F, {ArgValue, Builder.getTrue()}),
1960 Builder.CreateAdd(Builder.CreateCall(F, {ArgValue, Builder.getTrue()}),
1960 Builder.CreateAdd(Builder.CreateCall(F, {ArgValue, Builder.getTrue()}),
1963 Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
1964 Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
1966 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
1980 Value *Tmp = Builder.CreateCall(F, ArgValue);
1981 Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1));
1983 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
1996 Value *Result = Builder.CreateCall(F, {ArgValue, Builder.getFalse()});
1996 Value *Result = Builder.CreateCall(F, {ArgValue, Builder.getFalse()});
1998 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
2014 Value *Result = Builder.CreateCall(F, ArgValue);
2016 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
2039 Builder.CreateCall(FnExpect, {ArgValue, ExpectedValue}, "expval");
2066 return RValue::get(Builder.CreateCall(FnAssume, ArgValue));
2124 ArgValue = Builder.CreateBitCast(ArgValue, ConvertType(ArgType));
2128 Value *Result = Builder.CreateCall(F, ArgValue);
2130 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/false);
2154 return RValue::get(Builder.CreateCall(F, {Address, RW, Locality, Data}));
2158 return RValue::get(Builder.CreateCall(F));
2164 return RValue::get(Builder.CreateCall(F, {Begin, End}));
2186 return RValue::get(Builder.CreateCall(F, {Base, Exponent}));
2203 LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
2206 LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
2209 LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
2212 LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
2215 LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
2218 LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
2222 return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType())));
2226 V = Builder.CreateFCmpUNO(V, V, "cmp");
2227 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
2247 Value *FCmp = Builder.CreateFCmp(Pred, Fabs, Infinity, "cmpinf");
2248 return RValue::get(Builder.CreateZExt(FCmp, ConvertType(E->getType())));
2255 Value *IsInf = Builder.CreateFCmpOEQ(
2263 Value *SignResult = Builder.CreateSelect(IsNeg, NegativeOne, One);
2264 Value *Result = Builder.CreateSelect(IsInf, SignResult, Zero);
2271 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
2275 Builder.CreateFCmpULT(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
2279 Builder.CreateFCmpUGE(Abs, ConstantFP::get(V->getContext(), Smallest),
2281 V = Builder.CreateAnd(Eq, IsLessThanInf, "and");
2282 V = Builder.CreateAnd(V, IsNormal, "and");
2283 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
2290 Value *Result = Builder.CreateCall(F);
2292 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
2302 BasicBlock *Begin = Builder.GetInsertBlock();
2304 Builder.SetInsertPoint(End);
2306 Builder.CreatePHI(ConvertType(E->getArg(0)->getType()), 4,
2310 Builder.SetInsertPoint(Begin);
2311 Value *IsZero = Builder.CreateFCmpOEQ(V, Constant::getNullValue(Ty),
2315 Builder.CreateCondBr(IsZero, End, NotZero);
2319 Builder.SetInsertPoint(NotZero);
2320 Value *IsNan = Builder.CreateFCmpUNO(V, V, "cmp");
2323 Builder.CreateCondBr(IsNan, End, NotNan);
2327 Builder.SetInsertPoint(NotNan);
2330 Builder.CreateFCmpOEQ(VAbs, ConstantFP::getInfinity(V->getType()),
2334 Builder.CreateCondBr(IsInf, End, NotInf);
2338 Builder.SetInsertPoint(NotInf);
2342 Builder.CreateFCmpUGE(VAbs, ConstantFP::get(V->getContext(), Smallest),
2345 Builder.CreateSelect(IsNormal, EmitScalarExpr(E->getArg(2)),
2347 Builder.CreateBr(End);
2351 Builder.SetInsertPoint(End);
2365 AllocaInst *AI = Builder.CreateAlloca(Builder.getInt8Ty(), Size);
2365 AllocaInst *AI = Builder.CreateAlloca(Builder.getInt8Ty(), Size);
2378 AllocaInst *AI = Builder.CreateAlloca(Builder.getInt8Ty(), Size);
2378 AllocaInst *AI = Builder.CreateAlloca(Builder.getInt8Ty(), Size);
2390 Builder.CreateMemSet(Dest, Builder.getInt8(0), SizeVal, false);
2390 Builder.CreateMemSet(Dest, Builder.getInt8(0), SizeVal, false);
2402 Builder.CreateMemCpy(Dest, Src, SizeVal, false);
2422 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
2423 Builder.CreateMemCpy(Dest, Src, SizeVal, false);
2448 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
2449 Builder.CreateMemMove(Dest, Src, SizeVal, false);
2462 Builder.CreateMemMove(Dest, Src, SizeVal, false);
2468 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
2469 Builder.getInt8Ty());
2473 Builder.CreateMemSet(Dest, ByteVal, SizeVal, false);
2487 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
2488 Builder.getInt8Ty());
2489 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
2490 Builder.CreateMemSet(Dest, ByteVal, SizeVal, false);
2505 BasicBlock *Entry = Builder.GetInsertBlock();
2510 Value *SizeEq0 = Builder.CreateICmpEQ(Size, ConstantInt::get(SizeTy, 0));
2511 Builder.CreateCondBr(SizeEq0, Exit, CmpGT);
2514 PHINode *DstPhi = Builder.CreatePHI(Dst->getType(), 2);
2516 PHINode *SrcPhi = Builder.CreatePHI(Src->getType(), 2);
2518 PHINode *SizePhi = Builder.CreatePHI(SizeTy, 2);
2522 Value *DstCh = Builder.CreateAlignedLoad(WCharTy, DstPhi, WCharAlign);
2523 Value *SrcCh = Builder.CreateAlignedLoad(WCharTy, SrcPhi, WCharAlign);
2524 Value *DstGtSrc = Builder.CreateICmpUGT(DstCh, SrcCh);
2525 Builder.CreateCondBr(DstGtSrc, Exit, CmpLT);
2528 Value *DstLtSrc = Builder.CreateICmpULT(DstCh, SrcCh);
2529 Builder.CreateCondBr(DstLtSrc, Exit, Next);
2532 Value *NextDst = Builder.CreateConstInBoundsGEP1_32(WCharTy, DstPhi, 1);
2533 Value *NextSrc = Builder.CreateConstInBoundsGEP1_32(WCharTy, SrcPhi, 1);
2534 Value *NextSize = Builder.CreateSub(SizePhi, ConstantInt::get(SizeTy, 1));
2536 Builder.CreateICmpEQ(NextSize, ConstantInt::get(SizeTy, 0));
2537 Builder.CreateCondBr(NextSizeEq0, Exit, CmpGT);
2543 PHINode *Ret = Builder.CreatePHI(IntTy, 4);
2562 return RValue::get(Builder.CreateCall(F,
2569 return RValue::get(Builder.CreateCall(F, Depth));
2573 return RValue::get(Builder.CreateCall(F, Builder.getInt32(0)));
2573 return RValue::get(Builder.CreateCall(F, Builder.getInt32(0)));
2579 return RValue::get(Builder.CreateCall(F, Depth));
2617 Builder.CreateCall(F, {Int, Ptr});
2618 Builder.CreateUnreachable();
2627 return RValue::get(Builder.CreateCall(F));
2642 Value *Result = Builder.CreatePtrToInt(Ptr, IntPtrTy, "extend.cast");
2650 return RValue::get(Builder.CreateSExt(Result, Int64Ty, "extend.sext"));
2652 return RValue::get(Builder.CreateZExt(Result, Int64Ty, "extend.zext"));
2659 Value *FrameAddr = Builder.CreateCall(
2662 Builder.CreateStore(FrameAddr, Buf);
2666 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::stacksave));
2667 Address StackSaveSlot = Builder.CreateConstInBoundsGEP(Buf, 2);
2668 Builder.CreateStore(StackAddr, StackSaveSlot);
2672 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
2673 return RValue::get(Builder.CreateCall(F, Buf.getPointer()));
2677 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
2680 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::eh_sjlj_longjmp), Buf);
2683 Builder.CreateUnreachable();
2695 Ptr = Builder.CreateLaunderInvariantGroup(Ptr);
2845 Ptr = Builder.CreateBitCast(Ptr, ITy->getPointerTo());
2847 Builder.CreateAlignedStore(llvm::Constant::getNullValue(ITy), Ptr,
2861 Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent);
2901 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
2902 Value *NewVal = Builder.getInt8(1);
2910 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg, Ptr, NewVal,
2915 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg, Ptr, NewVal,
2919 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg, Ptr, NewVal,
2924 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg, Ptr, NewVal,
2928 Result = Builder.CreateAtomicRMW(
2934 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
2951 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
2951 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
2952 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
2954 Builder.SetInsertPoint(ContBB);
2955 PHINode *Result = Builder.CreatePHI(Int8Ty, 5, "was_set");
2958 Builder.SetInsertPoint(BBs[i]);
2959 AtomicRMWInst *RMW = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
2963 Builder.CreateBr(ContBB);
2966 SI->addCase(Builder.getInt32(0), BBs[0]);
2967 SI->addCase(Builder.getInt32(1), BBs[1]);
2968 SI->addCase(Builder.getInt32(2), BBs[1]);
2969 SI->addCase(Builder.getInt32(3), BBs[2]);
2970 SI->addCase(Builder.getInt32(4), BBs[3]);
2971 SI->addCase(Builder.getInt32(5), BBs[4]);
2973 Builder.SetInsertPoint(ContBB);
2974 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
2984 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
2985 Value *NewVal = Builder.getInt8(0);
2989 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
3016 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
3016 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
3017 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
3020 Builder.SetInsertPoint(BBs[i]);
3021 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
3023 Builder.CreateBr(ContBB);
3026 SI->addCase(Builder.getInt32(0), BBs[0]);
3027 SI->addCase(Builder.getInt32(3), BBs[1]);
3028 SI->addCase(Builder.getInt32(5), BBs[2]);
3030 Builder.SetInsertPoint(ContBB);
3053 Builder.CreateFence(llvm::AtomicOrdering::Acquire, SSID);
3056 Builder.CreateFence(llvm::AtomicOrdering::Release, SSID);
3059 Builder.CreateFence(llvm::AtomicOrdering::AcquireRelease, SSID);
3062 Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent, SSID);
3075 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
3075 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
3076 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, ContBB);
3078 Builder.SetInsertPoint(AcquireBB);
3079 Builder.CreateFence(llvm::AtomicOrdering::Acquire, SSID);
3080 Builder.CreateBr(ContBB);
3081 SI->addCase(Builder.getInt32(1), AcquireBB);
3082 SI->addCase(Builder.getInt32(2), AcquireBB);
3084 Builder.SetInsertPoint(ReleaseBB);
3085 Builder.CreateFence(llvm::AtomicOrdering::Release, SSID);
3086 Builder.CreateBr(ContBB);
3087 SI->addCase(Builder.getInt32(3), ReleaseBB);
3089 Builder.SetInsertPoint(AcqRelBB);
3090 Builder.CreateFence(llvm::AtomicOrdering::AcquireRelease, SSID);
3091 Builder.CreateBr(ContBB);
3092 SI->addCase(Builder.getInt32(4), AcqRelBB);
3094 Builder.SetInsertPoint(SeqCstBB);
3095 Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent, SSID);
3096 Builder.CreateBr(ContBB);
3097 SI->addCase(Builder.getInt32(5), SeqCstBB);
3099 Builder.SetInsertPoint(ContBB);
3107 Builder.CreateZExt(EmitSignBit(*this, EmitScalarExpr(E->getArg(0))),
3130 Builder.CreateCall(F, MetadataAsValue::get(getLLVMContext(), StrTuple));
3205 llvm::Value *CarryOut = Builder.CreateZExt(Builder.CreateOr(Carry1, Carry2),
3205 llvm::Value *CarryOut = Builder.CreateZExt(Builder.CreateOr(Carry1, Carry2),
3207 Builder.CreateStore(CarryOut, CarryOutPtr);
3269 Left = Builder.CreateIntCast(Left, EncompassingLLVMTy, LeftInfo.Signed);
3270 Right = Builder.CreateIntCast(Right, EncompassingLLVMTy, RightInfo.Signed);
3279 llvm::Value *ResultTrunc = Builder.CreateTrunc(Result, ResultLLVMTy);
3283 llvm::Value *ResultTruncExt = Builder.CreateIntCast(
3286 Builder.CreateICmpNE(Result, ResultTruncExt);
3288 Overflow = Builder.CreateOr(Overflow, TruncationOverflow);
3295 Builder.CreateStore(EmitToMemory(Result, ResultQTy), ResultPtr, isVolatile);
3365 Builder.CreateStore(Sum, SumOutPtr);
3403 Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), IntPtrType);
3407 Exchange = Builder.CreatePtrToInt(Exchange, IntType);
3410 Builder.CreatePtrToInt(EmitScalarExpr(E->getArg(2)), IntType);
3416 auto Result = Builder.CreateAtomicCmpXchg(Destination, Comparand, Exchange,
3420 return RValue::get(Builder.CreateIntToPtr(Builder.CreateExtractValue(Result,
3420 return RValue::get(Builder.CreateIntToPtr(Builder.CreateExtractValue(Result,
3529 auto T = Builder.getIntNTy(Context.getTypeSize(SizeTy));
3531 return RValue::get(Builder.CreateCall(F));
3585 Value *BCast = Builder.CreatePointerCast(Arg1, I8PTy);
3587 Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3601 Value *BCast = Builder.CreatePointerCast(Arg3, I8PTy);
3605 Arg2 = Builder.CreateZExtOrTrunc(Arg2, Int32Ty);
3606 return RValue::get(Builder.CreateCall(
3648 Arg1 = Builder.CreateZExtOrTrunc(Arg1, Int32Ty);
3650 Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3688 Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3712 return RValue::get(Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3730 NewArg = Builder.CreateAddrSpaceCast(Arg0, NewArgT);
3732 NewArg = Builder.CreateBitOrPointerCast(Arg0, NewArgT);
3735 Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, NewName), {NewArg});
3736 return RValue::get(Builder.CreateBitOrPointerCast(NewCall,
3747 llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
3768 Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
3770 Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
3778 Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name, ByValAttrSet),
3803 auto *GEP = Builder.CreateGEP(TmpPtr, {Zero, Index});
3807 Builder.CreateZExtOrTrunc(EmitScalarExpr(E->getArg(I)), SizeTy);
3808 Builder.CreateAlignedStore(
3821 Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
3822 auto *Block = Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
3839 RValue::get(Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3852 Builder.CreateZExtOrTrunc(EmitScalarExpr(E->getArg(3)), Int32Ty);
3866 EventWaitList = Builder.CreatePointerCast(EventWaitList, EventPtrTy);
3874 Builder.CreatePointerCast(EmitScalarExpr(E->getArg(5)), EventPtrTy);
3880 Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
3882 Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
3898 Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3915 RValue::get(Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
3926 llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
3930 Value *Kernel = Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
3931 Value *Arg = Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
3932 return RValue::get(Builder.CreateCall(
3940 llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
3944 Value *Kernel = Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
3945 Value *Arg = Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
3946 return RValue::get(Builder.CreateCall(
3955 llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
3961 Value *Kernel = Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
3962 Value *Block = Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
3967 return RValue::get(Builder.CreateCall(
3980 Value *HalfVal = Builder.CreateFPTrunc(Val, Builder.getHalfTy());
3980 Value *HalfVal = Builder.CreateFPTrunc(Val, Builder.getHalfTy());
3981 return RValue::get(Builder.CreateStore(HalfVal, Address));
3985 Value *HalfVal = Builder.CreateLoad(Address);
3986 return RValue::get(Builder.CreateFPExt(HalfVal, Builder.getDoubleTy()));
3986 return RValue::get(Builder.CreateFPExt(HalfVal, Builder.getDoubleTy()));
3990 Value *HalfVal = Builder.CreateLoad(Address);
3991 return RValue::get(Builder.CreateFPExt(HalfVal, Builder.getFloatTy()));
3991 return RValue::get(Builder.CreateFPExt(HalfVal, Builder.getFloatTy()));
4034 Arg0Val = Builder.CreatePointerCast(Arg0Val, PTy0);
4039 Arg1 = Builder.CreateTruncOrBitCast(Arg1, PTy1);
4040 return RValue::get(Builder.CreateCall(F, {Arg0Val, Arg1}));
4063 Arg0 = Builder.CreateTruncOrBitCast(Arg0, PTy0);
4072 Arg1Val = Builder.CreatePointerCast(Arg1Val, PTy1);
4077 Arg2 = Builder.CreateTruncOrBitCast(Arg2, PTy2);
4078 return RValue::get(Builder.CreateCall(F, {Arg0, Arg1Val, Arg2}));
4099 DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), BPP, "cp"),
4101 SrcAddr = Address(Builder.CreateBitCast(SrcAddr.getPointer(), BPP, "ap"),
4104 Value *ArgPtr = Builder.CreateLoad(SrcAddr, "ap.val");
4105 return RValue::get(Builder.CreateStore(ArgPtr, DestAddr));
4182 ArgValue = Builder.CreateAddrSpaceCast(
4190 ArgValue = Builder.CreateBitCast(ArgValue, PTy);
4196 Value *V = Builder.CreateCall(F, Args);
4207 V = Builder.CreateAddrSpaceCast(
4214 V = Builder.CreateBitCast(V, RetTy);
4338 return Builder.CreateShuffleVector(V, V, SV, "lane");
4350 Ops[j] = Builder.CreateBitCast(Ops[j], ai->getType(), name);
4352 return Builder.CreateCall(F, Ops, name);
4370 Vec = Builder.CreateBitCast(Vec, Ty);
4388 return Builder.CreateLShr(Vec, Shift, name);
4390 return Builder.CreateAShr(Vec, Shift, name);
5221 CGF.Builder.CreateTruncOrBitCast(Ops[j], ArgTy->getVectorElementType());
5223 CGF.Builder.CreateInsertElement(UndefValue::get(ArgTy), Ops[j], C0);
5230 return CGF.Builder.CreateExtractElement(Result, C0);
5232 return CGF.Builder.CreateBitCast(Result, ResultType, s);
5258 return Builder.getInt32(addr.getAlignment().getQuantity());
5284 Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
5285 Ops[1] = Builder.CreateBitCast(Ops[1], SrcTy);
5286 Ops[0] = Builder.CreateAdd(Ops[0], Ops[1], "vaddhn");
5291 Ops[0] = Builder.CreateLShr(Ops[0], ShiftAmt, "vaddhn");
5294 return Builder.CreateTrunc(Ops[0], VTy, "vaddhn");
5348 Ops.push_back(Builder.getInt1(getTarget().isCLZForZeroUndef()));
5352 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5355 return Usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
5356 : Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
5359 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5362 return Usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
5363 : Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
5403 Ops[0] = Builder.CreateBitCast(Ops[0], GetFloatNeonType(this, Type));
5404 return Usgn ? Builder.CreateFPToUI(Ops[0], Ty, "vcvt")
5405 : Builder.CreateFPToSI(Ops[0], Ty, "vcvt");
5465 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5466 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5467 return Builder.CreateShuffleVector(Ops[0], Ops[1], Indices, "vext");
5472 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5473 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5474 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
5477 return Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0]});
5492 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
5495 Ops[1] = Builder.CreateCall(F, Ops[1], "vld1xN");
5497 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5498 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5515 Ops[1] = Builder.CreateCall(F, {Ops[1], Align}, NameHint);
5517 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5518 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5524 PtrOp0 = Builder.CreateBitCast(PtrOp0, Ty);
5525 LoadInst *Ld = Builder.CreateLoad(PtrOp0);
5527 Ops[0] = Builder.CreateInsertElement(V, Ld, CI);
5539 Ops[I] = Builder.CreateBitCast(Ops[I], Ty);
5541 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), NameHint);
5543 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5544 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5548 Ops[0] = Builder.CreateBitCast(Ops[0], DTy);
5550 return Builder.CreateZExt(Ops[0], Ty, "vmovl");
5551 return Builder.CreateSExt(Ops[0], Ty, "vmovl");
5555 Ops[0] = Builder.CreateBitCast(Ops[0], QTy);
5556 return Builder.CreateTrunc(Ops[0], Ty, "vmovn");
5621 return Builder.CreateShl(Builder.CreateBitCast(Ops[0],Ty), Ops[1],
5621 return Builder.CreateShl(Builder.CreateBitCast(Ops[0],Ty), Ops[1],
5625 Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
5627 Ops[0] = Builder.CreateZExt(Ops[0], VTy);
5629 Ops[0] = Builder.CreateSExt(Ops[0], VTy);
5631 return Builder.CreateShl(Ops[0], Ops[1], "vshll_n");
5635 Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
5638 Ops[0] = Builder.CreateLShr(Ops[0], Ops[1]);
5640 Ops[0] = Builder.CreateAShr(Ops[0], Ops[1]);
5641 return Builder.CreateTrunc(Ops[0], Ty, "vshrn_n");
5686 Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
5687 Ops[1] = Builder.CreateBitCast(Ops[1], SrcTy);
5688 Ops[0] = Builder.CreateSub(Ops[0], Ops[1], "vsubhn");
5693 Ops[0] = Builder.CreateLShr(Ops[0], ShiftAmt, "vsubhn");
5696 return Builder.CreateTrunc(Ops[0], VTy, "vsubhn");
5700 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
5701 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5702 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
5711 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
5712 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vtrn");
5713 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
5719 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5720 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5721 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
5722 Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
5724 return Builder.CreateSExt(Ops[0], Ty, "vtst");
5728 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
5729 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5730 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
5738 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
5739 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vuzp");
5740 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
5746 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
5747 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5748 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
5757 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
5758 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vzip");
5759 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
5810 return Builder.CreateBitCast(Result, ResultType, NameHint);
5825 Op = Builder.CreateBitCast(Op, OTy);
5827 Op = Builder.CreateFCmp(Fp, Op, Constant::getNullValue(OTy));
5829 Op = Builder.CreateICmp(Ip, Op, Constant::getNullValue(OTy));
5831 return Builder.CreateSExt(Op, Ty, Name);
5852 TblOps.push_back(CGF.Builder.CreateShuffleVector(Ops[PairPos],
5862 TblOps.push_back(CGF.Builder.CreateShuffleVector(Ops[PairPos],
5903 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_hint),
5920 CodeGen::CGBuilderTy &Builder = CGF.Builder;
6032 return Builder.CreateCall(Emit);
6037 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_dbg), Option);
6049 return Builder.CreateCall(F, {Address, RW, Locality, IsData});
6054 return Builder.CreateCall(
6060 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_cls), Arg, "cls");
6064 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_cls64), Arg,
6107 Value *Rt = Builder.CreateTruncOrBitCast(RtAndRt2, Int32Ty);
6108 Value *Rt2 = Builder.CreateLShr(RtAndRt2, C1);
6109 Rt2 = Builder.CreateTruncOrBitCast(Rt2, Int32Ty);
6111 return Builder.CreateCall(F, {Coproc, Opc1, Rt, Rt2, CRm});
6131 Value *RtAndRt2 = Builder.CreateCall(F, {Coproc, Opc1, CRm});
6136 Value *Rt = Builder.CreateExtractValue(RtAndRt2, 1);
6137 Value *Rt1 = Builder.CreateExtractValue(RtAndRt2, 0);
6138 Rt = Builder.CreateZExt(Rt, Int64Ty);
6139 Rt1 = Builder.CreateZExt(Rt1, Int64Ty);
6142 RtAndRt2 = Builder.CreateShl(Rt, ShiftCast, "shl", true);
6143 RtAndRt2 = Builder.CreateOr(RtAndRt2, Rt1);
6145 return Builder.CreateBitCast(RtAndRt2, ConvertType(E->getType()));
6168 Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
6168 Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
6171 Value *Val0 = Builder.CreateExtractValue(Val, 1);
6172 Value *Val1 = Builder.CreateExtractValue(Val, 0);
6173 Val0 = Builder.CreateZExt(Val0, Int64Ty);
6174 Val1 = Builder.CreateZExt(Val1, Int64Ty);
6177 Val = Builder.CreateShl(Val0, ShiftCst, "shl", true /* nuw */);
6178 Val = Builder.CreateOr(Val, Val1);
6179 return Builder.CreateBitCast(Val, ConvertType(E->getType()));
6190 LoadAddr = Builder.CreateBitCast(LoadAddr, PtrTy);
6196 Value *Val = Builder.CreateCall(F, LoadAddr, "ldrex");
6199 return Builder.CreateIntToPtr(Val, RealResTy);
6203 Val = Builder.CreateTruncOrBitCast(Val, IntResTy);
6204 return Builder.CreateBitCast(Val, RealResTy);
6219 Builder.CreateStore(Val, Tmp);
6221 Address LdPtr = Builder.CreateBitCast(Tmp,llvm::PointerType::getUnqual(STy));
6222 Val = Builder.CreateLoad(LdPtr);
6224 Value *Arg0 = Builder.CreateExtractValue(Val, 0);
6225 Value *Arg1 = Builder.CreateExtractValue(Val, 1);
6226 Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), Int8PtrTy);
6227 return Builder.CreateCall(F, {Arg0, Arg1, StPtr}, "strexd");
6238 StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
6241 StoreVal = Builder.CreatePtrToInt(StoreVal, Int32Ty);
6246 StoreVal = Builder.CreateBitCast(StoreVal, IntTy);
6247 StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int32Ty);
6254 return Builder.CreateCall(F, {StoreVal, StoreAddr}, "strex");
6259 return Builder.CreateCall(F);
6290 Value *Arg1a = Builder.CreateTruncOrBitCast(Arg1, Int32Ty);
6291 Value *Arg1b = Builder.CreateLShr(Arg1, C1);
6292 Arg1b = Builder.CreateTruncOrBitCast(Arg1b, Int32Ty);
6295 Value *Res = Builder.CreateCall(F, {Arg0, Arg1a});
6296 return Builder.CreateCall(F, {Res, Arg1b});
6298 Arg1 = Builder.CreateZExtOrBitCast(Arg1, Int32Ty);
6301 return Builder.CreateCall(F, {Arg0, Arg1});
6348 return Builder.getInt32(addr.getAlignment().getQuantity());
6441 return Builder.CreateExtractElement(Ops[0], Ops[1], "vget_lane");
6447 return Builder.CreateCall(F, {Arg}, "vrndn"); }
6459 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
6480 return Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0],
6644 return Builder.CreateCall(F, Ops, "vcvtr");
6676 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
6679 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
6685 Value *Ld = Builder.CreateCall(F, {Ops[0], Align});
6689 return Builder.CreateShuffleVector(Ops[1], Ld, SV, "vld1q_lane");
6693 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
6694 PtrOp0 = Builder.CreateElementBitCast(PtrOp0, VTy->getElementType());
6695 Value *Ld = Builder.CreateLoad(PtrOp0);
6696 return Builder.CreateInsertElement(Ops[1], Ld, Ops[2], "vld1_lane");
6722 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
6723 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
6726 Ops[1] = Builder.CreateCall(CGM.getIntrinsic(Int, Ty), {Ops[1], Ops[2]});
6727 return Builder.CreateAdd(Ops[0], Ops[1], "vrsra_n");
6739 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
6741 return Builder.CreateAdd(Ops[0], Ops[1]);
6746 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
6748 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
6751 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_neon_vst1,
6756 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
6757 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2]);
6759 auto St = Builder.CreateStore(Ops[1], Builder.CreateBitCast(PtrOp0, Ty));
6759 auto St = Builder.CreateStore(Ops[1], Builder.CreateBitCast(PtrOp0, Ty));
6836 Value *LoadResult = Builder.CreateCall(F, Ops);
6839 Value *Vec = Builder.CreateExtractValue(LoadResult, i);
6840 MvecOut = Builder.CreateInsertValue(MvecOut, Vec, {0, i});
6846 return Builder.CreateStore(MvecOut, ReturnValue.getValue());
6873 auto Mvec = Builder.CreateLoad(MvecSlot.getAddress());
6875 Ops.push_back(Builder.CreateExtractValue(Mvec, {0, i}));
6881 ToReturn = Builder.CreateCall(F, Ops);
6942 CodeGen::CGBuilderTy &Builder = CGF.Builder;
7040 Op = Builder.CreateBitCast(Op, Int16Ty);
7043 Op = Builder.CreateInsertElement(V, Op, CI);
7080 return Builder.CreateCall(F, llvm::ConstantInt::get(Int32Ty, HintID));
7103 return Builder.CreateCall(F, {Address, RW, Locality, IsData});
7110 return Builder.CreateCall(
7117 return Builder.CreateCall(
7123 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::aarch64_cls), Arg,
7128 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::aarch64_cls64), Arg,
7136 return Builder.CreateCall(
7160 Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
7160 Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
7163 Value *Val0 = Builder.CreateExtractValue(Val, 1);
7164 Value *Val1 = Builder.CreateExtractValue(Val, 0);
7166 Val0 = Builder.CreateZExt(Val0, Int128Ty);
7167 Val1 = Builder.CreateZExt(Val1, Int128Ty);
7170 Val = Builder.CreateShl(Val0, ShiftCst, "shl", true /* nuw */);
7171 Val = Builder.CreateOr(Val, Val1);
7172 return Builder.CreateBitCast(Val, ConvertType(E->getType()));
7181 LoadAddr = Builder.CreateBitCast(LoadAddr, PtrTy);
7187 Value *Val = Builder.CreateCall(F, LoadAddr, "ldxr");
7190 return Builder.CreateIntToPtr(Val, RealResTy);
7194 Val = Builder.CreateTruncOrBitCast(Val, IntResTy);
7195 return Builder.CreateBitCast(Val, RealResTy);
7209 Tmp = Builder.CreateBitCast(Tmp, llvm::PointerType::getUnqual(STy));
7210 llvm::Value *Val = Builder.CreateLoad(Tmp);
7212 Value *Arg0 = Builder.CreateExtractValue(Val, 0);
7213 Value *Arg1 = Builder.CreateExtractValue(Val, 1);
7214 Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)),
7216 return Builder.CreateCall(F, {Arg0, Arg1, StPtr}, "stxp");
7227 StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
7230 StoreVal = Builder.CreatePtrToInt(StoreVal, Int64Ty);
7235 StoreVal = Builder.CreateBitCast(StoreVal, IntTy);
7236 StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int64Ty);
7243 return Builder.CreateCall(F, {StoreVal, StoreAddr}, "stxr");
7261 return Builder.CreateCall(F, Metadata);
7266 return Builder.CreateCall(F);
7270 return Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent,
7300 Arg1 = Builder.CreateZExtOrBitCast(Arg1, DataTy);
7302 return Builder.CreateCall(F, {Arg0, Arg1});
7329 Pointer = Builder.CreatePointerCast(Pointer, Int8PtrTy);
7330 Mask = Builder.CreateZExt(Mask, Int64Ty);
7331 Value *RV = Builder.CreateCall(
7333 return Builder.CreatePointerCast(RV, T);
7339 Pointer = Builder.CreatePointerCast(Pointer, Int8PtrTy);
7340 TagOffset = Builder.CreateZExt(TagOffset, Int64Ty);
7341 Value *RV = Builder.CreateCall(
7343 return Builder.CreatePointerCast(RV, T);
7349 ExcludedMask = Builder.CreateZExt(ExcludedMask, Int64Ty);
7350 Pointer = Builder.CreatePointerCast(Pointer, Int8PtrTy);
7351 return Builder.CreateCall(
7359 TagAddress = Builder.CreatePointerCast(TagAddress, Int8PtrTy);
7360 Value *RV = Builder.CreateCall(
7362 return Builder.CreatePointerCast(RV, T);
7369 TagAddress = Builder.CreatePointerCast(TagAddress, Int8PtrTy);
7370 return Builder.CreateCall(
7376 PointerA = Builder.CreatePointerCast(PointerA, Int8PtrTy);
7377 PointerB = Builder.CreatePointerCast(PointerB, Int8PtrTy);
7378 return Builder.CreateCall(
7438 return Builder.CreateCall(F, Metadata);
7444 return Builder.CreateCall(F, { Metadata, ArgValue });
7450 return Builder.CreateCall(F);
7455 return Builder.CreateCall(F);
7510 Value *Ptr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), Int128PTy);
7511 return Builder.CreateAlignedLoad(Int128Ty, Ptr,
7516 Value *Ptr = Builder.CreateBitCast(Ops[0], Int128PTy);
7517 return Builder.CreateDefaultAlignedStore(EmitScalarExpr(E->getArg(1)), Ptr);
7529 Ops[0] = Builder.CreateBitCast(Ops[0], FTy);
7531 return Builder.CreateFPToUI(Ops[0], InTy);
7532 return Builder.CreateFPToSI(Ops[0], InTy);
7544 Ops[0] = Builder.CreateBitCast(Ops[0], InTy);
7546 return Builder.CreateUIToFP(Ops[0], FTy);
7547 return Builder.CreateSIToFP(Ops[0], FTy);
7566 Ops[0] = Builder.CreateBitCast(Ops[0], InTy);
7568 return Builder.CreateUIToFP(Ops[0], FTy);
7569 return Builder.CreateSIToFP(Ops[0], FTy);
7576 Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
7578 return Builder.CreateFPToUI(Ops[0], Int16Ty);
7579 return Builder.CreateFPToSI(Ops[0], Int16Ty);
7586 Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
7588 return Builder.CreateFPToUI(Ops[0], Int32Ty);
7589 return Builder.CreateFPToSI(Ops[0], Int32Ty);
7596 Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
7598 return Builder.CreateFPToUI(Ops[0], Int64Ty);
7599 return Builder.CreateFPToSI(Ops[0], Int64Ty);
7634 return Builder.CreateTrunc(Ops[0], Int16Ty);
7657 return Builder.CreateTrunc(Ops[0], Int16Ty);
7674 return Builder.CreateTrunc(Ops[0], Int16Ty);
7687 Ops[0] = Builder.CreateSExt(Ops[0], InTy, "sext");
7691 Ops[0] = Builder.CreateZExt(Ops[0], InTy);
7700 Vec = Builder.CreateBitCast(Vec, Ty, "v2i64");
7703 Value *Op0 = Builder.CreateExtractElement(Vec, Idx0, "lane0");
7704 Value *Op1 = Builder.CreateExtractElement(Vec, Idx1, "lane1");
7706 return Builder.CreateAdd(Op0, Op1, "vpaddd");
7713 Vec = Builder.CreateBitCast(Vec, Ty, "v2f64");
7716 Value *Op0 = Builder.CreateExtractElement(Vec, Idx0, "lane0");
7717 Value *Op1 = Builder.CreateExtractElement(Vec, Idx1, "lane1");
7719 return Builder.CreateFAdd(Op0, Op1, "vpaddd");
7726 Vec = Builder.CreateBitCast(Vec, Ty, "v2f32");
7729 Value *Op0 = Builder.CreateExtractElement(Vec, Idx0, "lane0");
7730 Value *Op1 = Builder.CreateExtractElement(Vec, Idx1, "lane1");
7732 return Builder.CreateFAdd(Op0, Op1, "vpaddd");
7777 Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
7779 Builder.CreateICmpEQ(Ops[0], llvm::Constant::getNullValue(Int64Ty));
7780 return Builder.CreateSExt(Ops[0], Int64Ty, "vceqzd");
7797 Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
7798 Ops[1] = Builder.CreateBitCast(Ops[1], DoubleTy);
7799 Ops[0] = Builder.CreateFCmp(P, Ops[0], Ops[1]);
7800 return Builder.CreateSExt(Ops[0], Int64Ty, "vcmpd");
7817 Ops[0] = Builder.CreateBitCast(Ops[0], FloatTy);
7818 Ops[1] = Builder.CreateBitCast(Ops[1], FloatTy);
7819 Ops[0] = Builder.CreateFCmp(P, Ops[0], Ops[1]);
7820 return Builder.CreateSExt(Ops[0], Int32Ty, "vcmpd");
7837 Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
7838 Ops[1] = Builder.CreateBitCast(Ops[1], HalfTy);
7839 Ops[0] = Builder.CreateFCmp(P, Ops[0], Ops[1]);
7840 return Builder.CreateSExt(Ops[0], Int16Ty, "vcmpd");
7867 Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
7868 Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
7869 Ops[0] = Builder.CreateICmp(P, Ops[0], Ops[1]);
7870 return Builder.CreateSExt(Ops[0], Int64Ty, "vceqd");
7875 Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
7876 Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
7877 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
7878 Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
7880 return Builder.CreateSExt(Ops[0], Int64Ty, "vtstd");
7893 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
7896 Ops[1] = Builder.CreateBitCast(Ops[1],
7899 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
7902 Ops[1] = Builder.CreateBitCast(Ops[1],
7905 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
7909 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int8Ty, 8));
7910 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7914 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int8Ty, 16));
7915 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7919 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int16Ty, 4));
7920 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7924 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int16Ty, 8));
7925 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7929 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 2));
7930 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7933 Ops[0] = Builder.CreateBitCast(Ops[0],
7935 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7939 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 4));
7940 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7944 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 1));
7945 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7948 Ops[0] = Builder.CreateBitCast(Ops[0],
7950 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7954 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 2));
7955 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7958 Ops[0] = Builder.CreateBitCast(Ops[0],
7960 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7963 Ops[0] = Builder.CreateBitCast(Ops[0],
7965 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7969 Ops[0] = Builder.CreateBitCast(Ops[0],
7971 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7975 Ops[0] = Builder.CreateBitCast(Ops[0],
7977 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
7981 return Builder.CreateFAdd(Ops[0], Ops[1], "vaddh");
7984 return Builder.CreateFSub(Ops[0], Ops[1], "vsubh");
7987 return Builder.CreateFMul(Ops[0], Ops[1], "vmulh");
7990 return Builder.CreateFDiv(Ops[0], Ops[1], "vdivh");
7994 return Builder.CreateCall(F,
8000 Value* Sub = Builder.CreateFSub(Zero, EmitScalarExpr(E->getArg(1)), "vsubh");
8002 return Builder.CreateCall(F, {Sub, EmitScalarExpr(E->getArg(2)), Ops[0]});
8006 return Builder.CreateAdd(Ops[0], EmitScalarExpr(E->getArg(1)), "vaddd");
8009 return Builder.CreateSub(Ops[0], EmitScalarExpr(E->getArg(1)), "vsubd");
8019 Ops[1] = Builder.CreateExtractElement(Ops[1], CI, "lane0");
8028 Ops[1] = Builder.CreateZExt(Ops[1], Int64Ty);
8038 Ops[1] = Builder.CreateZExt(Ops[1], Int64Ty);
8056 Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
8057 Ops.push_back(Builder.CreateNeg(EmitScalarExpr(E->getArg(2))));
8058 Ops[1] = Builder.CreateCall(CGM.getIntrinsic(Int, Int64Ty),
8059 {Ops[1], Builder.CreateSExt(Ops[2], Int64Ty)});
8060 return Builder.CreateAdd(Ops[0], Builder.CreateBitCast(Ops[1], Int64Ty));
8060 return Builder.CreateAdd(Ops[0], Builder.CreateBitCast(Ops[1], Int64Ty));
8065 return Builder.CreateShl(
8070 return Builder.CreateAShr(
8081 return Builder.CreateLShr(Ops[0], ConstantInt::get(Int64Ty, ShiftAmt),
8086 Ops[1] = Builder.CreateAShr(
8090 return Builder.CreateAdd(Ops[0], Ops[1]);
8099 Ops[1] = Builder.CreateLShr(Ops[1], ConstantInt::get(Int64Ty, ShiftAmt),
8101 return Builder.CreateAdd(Ops[0], Ops[1]);
8107 Ops[2] = Builder.CreateExtractElement(Ops[2], EmitScalarExpr(E->getArg(3)),
8116 Ops[1] = Builder.CreateExtractElement(Ops[1], CI, "lane0");
8143 Ops[2] = Builder.CreateExtractElement(Ops[2], EmitScalarExpr(E->getArg(3)),
8160 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
8164 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
8307 AtomicRMWInst *RMWI = Builder.CreateAtomicRMW(
8310 return Builder.CreateAdd(RMWI, Arg1);
8339 Ops[0] = Builder.CreateBitCast(Ops[0], BitTy, "vbsl");
8340 Ops[1] = Builder.CreateBitCast(Ops[1], BitTy, "vbsl");
8341 Ops[2] = Builder.CreateBitCast(Ops[2], BitTy, "vbsl");
8343 Ops[1] = Builder.CreateAnd(Ops[0], Ops[1], "vbsl");
8344 Ops[2] = Builder.CreateAnd(Builder.CreateNot(Ops[0]), Ops[2], "vbsl");
8344 Ops[2] = Builder.CreateAnd(Builder.CreateNot(Ops[0]), Ops[2], "vbsl");
8345 Ops[0] = Builder.CreateOr(Ops[1], Ops[2], "vbsl");
8346 return Builder.CreateBitCast(Ops[0], Ty);
8365 Ops[1] = Builder.CreateBitCast(Ops[1], SourceTy);
8366 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV, "lane");
8376 Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
8377 Ops[1] = Builder.CreateBitCast(Ops[1], DoubleTy);
8380 Ops[2] = Builder.CreateBitCast(Ops[2], VTy);
8381 Ops[2] = Builder.CreateExtractElement(Ops[2], Ops[3], "extract");
8383 Value *Result = Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0]});
8384 return Builder.CreateBitCast(Result, Ty);
8387 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
8388 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
8392 Ops[2] = Builder.CreateBitCast(Ops[2], STy);
8395 Ops[2] = Builder.CreateShuffleVector(Ops[2], Ops[2], SV, "lane");
8397 return Builder.CreateCall(F, {Ops[2], Ops[1], Ops[0]});
8401 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
8402 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
8404 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
8406 return Builder.CreateCall(F, {Ops[2], Ops[1], Ops[0]});
8417 Ops[2] = Builder.CreateExtractElement(Ops[2], Ops[3], "extract");
8418 return Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0]});
8466 llvm::Value *addend = Builder.CreateBitCast(Ops[0], tmp->getType());
8467 return Builder.CreateAdd(tmp, addend);
8597 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
8599 return usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
8600 : Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
8605 Ops[0] = Builder.CreateBitCast(Ops[0], GetNeonType(this, SrcFlag));
8607 return Builder.CreateFPExt(Ops[0], Ty, "vcvt");
8613 Ops[0] = Builder.CreateBitCast(Ops[0], GetNeonType(this, SrcFlag));
8615 return Builder.CreateFPTrunc(Ops[0], Ty, "vcvt");
8629 Ops[0] = Builder.CreateBitCast(Ops[0], GetFloatNeonType(this, Type));
8631 return Builder.CreateFPToUI(Ops[0], Ty);
8632 return Builder.CreateFPToSI(Ops[0], Ty);
8708 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2], "extract");
8719 Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
8722 Ops[1] = Builder.CreateBitCast(Ops[1], VTy);
8723 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2], "extract");
8724 Value *Result = Builder.CreateFMul(Ops[0], Ops[1]);
8725 return Builder.CreateBitCast(Result, Ty);
8728 return Builder.CreateNeg(EmitScalarExpr(E->getArg(0)), "vnegd");
8730 return Builder.CreateFNeg(EmitScalarExpr(E->getArg(0)), "vnegh");
8749 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
8768 return Builder.CreateTrunc(Ops[0], Int8Ty);
8780 return Builder.CreateTrunc(Ops[0], Int16Ty);
8792 return Builder.CreateTrunc(Ops[0], Int8Ty);
8804 return Builder.CreateTrunc(Ops[0], Int16Ty);
8813 return Builder.CreateTrunc(Ops[0], Int8Ty);
8822 return Builder.CreateTrunc(Ops[0], Int16Ty);
8831 return Builder.CreateTrunc(Ops[0], Int8Ty);
8840 return Builder.CreateTrunc(Ops[0], Int16Ty);
8849 return Builder.CreateTrunc(Ops[0], Int8Ty);
8858 return Builder.CreateTrunc(Ops[0], Int16Ty);
8867 return Builder.CreateTrunc(Ops[0], Int8Ty);
8876 return Builder.CreateTrunc(Ops[0], Int16Ty);
8885 return Builder.CreateTrunc(Ops[0], HalfTy);
8894 return Builder.CreateTrunc(Ops[0], HalfTy);
8903 return Builder.CreateTrunc(Ops[0], Int8Ty);
8912 return Builder.CreateTrunc(Ops[0], Int16Ty);
8921 return Builder.CreateTrunc(Ops[0], Int8Ty);
8930 return Builder.CreateTrunc(Ops[0], Int16Ty);
8939 return Builder.CreateTrunc(Ops[0], Int8Ty);
8948 return Builder.CreateTrunc(Ops[0], Int16Ty);
8957 return Builder.CreateTrunc(Ops[0], Int8Ty);
8966 return Builder.CreateTrunc(Ops[0], Int16Ty);
8975 return Builder.CreateTrunc(Ops[0], HalfTy);
8984 return Builder.CreateTrunc(Ops[0], HalfTy);
8993 return Builder.CreateTrunc(Ops[0], HalfTy);
9002 return Builder.CreateTrunc(Ops[0], HalfTy);
9011 return Builder.CreateTrunc(Ops[0], HalfTy);
9020 return Builder.CreateTrunc(Ops[0], HalfTy);
9023 Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
9024 Value *RHS = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), DoubleTy);
9025 return Builder.CreateFMul(Ops[0], RHS);
9034 return Builder.CreateTrunc(Ops[0], Int16Ty);
9051 return Builder.CreateTrunc(Ops[0], Int16Ty);
9068 return Builder.CreateTrunc(Ops[0], Int16Ty);
9085 return Builder.CreateTrunc(Ops[0], Int16Ty);
9109 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
9111 return Builder.CreateAdd(Ops[0], Ops[1]);
9120 Ops[0] = Builder.CreateBitCast(Ops[0], VTy);
9121 return Builder.CreateAdd(Ops[0], tmp);
9125 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
9128 return Builder.CreateAlignedLoad(VTy, Ops[0], Alignment);
9132 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
9133 Ops[1] = Builder.CreateBitCast(Ops[1], VTy);
9134 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9137 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
9139 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
9143 Builder.CreateAlignedLoad(VTy->getElementType(), Ops[0], Alignment);
9144 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vld1_lane");
9150 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
9154 Builder.CreateAlignedLoad(VTy->getElementType(), Ops[0], Alignment);
9156 Ops[0] = Builder.CreateInsertElement(V, Ops[0], CI);
9161 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
9162 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2]);
9164 return Builder.CreateDefaultAlignedStore(Ops[1],
9165 Builder.CreateBitCast(Ops[0], Ty));
9169 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
9172 Ops[1] = Builder.CreateCall(F, Ops[1], "vld2");
9173 Ops[0] = Builder.CreateBitCast(Ops[0],
9175 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9180 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
9183 Ops[1] = Builder.CreateCall(F, Ops[1], "vld3");
9184 Ops[0] = Builder.CreateBitCast(Ops[0],
9186 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9191 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
9194 Ops[1] = Builder.CreateCall(F, Ops[1], "vld4");
9195 Ops[0] = Builder.CreateBitCast(Ops[0],
9197 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9203 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
9206 Ops[1] = Builder.CreateCall(F, Ops[1], "vld2");
9207 Ops[0] = Builder.CreateBitCast(Ops[0],
9209 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9215 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
9218 Ops[1] = Builder.CreateCall(F, Ops[1], "vld3");
9219 Ops[0] = Builder.CreateBitCast(Ops[0],
9221 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9227 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
9230 Ops[1] = Builder.CreateCall(F, Ops[1], "vld4");
9231 Ops[0] = Builder.CreateBitCast(Ops[0],
9233 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9241 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
9242 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
9243 Ops[3] = Builder.CreateZExt(Ops[3], Int64Ty);
9244 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld2_lane");
9246 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
9247 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9255 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
9256 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
9257 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
9258 Ops[4] = Builder.CreateZExt(Ops[4], Int64Ty);
9259 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane");
9261 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
9262 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9270 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
9271 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
9272 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
9273 Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
9274 Ops[5] = Builder.CreateZExt(Ops[5], Int64Ty);
9275 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld4_lane");
9277 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
9278 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
9292 Ops[2] = Builder.CreateZExt(Ops[2], Int64Ty);
9309 Ops[3] = Builder.CreateZExt(Ops[3], Int64Ty);
9326 Ops[4] = Builder.CreateZExt(Ops[4], Int64Ty);
9333 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
9334 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
9335 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
9344 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
9345 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vtrn");
9346 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
9352 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
9353 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
9354 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
9362 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
9363 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vuzp");
9364 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
9370 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
9371 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
9372 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
9381 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
9382 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vzip");
9383 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
9460 return Builder.CreateCall(FnGetFieldInfo, {FieldAddr, InfoKind});
9484 Result = Builder.CreateInsertElement(Result, Ops[i], Builder.getInt32(i));
9484 Result = Builder.CreateInsertElement(Result, Ops[i], Builder.getInt32(i));
9493 llvm::VectorType *MaskTy = llvm::VectorType::get(CGF.Builder.getInt1Ty(),
9495 Value *MaskVec = CGF.Builder.CreateBitCast(Mask, MaskTy);
9503 MaskVec = CGF.Builder.CreateShuffleVector(MaskVec, MaskVec,
9514 Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
9520 return CGF.Builder.CreateMaskedStore(Ops[1], Ptr, Align, MaskVec);
9526 Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
9532 return CGF.Builder.CreateMaskedLoad(Ptr, Align, MaskVec, Ops[1]);
9541 Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
9549 return CGF.Builder.CreateCall(F, { Ptr, MaskVec, Ops[1] });
9563 return CGF.Builder.CreateCall(F, { Ops[0], Ops[1], MaskVec });
9572 Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
9580 return CGF.Builder.CreateCall(F, { Ops[1], Ptr, MaskVec });
9591 LHS = CGF.Builder.CreateNot(LHS);
9593 return CGF.Builder.CreateBitCast(CGF.Builder.CreateBinOp(Opc, LHS, RHS),
9593 return CGF.Builder.CreateBitCast(CGF.Builder.CreateBinOp(Opc, LHS, RHS),
9606 Amt = CGF.Builder.CreateIntCast(Amt, Ty->getScalarType(), false);
9607 Amt = CGF.Builder.CreateVectorSplat(NumElts, Amt);
9612 return CGF.Builder.CreateCall(F, {Op0, Op1, Amt});
9650 Value *Cmp = CGF.Builder.CreateICmp(Pred, Op0, Op1);
9651 Value *Res = CGF.Builder.CreateSExt(Cmp, Ty);
9665 return CGF.Builder.CreateSelect(Mask, Op0, Op1);
9676 llvm::VectorType::get(CGF.Builder.getInt1Ty(),
9678 Mask = CGF.Builder.CreateBitCast(Mask, MaskTy);
9679 Mask = CGF.Builder.CreateExtractElement(Mask, (uint64_t)0);
9680 return CGF.Builder.CreateSelect(Mask, Op0, Op1);
9688 Cmp = CGF.Builder.CreateAnd(Cmp, getMaskVecValue(CGF, MaskIn, NumElts));
9697 Cmp = CGF.Builder.CreateShuffleVector(
9701 return CGF.Builder.CreateBitCast(Cmp,
9715 llvm::VectorType::get(CGF.Builder.getInt1Ty(), NumElts));
9718 llvm::VectorType::get(CGF.Builder.getInt1Ty(), NumElts));
9730 Cmp = CGF.Builder.CreateICmp(Pred, Ops[0], Ops[1]);
9755 Res = CGF.Builder.CreateCall(F, { Ops[0], Ops[3] });
9757 Res = IsSigned ? CGF.Builder.CreateSIToFP(Ops[0], Ty)
9758 : CGF.Builder.CreateUIToFP(Ops[0], Ty);
9768 Value *Sub = CGF.Builder.CreateSub(Zero, Ops[0]);
9769 Value *Cmp = CGF.Builder.CreateICmp(ICmpInst::ICMP_SGT, Ops[0], Zero);
9770 Value *Res = CGF.Builder.CreateSelect(Cmp, Ops[0], Sub);
9776 Value *Cmp = CGF.Builder.CreateICmp(Pred, Ops[0], Ops[1]);
9777 Value *Res = CGF.Builder.CreateSelect(Cmp, Ops[0], Ops[1]);
9828 C = CGF.Builder.CreateFNeg(C);
9836 Res = CGF.Builder.CreateCall(Intr, {A, B, C, Ops.back() });
9840 Res = CGF.Builder.CreateCall(FMA, {A, B, C} );
9849 Value *NegC = CGF.Builder.CreateFNeg(C);
9850 Value *FMSub = CGF.Builder.CreateCall(FMA, {A, B, NegC} );
9851 Res = CGF.Builder.CreateShuffleVector(FMSub, Res, Indices);
9897 Ops[2] = CGF.Builder.CreateFNeg(Ops[2]);
9899 Ops[0] = CGF.Builder.CreateExtractElement(Ops[0], (uint64_t)0);
9900 Ops[1] = CGF.Builder.CreateExtractElement(Ops[1], (uint64_t)0);
9901 Ops[2] = CGF.Builder.CreateExtractElement(Ops[2], (uint64_t)0);
9907 Res = CGF.Builder.CreateCall(CGF.CGM.getIntrinsic(IID),
9911 Res = CGF.Builder.CreateCall(FMA, Ops.slice(0, 3));
9922 PassThru = CGF.Builder.CreateExtractElement(Upper, (uint64_t)0);
9926 return CGF.Builder.CreateInsertElement(Upper, Res, (uint64_t)0);
9935 Value *LHS = CGF.Builder.CreateBitCast(Ops[0], Ty);
9936 Value *RHS = CGF.Builder.CreateBitCast(Ops[1], Ty);
9941 LHS = CGF.Builder.CreateShl(LHS, ShiftAmt);
9942 LHS = CGF.Builder.CreateAShr(LHS, ShiftAmt);
9943 RHS = CGF.Builder.CreateShl(RHS, ShiftAmt);
9944 RHS = CGF.Builder.CreateAShr(RHS, ShiftAmt);
9948 LHS = CGF.Builder.CreateAnd(LHS, Mask);
9949 RHS = CGF.Builder.CreateAnd(RHS, Mask);
9952 return CGF.Builder.CreateMul(LHS, RHS);
9980 Value *Ternlog = CGF.Builder.CreateCall(CGF.CGM.getIntrinsic(IID),
9990 return CGF.Builder.CreateSExt(Mask, DstTy, "vpmovm2");
10001 return CGF.Builder.CreateCall(F, {Ops[0], Ops[1]});
10014 llvm::Type *Int32Ty = CGF.Builder.getInt32Ty();
10015 Value *ZeroExt = CGF.Builder.CreateZExt(Ops[0], Int32Ty);
10016 Value *Shl = CGF.Builder.CreateShl(ZeroExt, 16);
10018 Value *BitCast = CGF.Builder.CreateBitCast(Shl, ResultType);
10024 llvm::Type *Int32Ty = Builder.getInt32Ty();
10059 llvm::Value *CpuValue = Builder.CreateGEP(STy, CpuModel, Idxs);
10060 CpuValue = Builder.CreateAlignedLoad(CpuValue, CharUnits::fromQuantity(4));
10063 return Builder.CreateICmpEQ(CpuValue,
10096 Value *Result = Builder.getTrue();
10114 Value *Idxs[] = {Builder.getInt32(0), Builder.getInt32(3),
10114 Value *Idxs[] = {Builder.getInt32(0), Builder.getInt32(3),
10115 Builder.getInt32(0)};
10116 Value *CpuFeatures = Builder.CreateGEP(STy, CpuModel, Idxs);
10118 Builder.CreateAlignedLoad(CpuFeatures, CharUnits::fromQuantity(4));
10121 Value *Mask = Builder.getInt32(Features1);
10122 Value *Bitset = Builder.CreateAnd(Features, Mask);
10123 Value *Cmp = Builder.CreateICmpEQ(Bitset, Mask);
10124 Result = Builder.CreateAnd(Result, Cmp);
10133 Builder.CreateAlignedLoad(CpuFeatures2, CharUnits::fromQuantity(4));
10136 Value *Mask = Builder.getInt32(Features2);
10137 Value *Bitset = Builder.CreateAnd(Features, Mask);
10138 Value *Cmp = Builder.CreateICmpEQ(Bitset, Mask);
10139 Result = Builder.CreateAnd(Result, Cmp);
10153 return Builder.CreateCall(Func);
10197 return Builder.CreateCall(F, Ops);
10206 Value *Cmp = Builder.CreateFCmp(Pred, Ops[0], Ops[1]);
10209 Value *Sext = Builder.CreateSExt(Cmp, IntVecTy);
10210 return Builder.CreateBitCast(Sext, FPVecTy);
10222 return Builder.CreateCall(F, {Address, RW, Locality, Data});
10225 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse2_clflush),
10229 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse2_lfence));
10232 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse2_mfence));
10235 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_sfence));
10238 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse2_pause));
10241 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_rdtsc));
10244 Value *Call = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_rdtscp));
10245 Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 1),
10245 Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 1),
10247 return Builder.CreateExtractValue(Call, 0);
10253 return Builder.CreateCall(F, {Ops[0], Builder.getInt1(false)});
10253 return Builder.CreateCall(F, {Ops[0], Builder.getInt1(false)});
10259 return Builder.CreateCall(F, {Ops[0], Builder.getInt1(false)});
10259 return Builder.CreateCall(F, {Ops[0], Builder.getInt1(false)});
10273 return Builder.CreateBitCast(BuildVector(Ops),
10290 return Builder.CreateExtractElement(Ops[0], Index);
10305 return Builder.CreateInsertElement(Ops[0], Ops[1], Index);
10310 Builder.CreateStore(Ops[0], Tmp);
10311 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
10312 Builder.CreateBitCast(Tmp.getPointer(), Int8PtrTy));
10317 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
10318 Builder.CreateBitCast(Tmp.getPointer(), Int8PtrTy));
10319 return Builder.CreateLoad(Tmp, "stmxcsr");
10360 Value *Mhi = Builder.CreateTrunc(
10361 Builder.CreateLShr(Ops[1], ConstantInt::get(Int64Ty, 32)), Int32Ty);
10362 Value *Mlo = Builder.CreateTrunc(Ops[1], Int32Ty);
10365 return Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
10369 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_xgetbv), Ops);
10408 return Builder.CreateCall(F, Ops);
10735 return Builder.CreateCall(Intr, Ops);
10843 return Builder.CreateCall(Intr, Ops);
10875 Value *Res = Builder.CreateShuffleVector(Ops[0],
10913 Value *Op1 = Builder.CreateShuffleVector(Ops[1],
10925 return Builder.CreateShuffleVector(Ops[0], Op1,
10931 Value *Res = Builder.CreateTrunc(Ops[0], Ops[1]->getType());
10939 return Builder.CreateTrunc(Ops[0], Ops[1]->getType());
10956 return Builder.CreateCall(Intr, Ops);
10975 return Builder.CreateShuffleVector(Ops[0], Ops[1],
10999 return Builder.CreateShuffleVector(Ops[0], UndefValue::get(Ty),
11023 return Builder.CreateShuffleVector(Ops[0], UndefValue::get(Ty),
11053 return Builder.CreateShuffleVector(Ops[0], UndefValue::get(Ty),
11083 return Builder.CreateShuffleVector(Ops[0], Ops[1],
11101 return Builder.CreateShuffleVector(Ops[0], UndefValue::get(Ty),
11137 return Builder.CreateShuffleVector(Ops[1], Ops[0],
11157 return Builder.CreateShuffleVector(Ops[1], Ops[0],
11186 return Builder.CreateShuffleVector(Ops[0], Ops[1],
11225 return Builder.CreateShuffleVector(OutOps[0], OutOps[1],
11253 Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast");
11255 Value *SV = Builder.CreateShuffleVector(Zero, Cast,
11258 return Builder.CreateBitCast(SV, Ops[0]->getType(), "cast");
11283 Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast");
11285 Value *SV = Builder.CreateShuffleVector(Cast, Zero,
11288 return Builder.CreateBitCast(SV, ResultType, "cast");
11307 Value *SV = Builder.CreateShuffleVector(Zero, In,
11310 return Builder.CreateBitCast(SV, Ops[0]->getType());
11329 Value *SV = Builder.CreateShuffleVector(In, Zero,
11332 return Builder.CreateBitCast(SV, Ops[0]->getType());
11339 getLLVMContext(), llvm::ConstantAsMetadata::get(Builder.getInt32(1)));
11347 Src = Builder.CreateExtractElement(Src, (uint64_t)0, "extract");
11350 Value *BC = Builder.CreateBitCast(
11354 StoreInst *SI = Builder.CreateDefaultAlignedStore(Src, BC);
11415 Value *A = Builder.CreateExtractElement(Ops[1], (uint64_t)0);
11416 Value *B = Builder.CreateExtractElement(Ops[2], (uint64_t)0);
11418 return Builder.CreateInsertElement(Ops[1], A, (uint64_t)0);
11467 Value *Cmp = Builder.CreateICmpEQ(Or, C);
11468 return Builder.CreateZExt(Cmp, ConvertType(E->getType()));
11476 Value *Cmp = Builder.CreateICmpEQ(Or, C);
11477 return Builder.CreateZExt(Cmp, ConvertType(E->getType()));
11521 return Builder.CreateCall(Intr, {LHS, RHS});
11549 Value *Res = Builder.CreateCall(Intr, {LHS, RHS});
11550 return Builder.CreateBitCast(Res, Ops[0]->getType());
11583 return Builder.CreateBitCast(Builder.CreateNot(Res),
11583 return Builder.CreateBitCast(Builder.CreateNot(Res),
11595 return Builder.CreateBitCast(Res, Ops[0]->getType());
11610 LHS = Builder.CreateShuffleVector(LHS, LHS,
11612 RHS = Builder.CreateShuffleVector(RHS, RHS,
11616 Value *Res = Builder.CreateShuffleVector(RHS, LHS,
11618 return Builder.CreateBitCast(Res, Ops[0]->getType());
11628 return Builder.CreateCall(F, {Ops[0],Builder.getInt1(false)});
11628 return Builder.CreateCall(F, {Ops[0],Builder.getInt1(false)});
11632 Value *A = Builder.CreateExtractElement(Ops[0], (uint64_t)0);
11634 A = Builder.CreateCall(F, {A});
11635 return Builder.CreateInsertElement(Ops[0], A, (uint64_t)0);
11646 return Builder.CreateCall(CGM.getIntrinsic(IID), Ops);
11648 Value *A = Builder.CreateExtractElement(Ops[1], (uint64_t)0);
11650 A = Builder.CreateCall(F, A);
11651 Value *Src = Builder.CreateExtractElement(Ops[2], (uint64_t)0);
11653 return Builder.CreateInsertElement(Ops[0], A, (uint64_t)0);
11669 return Builder.CreateCall(CGM.getIntrinsic(IID), Ops);
11673 return Builder.CreateCall(F, Ops[0]);
11818 Ops[0] = Builder.CreateBitCast(Ops[0], MMXTy, "cast");
11820 return Builder.CreateCall(F, Ops, "pswapd");
11851 Value *Call = Builder.CreateCall(CGM.getIntrinsic(ID));
11852 Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 0),
11852 Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 0),
11854 return Builder.CreateExtractValue(Call, 1);
11877 Value *Call = Builder.CreateCall(CGM.getIntrinsic(IID),
11879 Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 1),
11879 Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 1),
11881 return Builder.CreateExtractValue(Call, 0);
11917 Value *Fpclass = Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
11952 Value *Call = Builder.CreateCall(CGM.getIntrinsic(ID), {Ops[0], Ops[1]});
11953 Value *Result = Builder.CreateExtractValue(Call, 0);
11955 Builder.CreateDefaultAlignedStore(Result, Ops[2]);
11957 Result = Builder.CreateExtractValue(Call, 1);
11959 return Builder.CreateDefaultAlignedStore(Result, Ops[3]);
11979 return Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
12003 Value *Shufbit = Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
12102 Value *Cmp = Builder.CreateFCmp(Pred, Ops[0], Ops[1]);
12149 return Builder.CreateCall(CGM.getIntrinsic(IID), Ops);
12166 Value *Res = Builder.CreateCall(CGM.getIntrinsic(IID), Ops[0]);
12174 Value *LHS = Builder.CreateIntCast(Ops[0], Int64Ty, isSigned);
12175 Value *RHS = Builder.CreateIntCast(Ops[1], Int64Ty, isSigned);
12176 return Builder.CreateMul(LHS, RHS, "", !isSigned, isSigned);
12186 Value *LHS = Builder.CreateIntCast(Ops[0], Int128Ty, IsSigned);
12187 Value *RHS = Builder.CreateIntCast(Ops[1], Int128Ty, IsSigned);
12191 MulResult = Builder.CreateNSWMul(LHS, RHS);
12192 HigherBits = Builder.CreateAShr(MulResult, 64);
12194 MulResult = Builder.CreateNUWMul(LHS, RHS);
12195 HigherBits = Builder.CreateLShr(MulResult, 64);
12197 HigherBits = Builder.CreateIntCast(HigherBits, ResType, IsSigned);
12203 Builder.CreateStore(HigherBits, HighBitsAddress);
12204 return Builder.CreateIntCast(MulResult, ResType, IsSigned);
12208 return Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent,
12219 llvm::Type *Int128Ty = Builder.getInt128Ty();
12221 Builder.CreateShl(Builder.CreateZExt(Ops[1], Int128Ty), 64);
12221 Builder.CreateShl(Builder.CreateZExt(Ops[1], Int128Ty), 64);
12222 Value *LowPart128 = Builder.CreateZExt(Ops[0], Int128Ty);
12223 Value *Val = Builder.CreateOr(HighPart128, LowPart128);
12224 Value *Amt = Builder.CreateAnd(Builder.CreateZExt(Ops[2], Int128Ty),
12224 Value *Amt = Builder.CreateAnd(Builder.CreateZExt(Ops[2], Int128Ty),
12228 Res = Builder.CreateLShr(Builder.CreateShl(Val, Amt), 64);
12228 Res = Builder.CreateLShr(Builder.CreateShl(Val, Amt), 64);
12230 Res = Builder.CreateLShr(Val, Amt);
12231 return Builder.CreateTrunc(Res, Int64Ty);
12236 return Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent,
12269 llvm::Type *Int128Ty = Builder.getInt128Ty();
12273 Builder.CreateBitCast(Ops[0], Int128PtrTy);
12274 Value *ExchangeHigh128 = Builder.CreateZExt(Ops[1], Int128Ty);
12275 Value *ExchangeLow128 = Builder.CreateZExt(Ops[2], Int128Ty);
12276 Address ComparandResult(Builder.CreateBitCast(Ops[3], Int128PtrTy),
12279 Value *Exchange = Builder.CreateOr(
12280 Builder.CreateShl(ExchangeHigh128, 64, "", false, false),
12283 Value *Comparand = Builder.CreateLoad(ComparandResult);
12286 Builder.CreateAtomicCmpXchg(Destination, Comparand, Exchange,
12292 Builder.CreateStore(Builder.CreateExtractValue(CXI, 0), ComparandResult);
12292 Builder.CreateStore(Builder.CreateExtractValue(CXI, 0), ComparandResult);
12295 Value *Success = Builder.CreateExtractValue(CXI, 1);
12296 return Builder.CreateZExt(Success, ConvertType(E->getType()));
12302 return Builder.CreateCall(F);
12307 return Builder.CreateMemSet(Ops[0], Ops[1], Ops[2], 1, true);
12320 llvm::CallInst *CI = Builder.CreateCall(IA);
12330 Builder.CreateIntToPtr(Ops[0], llvm::PointerType::get(IntTy, 257));
12331 LoadInst *Load = Builder.CreateAlignedLoad(
12342 Builder.CreateIntToPtr(Ops[0], llvm::PointerType::get(IntTy, 256));
12343 LoadInst *Load = Builder.CreateAlignedLoad(
12394 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::readcyclecounter));
12413 Ops[0] = Builder.CreateBitCast(Ops[0], Int8PtrTy);
12415 Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
12416 Ops[0] = Builder.CreateGEP(Ops[1], Ops[0]);
12463 return Builder.CreateCall(F, Ops, "");
12481 Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
12483 Ops[2] = Builder.CreateBitCast(Ops[2], Int8PtrTy);
12484 Ops[1] = Builder.CreateGEP(Ops[2], Ops[1]);
12525 return Builder.CreateCall(F, Ops, "");
12534 return Builder.CreateCall(F, X);
12543 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
12545 return Builder.CreateCall(F, {X, Undef});
12553 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
12555 return Builder.CreateCall(F, {X, Undef});
12564 return Builder.CreateCall(F, X);
12574 return Builder.CreateCall(F, {X, Y});
12605 return Builder.CreateCall(F, X);
12614 return Builder.CreateCall(F, X);
12635 return Builder.CreateCall(F, {X, Y, Z});
12638 return Builder.CreateFSub(Zero,
12639 Builder.CreateCall(F, {X, Y, Z}), "sub");
12642 return Builder.CreateCall(F,
12643 {X, Y, Builder.CreateFSub(Zero, Z, "sub")});
12647 Builder.CreateCall(F, {X, Y, Builder.CreateFSub(Zero, Z, "sub")});
12647 Builder.CreateCall(F, {X, Y, Builder.CreateFSub(Zero, Z, "sub")});
12648 return Builder.CreateFSub(Zero, FsubRes, "sub");
12674 Ops[1] = Builder.CreateBitCast(Ops[1], llvm::VectorType::get(Int64Ty, 2));
12684 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 2));
12685 Ops[0] = Builder.CreateShuffleVector(Ops[0], Ops[0], ShuffleMask);
12692 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 4));
12694 return Builder.CreateCall(F, Ops);
12701 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 2));
12717 Value *Call = Builder.CreateCall(F, Ops);
12725 Value *ShuffleCall = Builder.CreateShuffleVector(Call, Call, ShuffleMask);
12729 return Builder.CreateCall(F, Ops);
12738 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 2));
12739 Ops[1] = Builder.CreateBitCast(Ops[1], llvm::VectorType::get(Int64Ty, 2));
12752 Builder.CreateShuffleVector(Ops[0], Ops[1], ShuffleMask);
12755 return Builder.CreateBitCast(ShuffleCall, RetTy);
12762 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 4));
12763 Ops[1] = Builder.CreateBitCast(Ops[1], llvm::VectorType::get(Int32Ty, 4));
12793 Builder.CreateShuffleVector(Ops[0], Ops[1], ShuffleMask);
12796 return Builder.CreateBitCast(ShuffleCall, RetTy);
12803 Value *Res = Builder.CreateInsertElement(
12805 Res = Builder.CreateInsertElement(Res, Ops[1],
12807 return Builder.CreateBitCast(Res, ConvertType(E->getType()));
12812 Value *Unpacked = Builder.CreateBitCast(
12818 return Builder.CreateExtractElement(Unpacked, Index);
12840 llvm::Value *Tmp = Builder.CreateCall(Callee, {X, Y, Z});
12842 llvm::Value *Result = Builder.CreateExtractValue(Tmp, 0);
12843 llvm::Value *Flag = Builder.CreateExtractValue(Tmp, 1);
12848 llvm::Value *FlagExt = Builder.CreateZExt(Flag, RealFlagType);
12849 Builder.CreateStore(FlagExt, FlagOutPtr);
12861 llvm::Value *Src3ToBool = Builder.CreateIsNotNull(Src3);
12862 return Builder.CreateCall(F, {Src0, Src1, Src2, Src3ToBool});
12879 return Builder.CreateCall(F, Args);
12919 { Builder.getInt32Ty(), Src0->getType() });
12920 return Builder.CreateCall(F, Src0);
12925 { Builder.getInt16Ty(), Src0->getType() });
12926 return Builder.CreateCall(F, Src0);
12948 { Builder.getInt64Ty(), Src0->getType() });
12949 return Builder.CreateCall(F, { Src0, Src1, Src2 });
12959 { Builder.getInt64Ty(), Src0->getType() });
12960 return Builder.CreateCall(F, { Src0, Src1, Src2 });
12975 return Builder.CreateCall(F, { Src0, Builder.getFalse() });
12975 return Builder.CreateCall(F, { Src0, Builder.getFalse() });
13027 Value *Call = CGF.Builder.CreateCall(F, Args);
13028 Value *CC = CGF.Builder.CreateExtractValue(Call, 1);
13029 CGF.Builder.CreateStore(CC, CCPtr);
13030 return CGF.Builder.CreateExtractValue(Call, 0);
13040 return Builder.CreateCall(F, {TDB, Control});
13046 return Builder.CreateCall(F, {TDB, Control});
13052 return Builder.CreateCall(F, {TDB, Control});
13057 return Builder.CreateCall(F, Builder.CreateSExt(Data, Int64Ty, "tabort"));
13057 return Builder.CreateCall(F, Builder.CreateSExt(Data, Int64Ty, "tabort"));
13063 return Builder.CreateCall(F, {Data, Address});
13078 return Builder.CreateCall(F, X);
13087 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
13089 return Builder.CreateCall(F, {X, Undef});
13098 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
13100 return Builder.CreateCall(F, {X, Undef});
13108 return Builder.CreateCall(F, X);
13117 return Builder.CreateCall(F, {X, Y, Z});
13127 return Builder.CreateCall(F, {X, Y, Builder.CreateFSub(Zero, Z, "sub")});
13127 return Builder.CreateCall(F, {X, Y, Builder.CreateFSub(Zero, Z, "sub")});
13137 return Builder.CreateFSub(Zero, Builder.CreateCall(F, {X, Y, Z}), "sub");
13137 return Builder.CreateFSub(Zero, Builder.CreateCall(F, {X, Y, Z}), "sub");
13147 Value *NegZ = Builder.CreateFSub(Zero, Z, "sub");
13148 return Builder.CreateFSub(Zero, Builder.CreateCall(F, {X, Y, NegZ}));
13148 return Builder.CreateFSub(Zero, Builder.CreateCall(F, {X, Y, NegZ}));
13155 return Builder.CreateCall(F, X);
13163 return Builder.CreateFSub(Zero, Builder.CreateCall(F, X), "sub");
13163 return Builder.CreateFSub(Zero, Builder.CreateCall(F, X), "sub");
13199 return Builder.CreateCall(F, X);
13209 return Builder.CreateCall(F, {X, M4Value, M5Value});
13230 return Builder.CreateCall(F, {X, Y});
13239 return Builder.CreateCall(F, {X, Y, M4Value});
13260 return Builder.CreateCall(F, {X, Y});
13269 return Builder.CreateCall(F, {X, Y, M4Value});
13278 return Builder.CreateCall(F, X);
13621 return Builder.CreateCall(
13624 {Ptr, ConstantInt::get(Builder.getInt32Ty(), Align.getQuantity())});
13628 return Builder.CreateCall(
13695 return Builder.CreateAtomicRMW(llvm::AtomicRMWInst::FAdd, Ptr, Val,
13704 return Builder.CreateCall(FnALI32, {Ptr, Val});
13712 return Builder.CreateCall(FnALD32, {Ptr, Val});
13836 return Builder.CreateCall(
13846 return Builder.CreateCall(
13857 Value *ResultPair = Builder.CreateCall(
13862 Value *Pred = Builder.CreateZExt(Builder.CreateExtractValue(ResultPair, 1),
13862 Value *Pred = Builder.CreateZExt(Builder.CreateExtractValue(ResultPair, 1),
13864 Builder.CreateStore(Pred, PredOutPtr);
13865 return Builder.CreateExtractValue(ResultPair, 0);
13920 Builder.CreateCall(CGM.getIntrinsic(IID, Src->getType()), {Src, Ldm});
13925 Builder.CreateAlignedStore(Result, Dst.getPointer(),
13929 Builder.CreateAlignedStore(
13930 Builder.CreateBitCast(Builder.CreateExtractValue(Result, i),
13930 Builder.CreateBitCast(Builder.CreateExtractValue(Result, i),
13932 Builder.CreateGEP(Dst.getPointer(),
13967 Value *V = Builder.CreateAlignedLoad(
13968 Builder.CreateGEP(Src.getPointer(), llvm::ConstantInt::get(IntTy, i)),
13970 Values.push_back(Builder.CreateBitCast(V, ParamType));
13973 Value *Result = Builder.CreateCall(Intrinsic, Values);
14026 Value *V = Builder.CreateAlignedLoad(
14027 Builder.CreateGEP(SrcA.getPointer(),
14030 Values.push_back(Builder.CreateBitCast(V, AType));
14035 Value *V = Builder.CreateAlignedLoad(
14036 Builder.CreateGEP(SrcB.getPointer(),
14039 Values.push_back(Builder.CreateBitCast(V, BType));
14045 Value *V = Builder.CreateAlignedLoad(
14046 Builder.CreateGEP(SrcC.getPointer(),
14049 Values.push_back(Builder.CreateBitCast(V, CType));
14051 Value *Result = Builder.CreateCall(Intrinsic, Values);
14054 Builder.CreateAlignedStore(
14055 Builder.CreateBitCast(Builder.CreateExtractValue(Result, i), DType),
14055 Builder.CreateBitCast(Builder.CreateExtractValue(Result, i), DType),
14056 Builder.CreateGEP(Dst.getPointer(), llvm::ConstantInt::get(IntTy, i)),
14072 return Builder.CreateCall(Callee, I);
14081 return Builder.CreateCall(Callee, Args);
14097 return Builder.CreateCall(Callee, Args);
14105 return Builder.CreateCall(Callee, {Arg});
14110 return Builder.CreateCall(Callee);
14115 return Builder.CreateCall(Callee);
14119 return Builder.CreateCall(Callee);
14125 return Builder.CreateCall(Callee, {Tag, Obj});
14129 return Builder.CreateCall(Callee);
14136 return Builder.CreateCall(Callee, {Addr, Expected, Timeout});
14143 return Builder.CreateCall(Callee, {Addr, Expected, Timeout});
14149 return Builder.CreateCall(Callee, {Addr, Count});
14159 return Builder.CreateCall(Callee, {Src});
14169 return Builder.CreateCall(Callee, {Src});
14181 return Builder.CreateCall(Callee, {Src});
14193 return Builder.CreateCall(Callee, {Src});
14203 return Builder.CreateCall(Callee, {LHS, RHS});
14213 return Builder.CreateCall(Callee, {LHS, RHS});
14219 return Builder.CreateCall(Callee, {Src, Indices});
14234 Value *Extract = Builder.CreateExtractElement(Vec, Lane);
14238 return Builder.CreateSExt(Extract, ConvertType(E->getType()));
14241 return Builder.CreateZExt(Extract, ConvertType(E->getType()));
14267 Value *Trunc = Builder.CreateTrunc(Val, ElemType);
14268 return Builder.CreateInsertElement(Vec, Trunc, Lane);
14274 return Builder.CreateInsertElement(Vec, Val, Lane);
14311 return Builder.CreateCall(Callee, {LHS, RHS});
14319 return Builder.CreateCall(Callee, {V1, V2, C});
14348 return Builder.CreateCall(Callee, {Vec});
14354 return Builder.CreateCall(Callee, {Vec});
14360 return Builder.CreateCall(Callee, {Vec});
14383 return Builder.CreateCall(Callee, {A, B, C});
14406 return Builder.CreateCall(Callee, {Low, High});
14440 return Builder.CreateCall(Callee, Vec);
14455 BP = Address(Builder.CreateBitCast(BP.getPointer(), Int8PtrPtrTy),
14457 llvm::Value *Base = Builder.CreateLoad(BP);
14466 llvm::Value *Result = Builder.CreateCall(CGM.getIntrinsic(IntID), Ops);
14467 llvm::Value *NewBase = Builder.CreateExtractValue(Result, 1);
14468 llvm::Value *LV = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)),
14473 Builder.CreateAlignedStore(NewBase, LV, Dest.getAlignment());
14474 return Builder.CreateExtractValue(Result, 0);
14480 BP = Address(Builder.CreateBitCast(BP.getPointer(), Int8PtrPtrTy),
14482 llvm::Value *Base = Builder.CreateLoad(BP);
14491 llvm::Value *NewBase = Builder.CreateCall(CGM.getIntrinsic(IntID), Ops);
14492 llvm::Value *LV = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)),
14497 return Builder.CreateAlignedStore(NewBase, LV, Dest.getAlignment());
14508 Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), Int8PtrTy);
14514 DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), Int8PtrTy),
14523 llvm::Value *Result = Builder.CreateCall(CGM.getIntrinsic(IntID), Ops);
14525 llvm::Value *DestVal = Builder.CreateExtractValue(Result, 0);
14530 DestVal = Builder.CreateTrunc(DestVal, DestTy);
14533 Builder.CreateBitCast(DestAddress, DestVal->getType()->getPointerTo());
14534 Builder.CreateAlignedStore(DestVal, DestForStore, DestAddr.getAlignment());
14536 return Builder.CreateExtractValue(Result, 1);
14551 Dest = Builder.CreateBitCast(Dest,
14552 llvm::VectorType::get(Builder.getInt1Ty(), Size)->getPointerTo(0));
14553 LoadInst *QLd = Builder.CreateLoad(Dest);
14555 llvm::Value *Result = Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
14556 llvm::Value *Vprd = Builder.CreateExtractValue(Result, 1);
14557 llvm::Value *Base = Builder.CreateBitCast(EmitScalarExpr(E->getArg(2)),
14559 Builder.CreateAlignedStore(Vprd, Base, Dest.getAlignment());
14560 return Builder.CreateExtractValue(Result, 0);
14573 Dest = Builder.CreateBitCast(Dest,
14574 llvm::VectorType::get(Builder.getInt1Ty(), Size)->getPointerTo(0));
14575 LoadInst *QLd = Builder.CreateLoad(Dest);
14577 llvm::Value *Result = Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
14578 llvm::Value *Vprd = Builder.CreateExtractValue(Result, 1);
14579 llvm::Value *Base = Builder.CreateBitCast(EmitScalarExpr(E->getArg(2)),
14581 Builder.CreateAlignedStore(Vprd, Base, Dest.getAlignment());
14582 return Builder.CreateExtractValue(Result, 0);
tools/clang/lib/CodeGen/CGCUDANV.cpp 261 llvm::Value *VoidVarPtr = CGF.Builder.CreatePointerCast(VarPtr, VoidPtrTy);
262 CGF.Builder.CreateDefaultAlignedStore(
263 VoidVarPtr, CGF.Builder.CreateConstGEP1_32(KernelArgs.getPointer(), i));
316 llvm::Value *Kernel = CGF.Builder.CreatePointerCast(CGF.CurFn, VoidPtrTy);
324 LaunchKernelArgs.add(RValue::get(CGF.Builder.CreateLoad(ShmemSize)),
326 LaunchKernelArgs.add(RValue::get(CGF.Builder.CreateLoad(Stream)),
357 CGF.Builder.CreatePointerCast(CGF.GetAddrOfLocalVar(A).getPointer(),
364 llvm::Value *CBZero = CGF.Builder.CreateICmpEQ(CB, Zero);
366 CGF.Builder.CreateCondBr(CBZero, NextBlock, EndBlock);
373 llvm::Value *Arg = CGF.Builder.CreatePointerCast(CGF.CurFn, CharPtrTy);
tools/clang/lib/CodeGen/CGCXX.cpp 255 VTable = CGF.Builder.CreateBitCast(VTable, Ty);
264 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfnkxt");
266 CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.PointerAlignInBytes);
tools/clang/lib/CodeGen/CGCXXABI.cpp 86 return CGF.Builder.getFalse();
94 return CGF.Builder.getFalse();
146 return CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
206 ptr = CGF.Builder.CreateElementBitCast(ptr, CGF.Int8Ty);
218 CGF.Builder.CreateConstInBoundsByteGEP(ptr, -cookieSize);
tools/clang/lib/CodeGen/CGCXXABI.h 616 CGF.Builder.CreateCatchRet(CPI, BB);
tools/clang/lib/CodeGen/CGCall.cpp 1011 CGF.Builder.CreateConstGEP2_32(nullptr, BaseAddr.getPointer(), 0, i);
1106 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(IRCallArgPos));
1146 SrcPtr = CGF.Builder.CreateStructGEP(SrcPtr, 0, "coerce.dive");
1172 return CGF.Builder.CreateBitCast(Val, Ty, "coerce.val");
1175 Val = CGF.Builder.CreatePtrToInt(Val, CGF.IntPtrTy, "coerce.val.pi");
1191 Val = CGF.Builder.CreateLShr(Val, SrcSize - DstSize, "coerce.highbits");
1192 Val = CGF.Builder.CreateTrunc(Val, DestIntTy, "coerce.val.ii");
1194 Val = CGF.Builder.CreateZExt(Val, DestIntTy, "coerce.val.ii");
1195 Val = CGF.Builder.CreateShl(Val, DstSize - SrcSize, "coerce.highbits");
1199 Val = CGF.Builder.CreateIntCast(Val, DestIntTy, false, "coerce.val.ii");
1204 Val = CGF.Builder.CreateIntToPtr(Val, Ty, "coerce.val.ip");
1223 return CGF.Builder.CreateLoad(Src);
1238 llvm::Value *Load = CGF.Builder.CreateLoad(Src);
1250 Src = CGF.Builder.CreateBitCast(Src,
1252 return CGF.Builder.CreateLoad(Src);
1257 Address Casted = CGF.Builder.CreateElementBitCast(Tmp,CGF.Int8Ty);
1258 Address SrcCasted = CGF.Builder.CreateElementBitCast(Src,CGF.Int8Ty);
1259 CGF.Builder.CreateMemCpy(Casted, SrcCasted,
1262 return CGF.Builder.CreateLoad(Tmp);
1275 Address EltPtr = CGF.Builder.CreateStructGEP(Dest, i);
1276 llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i);
1277 CGF.Builder.CreateStore(Elt, EltPtr, DestIsVolatile);
1280 CGF.Builder.CreateStore(Val, Dest, DestIsVolatile);
1297 CGF.Builder.CreateStore(Src, Dst, DstIsVolatile);
1313 CGF.Builder.CreateStore(Src, Dst, DstIsVolatile);
1321 Dst = CGF.Builder.CreateElementBitCast(Dst, SrcTy);
1334 CGF.Builder.CreateStore(Src, Tmp);
1335 Address Casted = CGF.Builder.CreateElementBitCast(Tmp,CGF.Int8Ty);
1336 Address DstCasted = CGF.Builder.CreateElementBitCast(Dst,CGF.Int8Ty);
1337 CGF.Builder.CreateMemCpy(DstCasted, Casted,
1346 addr = CGF.Builder.CreateElementBitCast(addr, CGF.Int8Ty);
1347 addr = CGF.Builder.CreateConstInBoundsByteGEP(addr,
1349 addr = CGF.Builder.CreateElementBitCast(addr, info.getCoerceToType());
2177 return CGF.Builder.CreateTrunc(value, varType, "arg.unpromote");
2179 return CGF.Builder.CreateFPCast(value, varType, "arg.unpromote");
2216 llvm::Value *errorValue = CGF.Builder.CreateLoad(Temp);
2217 CGF.Builder.CreateStore(errorValue, Arg);
2238 Builder.CreateStore(Zero, ReturnValue);
2307 Builder.CreateStructGEP(ArgStruct, FieldIndex, Arg->getName());
2330 Address Dst = Builder.CreateBitCast(AlignedTemp, Int8PtrTy);
2331 Address Src = Builder.CreateBitCast(ParamAddr, Int8PtrTy);
2332 Builder.CreateMemCpy(Dst, Src, SizeVal, false);
2427 llvm::Value *incomingErrorValue = Builder.CreateLoad(arg);
2428 Builder.CreateStore(incomingErrorValue, temp);
2439 V = Builder.CreateBitCast(V, ArgI.getCoerceToType());
2450 V = Builder.CreateBitCast(V, LTy);
2473 AddrToStoreInto = Builder.CreateElementBitCast(Ptr, STy);
2483 Address EltPtr = Builder.CreateStructGEP(AddrToStoreInto, i);
2484 Builder.CreateStore(AI, EltPtr);
2488 Builder.CreateMemCpy(Ptr, AddrToStoreInto, DstSize);
2518 alloca = Builder.CreateElementBitCast(alloca, coercionType);
2526 auto eltAddr = Builder.CreateStructGEP(alloca, i);
2528 Builder.CreateStore(elt, eltAddr);
2589 llvm::BasicBlock *BB = CGF.Builder.GetInsertBlock();
2670 return CGF.Builder.CreateBitCast(result, resultType);
2707 return CGF.Builder.CreateBitCast(load, resultType);
2749 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
2782 llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
2804 Builder.CreateUnreachable();
2810 Builder.CreateRetVoid();
2828 llvm::Value *SRet = Builder.CreateStructGEP(
2830 RV = Builder.CreateAlignedLoad(SRet, getPointerAlign(), "sret");
2850 EmitStoreOfScalar(Builder.CreateLoad(ReturnValue),
2880 RV = Builder.CreateLoad(ReturnValue);
2925 Address addr = Builder.CreateElementBitCast(ReturnValue, coercionType);
2931 auto eltAddr = Builder.CreateStructGEP(addr, i);
2932 auto elt = Builder.CreateLoad(eltAddr);
2947 RV = Builder.CreateInsertValue(RV, results[i], i);
2960 Ret = Builder.CreateRet(RV);
2962 Ret = Builder.CreateRetVoid();
3006 llvm::Value *SLocPtr = Builder.CreateLoad(ReturnLocation, "return.sloc.load");
3007 llvm::Value *CanNullCheck = Builder.CreateIsNotNull(SLocPtr);
3010 Builder.CreateAnd(CanNullCheck, RetValNullabilityPrecondition);
3011 Builder.CreateCondBr(CanNullCheck, Check, NoCheck);
3015 llvm::Value *Cond = Builder.CreateIsNotNull(RV);
3044 Placeholder = CGF.Builder.CreateAlignedLoad(IRPtrTy, Placeholder, Align);
3071 args.add(RValue::get(Builder.CreateLoad(local)), type);
3081 llvm::Value *ptr = Builder.CreateLoad(local);
3084 Builder.CreateStore(null, local);
3102 llvm::Instruction *isActive = Builder.CreateUnreachable();
3130 CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull");
3131 CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
3136 llvm::Value *value = CGF.Builder.CreateLoad(writeback.Temporary);
3139 value = CGF.Builder.CreateBitCast(value, srcAddr.getElementType(),
3254 CGF.Builder.CreateStore(null, temp);
3269 CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull");
3271 finalArgument = CGF.Builder.CreateSelect(isNull,
3278 originBB = CGF.Builder.GetInsertBlock();
3281 CGF.Builder.CreateCondBr(isNull, contBB, copyBB);
3295 src = CGF.Builder.CreateBitCast(src, destType->getElementType(),
3299 CGF.Builder.CreateStore(src, temp);
3314 llvm::BasicBlock *copyBB = CGF.Builder.GetInsertBlock();
3319 llvm::PHINode *phiToUse = CGF.Builder.CreatePHI(valueToUse->getType(), 2,
3339 StackBase = CGF.Builder.CreateCall(F, {}, "inalloca.save");
3346 CGF.Builder.CreateCall(F, StackBase);
3395 Builder.CreateICmpNE(V, llvm::Constant::getNullValue(V->getType()));
3429 auto T = Builder.getIntNTy(Context.getTypeSize(SizeTy));
3609 llvm::Instruction *IsActive = Builder.CreateUnreachable();
3701 llvm::CallInst *call = Builder.CreateCall(
3715 Builder.CreateInvoke(callee,
3723 llvm::CallInst *call = Builder.CreateCall(callee, args, BundleList);
3726 Builder.CreateUnreachable();
3758 Inst = Builder.CreateCall(Callee, Args, BundleList, Name);
3761 Inst = Builder.CreateInvoke(Callee, ContBB, InvokeDest, Args, BundleList,
3873 Builder.CreateStructGEP(ArgMemory, RetAI.getInAllocaFieldIndex());
3874 Builder.CreateStore(SRetPtr.getPointer(), Addr);
3914 CGBuilderTy::InsertPoint IP = Builder.saveIP();
3915 Builder.SetInsertPoint(Placeholder);
3917 Builder.CreateStructGEP(ArgMemory, ArgInfo.getInAllocaFieldIndex());
3918 Builder.restoreIP(IP);
3923 Builder.CreateStructGEP(ArgMemory, ArgInfo.getInAllocaFieldIndex());
3930 Addr = Builder.CreateBitCast(Addr, MemType);
4041 V = Builder.CreateLoad(
4060 llvm::Value *errorValue = Builder.CreateLoad(swiftErrorArg);
4061 Builder.CreateStore(errorValue, swiftErrorTemp);
4067 V = Builder.CreateZExt(V, ArgInfo.getCoerceToType());
4073 V = Builder.CreateBitCast(V, IRFuncTy->getParamType(FirstIRArg));
4109 Builder.CreateMemCpy(TempAlloca, Src, SrcSize);
4112 Src = Builder.CreateBitCast(Src,
4118 Address EltPtr = Builder.CreateStructGEP(Src, i);
4119 llvm::Value *LI = Builder.CreateLoad(EltPtr);
4160 Builder.CreateStore(RV.getScalarVal(), addr);
4163 addr = Builder.CreateElementBitCast(addr, coercionType);
4169 Address eltAddr = Builder.CreateStructGEP(addr, i);
4170 llvm::Value *elt = Builder.CreateLoad(eltAddr);
4203 Builder.CreateBitCast(CalleePtr, IRFuncTy->getPointerTo(CalleeAS));
4220 Arg = Builder.CreateBitCast(Arg, LastParamTy);
4360 CI = Builder.CreateCall(IRFuncTy, CalleePtr, IRCallArgs, BundleList);
4363 CI = Builder.CreateInvoke(IRFuncTy, CalleePtr, Cont, InvokeDest, IRCallArgs,
4388 PGO.valueProfile(Builder, llvm::IPVK_IndirectCallTarget,
4430 llvm::IRBuilder<>::InsertPointGuard IPGuard(Builder);
4431 Builder.SetInsertPoint(CI);
4440 Builder.ClearInsertionPoint();
4453 llvm::Value *errorResult = Builder.CreateLoad(swiftErrorTemp);
4454 Builder.CreateStore(errorResult, swiftErrorArg);
4473 addr = Builder.CreateElementBitCast(addr, coercionType);
4482 Address eltAddr = Builder.CreateStructGEP(addr, i);
4485 elt = Builder.CreateExtractValue(elt, unpaddedIndex++);
4488 Builder.CreateStore(elt, eltAddr);
4513 llvm::Value *Real = Builder.CreateExtractValue(CI, 0);
4514 llvm::Value *Imag = Builder.CreateExtractValue(CI, 1);
4533 V = Builder.CreateBitCast(V, RetIRTy);
tools/clang/lib/CodeGen/CGClass.cpp 218 V = Builder.CreateElementBitCast(V, Int8Ty);
219 V = Builder.CreateConstInBoundsByteGEP(V, Offset);
221 V = Builder.CreateElementBitCast(V, ConvertType(Base));
241 baseOffset = CGF.Builder.CreateAdd(virtualOffset, baseOffset);
250 ptr = CGF.Builder.CreateBitCast(ptr, CGF.Int8Ty->getPointerTo(AddrSpace));
251 ptr = CGF.Builder.CreateInBoundsGEP(ptr, baseOffset, "add.ptr");
321 return Builder.CreateBitCast(Value, BasePtrTy);
330 origBB = Builder.GetInsertBlock();
334 llvm::Value *isNull = Builder.CreateIsNull(Value.getPointer());
335 Builder.CreateCondBr(isNull, endBB, notNullBB);
358 Value = Builder.CreateBitCast(Value, BasePtrTy);
362 llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
363 Builder.CreateBr(endBB);
366 llvm::PHINode *PHI = Builder.CreatePHI(BasePtrTy, 2, "cast.result");
394 return Builder.CreateBitCast(BaseAddr, DerivedPtrTy);
406 llvm::Value *IsNull = Builder.CreateIsNull(BaseAddr.getPointer());
407 Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
412 llvm::Value *Value = Builder.CreateBitCast(BaseAddr.getPointer(), Int8PtrTy);
413 Value = Builder.CreateInBoundsGEP(Value, Builder.CreateNeg(NonVirtualOffset),
413 Value = Builder.CreateInBoundsGEP(Value, Builder.CreateNeg(NonVirtualOffset),
417 Value = Builder.CreateBitCast(Value, DerivedPtrTy);
421 Builder.CreateBr(CastEnd);
423 Builder.CreateBr(CastEnd);
426 llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
474 VTT = Builder.CreateConstInBoundsGEP1_64(VTT, SubVTTIndex);
478 VTT = Builder.CreateConstInBoundsGEP2_64(VTT, 0, SubVTTIndex);
649 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(Args[SrcArgIndex]));
802 ThisPtr = Builder.CreatePtrToInt(ThisPtr, IntPtrTy);
814 Builder.CreateCall(
815 F, {Builder.CreateAdd(ThisPtr, Builder.getIntN(PtrSize, EndOffset)),
815 F, {Builder.CreateAdd(ThisPtr, Builder.getIntN(PtrSize, EndOffset)),
816 Builder.getIntN(PtrSize, PoisonSize)});
960 llvm::Value *SrcPtr = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(SrcRec));
983 DestPtr = CGF.Builder.CreateBitCast(DestPtr, DBP);
988 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, SBP);
990 CGF.Builder.CreateMemCpy(DestPtr, SrcPtr, Size.getQuantity());
1297 CXXThisValue = Builder.CreateLaunderInvariantGroup(LoadCXXThis());
1303 Builder.CreateBr(BaseCtorContinueBB);
1314 CXXThisValue = Builder.CreateLaunderInvariantGroup(LoadCXXThis());
1433 Builder.CreateUnreachable();
1434 Builder.ClearInsertionPoint();
1505 CXXThisValue = Builder.CreateLaunderInvariantGroup(LoadCXXThis());
1576 = CGF.Builder.CreateIsNull(ShouldDeleteCondition);
1577 CGF.Builder.CreateCondBr(ShouldCallDelete, continueBB, callDeleteBB);
1591 CGF.Builder.CreateBr(continueBB);
1640 llvm::Value *Args[] = {CGF.Builder.CreateBitCast(Ptr, CGF.VoidPtrTy),
1716 llvm::Value *OffsetPtr = CGF.Builder.CreateGEP(
1717 CGF.Builder.CreateBitCast(CGF.LoadCXXThis(), CGF.Int8PtrTy),
1935 llvm::Value *iszero = Builder.CreateIsNull(numElements, "isempty");
1936 zeroCheckBranch = Builder.CreateCondBr(iszero, loopBB, loopBB);
1942 llvm::Value *arrayEnd = Builder.CreateInBoundsGEP(arrayBegin, numElements,
1946 llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1949 llvm::PHINode *cur = Builder.CreatePHI(arrayBegin->getType(), 2,
2002 Builder.CreateInBoundsGEP(cur, llvm::ConstantInt::get(SizeTy, 1),
2004 cur->addIncoming(next, Builder.GetInsertBlock());
2007 llvm::Value *done = Builder.CreateICmpEQ(next, arrayEnd, "arrayctor.done");
2009 Builder.CreateCondBr(done, contBB, loopBB);
2289 Builder.CreateICmpEQ(VPtrValue, VTableGlobal, "cmp.vtables");
2290 Builder.CreateAssumption(Cmp);
2314 Src = Builder.CreateBitCast(Src, t);
2494 VTableField = Builder.CreateBitCast(VTableField, VTablePtrTy->getPointerTo());
2495 VTableAddressPoint = Builder.CreateBitCast(VTableAddressPoint, VTablePtrTy);
2497 llvm::StoreInst *Store = Builder.CreateStore(VTableAddressPoint, VTableField);
2591 Address VTablePtrSrc = Builder.CreateElementBitCast(This, VTableTy);
2592 llvm::Instruction *VTable = Builder.CreateLoad(VTablePtrSrc, "vtable");
2650 llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
2652 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::type_test),
2654 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::assume), TypeTest);
2692 Builder.CreateIsNotNull(Derived, "cast.nonnull");
2697 Builder.CreateCondBr(DerivedNotNull, CheckBlock, ContBlock);
2709 Builder.CreateBr(ContBlock);
2758 llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
2759 llvm::Value *TypeTest = Builder.CreateCall(
2782 llvm::Value *ValidVtable = Builder.CreateCall(
2815 llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
2816 llvm::Value *CheckedLoad = Builder.CreateCall(
2820 llvm::Value *CheckResult = Builder.CreateExtractValue(CheckedLoad, 1);
2830 return Builder.CreateBitCast(
2831 Builder.CreateExtractValue(CheckedLoad, 0),
tools/clang/lib/CodeGen/CGCleanup.cpp 46 CGF.Builder.CreateStore(V, addr);
55 CGF.Builder.CreateStore(V.first, CGF.Builder.CreateStructGEP(addr, 0));
55 CGF.Builder.CreateStore(V.first, CGF.Builder.CreateStructGEP(addr, 0));
56 CGF.Builder.CreateStore(V.second, CGF.Builder.CreateStructGEP(addr, 1));
56 CGF.Builder.CreateStore(V.second, CGF.Builder.CreateStructGEP(addr, 1));
68 CGF.Builder.CreateStore(V.getPointer(), addr);
85 return RValue::get(CGF.Builder.CreateLoad(getSavingAddress(Value)));
89 auto addr = CGF.Builder.CreateLoad(getSavingAddress(Value));
95 CGF.Builder.CreateLoad(CGF.Builder.CreateStructGEP(address, 0));
95 CGF.Builder.CreateLoad(CGF.Builder.CreateStructGEP(address, 0));
97 CGF.Builder.CreateLoad(CGF.Builder.CreateStructGEP(address, 1));
97 CGF.Builder.CreateLoad(CGF.Builder.CreateStructGEP(address, 1));
280 Builder.getInt1Ty(), CharUnits::One(), "cleanup.cond");
284 setBeforeOutermostConditional(Builder.getFalse(), active);
287 Builder.CreateStore(Builder.getTrue(), active);
287 Builder.CreateStore(Builder.getTrue(), active);
339 createStoreInstBefore(CGF.Builder.getInt32(Fixup.DestinationIndex),
349 Switch->addCase(CGF.Builder.getInt32(Fixup.DestinationIndex),
409 Switch->addCase(Builder.getInt32(Fixup.DestinationIndex), Block);
467 *ReloadedValue = Builder.CreateLoad(Tmp);
533 bool WasInsertBlock = CGF.Builder.GetInsertBlock() == Entry;
534 assert(!WasInsertBlock || CGF.Builder.GetInsertPoint() == Entry->end());
550 CGF.Builder.SetInsertPoint(Pred);
566 = CGF.Builder.CreateLoad(ActiveFlag, "cleanup.is_active");
567 CGF.Builder.CreateCondBr(IsActive, CleanupBB, ContBB);
676 llvm::BasicBlock *FallthroughSource = Builder.GetInsertBlock();
792 Builder.CreateStore(Builder.getInt32(0), getNormalCleanupDestSlot());
792 Builder.CreateStore(Builder.getInt32(0), getNormalCleanupDestSlot());
798 savedInactiveFallthroughIP = Builder.saveAndClearIP();
875 Switch->addCase(Builder.getInt32(0), FallthroughDest);
900 llvm::BasicBlock *NormalExit = Builder.GetInsertBlock();
910 createStoreInstBefore(Builder.getInt32(Fixup.DestinationIndex),
927 Builder.restoreIP(savedInactiveFallthroughIP);
943 Builder.ClearInsertionPoint();
966 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
985 CurrentFuncletPad = CPI = Builder.CreateCleanupPad(ParentPad);
1002 Builder.CreateCleanupRet(CPI, NextAction);
1004 Builder.CreateBr(NextAction);
1010 Builder.restoreIP(SavedIP);
1052 llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock());
1063 Builder.ClearInsertionPoint();
1076 Builder.ClearInsertionPoint();
1083 llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex());
1117 Builder.ClearInsertionPoint();
1205 var = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), CharUnits::One(),
1213 llvm::Constant *value = CGF.Builder.getInt1(kind == ForDeactivation);
1224 CGF.Builder.CreateStore(CGF.Builder.getInt1(kind == ForActivation), var);
1224 CGF.Builder.CreateStore(CGF.Builder.getInt1(kind == ForActivation), var);
1252 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1254 Builder.restoreIP(SavedIP);
1267 CreateDefaultAlignTempAlloca(Builder.getInt32Ty(), "cleanup.dest.slot");
tools/clang/lib/CodeGen/CGCoroutine.cpp 196 auto &Builder = CGF.Builder;
206 CGF.Builder.CreateCondBr(SuspendRet, RealSuspendBlock, ReadyBlock);
403 auto *CoroEnd = CGF.Builder.CreateCall(
404 CoroEndFn, {NullPtr, CGF.Builder.getTrue()}, Bundles);
410 CGF.Builder.CreateCondBr(CoroEnd, ResumeBB, CleanupContBB);
433 BasicBlock *SaveInsertBlock = CGF.Builder.GetInsertBlock();
453 CGF.Builder.SetInsertPoint(InsertPt);
457 auto *Cond = CGF.Builder.CreateICmpNE(CoroFree, NullPtr);
458 CGF.Builder.CreateCondBr(Cond, FreeBB, AfterFreeBB);
462 CGF.Builder.SetInsertPoint(AfterFreeBB);
478 : CGF(CGF), Builder(CGF.Builder), S(S), GroActiveFlag(Address::invalid()),
537 const bool CanFallthrough = CGF.Builder.GetInsertBlock();
544 auto *NullPtr = llvm::ConstantPointerNull::get(Builder.getInt8PtrTy());
548 auto *EntryBB = Builder.GetInsertBlock();
554 auto *CoroId = Builder.CreateCall(
556 {Builder.getInt32(NewAlign), NullPtr, NullPtr, NullPtr});
562 auto *CoroAlloc = Builder.CreateCall(
565 Builder.CreateCondBr(CoroAlloc, AllocBB, InitBB);
569 auto *AllocOrInvokeContBB = Builder.GetInsertBlock();
577 auto *Cond = Builder.CreateICmpNE(AllocateCall, NullPtr);
578 Builder.CreateCondBr(Cond, InitBB, RetOnFailureBB);
585 Builder.CreateBr(InitBB);
591 auto *Phi = Builder.CreatePHI(VoidPtrTy, 2);
594 auto *CoroBegin = Builder.CreateCall(
649 Value *SkipBody = Builder.CreateFlagLoad(CurCoro.Data->ResumeEHVar,
651 Builder.CreateCondBr(SkipBody, ContBB, BodyBB);
673 const bool CanFallthrough = Builder.GetInsertBlock();
689 Builder.CreateCall(CoroEnd, {NullPtr, Builder.getFalse()});
689 Builder.CreateCall(CoroEnd, {NullPtr, Builder.getFalse()});
710 auto NullPtr = llvm::ConstantPointerNull::get(Builder.getInt8PtrTy());
738 llvm::CallInst *Call = Builder.CreateCall(F, Args);
tools/clang/lib/CodeGen/CGDebugInfo.cpp 100 OriginalLocation = CGF->Builder.getCurrentDebugLocation();
106 DI->EmitLocation(CGF->Builder, TemporaryLocation);
111 CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc());
117 CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
132 OriginalLocation = CGF.Builder.getCurrentDebugLocation();
134 CGF.Builder.SetCurrentDebugLocation(std::move(Loc));
141 CGF->Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
154 CGF.Builder.getCurrentDebugLocation()->getInlinedAt()) &&
157 DI.EmitInlineFunctionStart(CGF.Builder, InlinedFn);
164 DI.EmitInlineFunctionEnd(CGF->Builder);
165 DI.EmitLocation(CGF->Builder, SavedLocation);
tools/clang/lib/CodeGen/CGDecl.cpp 494 CGF.Builder.CreateFlagLoad(NRVOFlag, "nrvo.val");
495 CGF.Builder.CreateCondBr(DidNRVO, SkipDtorBB, RunDtorBB);
537 llvm::Value *V = CGF.Builder.CreateLoad(Stack);
539 CGF.Builder.CreateCall(F, V);
582 CGF.Builder.CreateBitCast(Addr, CGF.ConvertType(ArgTy));
689 srcAddr = CGF.Builder.CreateElementBitCast(srcAddr,
731 llvm::Value *IsNotNull = Builder.CreateIsNotNull(RHS);
1295 Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
1297 Builder.CreateCall(CGM.getLLVMLifetimeStartFn(), {SizeV, Addr});
1306 Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
1308 Builder.CreateCall(CGM.getLLVMLifetimeEndFn(), {Size, Addr});
1334 Builder.CreateStore(VlaSize.NumElts, SizeExprAddr);
1365 Builder);
1460 llvm::Value *Zero = Builder.getFalse();
1464 Builder.CreateStore(Zero, NRVOFlag);
1530 llvm::Value *V = Builder.CreateCall(F);
1531 Builder.CreateStore(V, Stack);
1567 (void)DI->EmitDeclareOfAutoVariable(&D, DebugAddr.getPointer(), Builder,
1672 emitStoresForZeroInit(CGM, D, Loc, isVolatile, Builder);
1675 emitStoresForPatternInit(CGM, D, Loc, isVolatile, Builder);
1698 SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(EltSize));
1699 Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, 0), SizeVal,
1711 llvm::Value *IsZeroSizedVLA = Builder.CreateICmpEQ(
1714 Builder.CreateCondBr(IsZeroSizedVLA, ContBB, SetupBB);
1717 SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(EltSize));
1720 Address Begin = Builder.CreateElementBitCast(Loc, Int8Ty, "vla.begin");
1722 Builder.CreateInBoundsGEP(Begin.getPointer(), SizeVal, "vla.end");
1723 llvm::BasicBlock *OriginBB = Builder.GetInsertBlock();
1725 llvm::PHINode *Cur = Builder.CreatePHI(Begin.getType(), 2, "vla.cur");
1728 Builder.CreateMemCpy(Address(Cur, CurAlign),
1730 CGM, D, Builder, Constant, ConstantAlign),
1733 Builder.CreateInBoundsGEP(Int8Ty, Cur, BaseSizeInChars, "vla.next");
1734 llvm::Value *Done = Builder.CreateICmpEQ(Next, End, "vla-init.isdone");
1735 Builder.CreateCondBr(Done, ContBB, LoopBB);
1851 CGM, D, (Loc.getType() == BP) ? Loc : Builder.CreateBitCast(Loc, BP),
1852 type.isVolatileQualified(), Builder, constant);
2125 llvm::Value *end = Builder.CreateInBoundsGEP(begin, length);
2155 llvm::Value *isEmpty = Builder.CreateICmpEQ(begin, end,
2157 Builder.CreateCondBr(isEmpty, doneBB, bodyBB);
2161 llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
2164 Builder.CreatePHI(begin->getType(), 2, "arraydestroy.elementPast");
2169 llvm::Value *element = Builder.CreateInBoundsGEP(elementPast, negativeOne,
2183 llvm::Value *done = Builder.CreateICmpEQ(element, begin, "arraydestroy.done");
2184 Builder.CreateCondBr(done, doneBB, bodyBB);
2185 elementPast->addIncoming(element, Builder.GetInsertBlock());
2210 begin = CGF.Builder.CreateInBoundsGEP(begin, gepIndices, "pad.arraybegin");
2211 end = CGF.Builder.CreateInBoundsGEP(end, gepIndices, "pad.arrayend");
2265 llvm::Value *arrayEnd = CGF.Builder.CreateLoad(ArrayEndPointer);
2361 ? Builder.CreateLoad(Arg.getIndirectAddress())
2378 DeclPtr = Builder.CreateBitCast(DeclPtr, IRTy, D.getName());
2449 ArgVal = Builder.CreateLoad(DeclPtr);
2499 DI->EmitDeclareOfArgVariable(&D, DeclPtr.getPointer(), ArgNo, Builder);
2514 Builder.CreateAnd(RetValNullabilityPrecondition,
2515 Builder.CreateIsNotNull(Arg.getAnyValue()));
tools/clang/lib/CodeGen/CGDeclCXX.cpp 169 Builder.CreateCall(InvariantStart, Args);
248 llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr);
331 Builder.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights);
683 llvm::Value *GuardVal = Builder.CreateLoad(Guard);
684 llvm::Value *Uninit = Builder.CreateIsNull(GuardVal,
694 Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(),1), Guard);
719 Builder.CreateBr(ExitBlock);
744 llvm::CallInst *CI = Builder.CreateCall(CalleeTy, Callee, Arg);
tools/clang/lib/CodeGen/CGException.cpp 386 Address typedAddr = Builder.CreateBitCast(addr, ty);
416 return Builder.CreateLoad(getExceptionSlot(), "exn");
420 return Builder.CreateLoad(getEHSelectorSlot(), "sel");
502 llvm::Value *zero = CGF.Builder.getInt32(0);
504 CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails");
505 CGF.Builder.CreateCondBr(failsFilter, unexpectedBB,
518 CGF.Builder.CreateUnreachable();
770 CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP();
778 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0);
780 llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0);
781 Builder.CreateStore(LPadExn, getExceptionSlot());
782 llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1);
783 Builder.CreateStore(LPadSel, getEHSelectorSlot());
888 Builder.CreateBr(getEHDispatchBlock(EHStack.getInnermostEHScope()));
891 Builder.restoreIP(savedIP);
900 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP();
911 CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);
921 CGF.Builder.SetInsertPoint(Handler.Block);
924 CGF.Builder.CreateCatchPad(
925 CatchSwitch, {TypeInfo.RTTI, CGF.Builder.getInt32(TypeInfo.Flags),
928 CGF.Builder.CreateCatchPad(CatchSwitch, {TypeInfo.RTTI});
933 CGF.Builder.restoreIP(SavedIP);
944 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP();
955 CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);
972 auto *CPI = CGF.Builder.CreateCatchPad(CatchSwitch, CatchTypes);
981 llvm::CallInst *Exn = CGF.Builder.CreateCall(GetExnFn, CPI);
982 CGF.Builder.CreateStore(Exn, CGF.getExceptionSlot());
983 llvm::CallInst *Selector = CGF.Builder.CreateCall(GetSelectorFn, CPI);
990 CGF.Builder.CreateBr(CatchScope.getHandler(0).Block);
991 CGF.Builder.restoreIP(SavedIP);
1029 llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(TypeIDFn, TypeInfo.RTTI);
1033 CGF.Builder.CreateICmpEQ(Selector, TypeIndex, "matches");
1034 CGF.Builder.CreateCondBr(MatchesTypeIndex, Handler.Block, NextBlock);
1042 CGF.Builder.restoreIP(SavedIP);
1065 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP();
1084 typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy);
1110 CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue);
1114 CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches");
1115 CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock);
1119 CGF.Builder.restoreIP(savedIP);
1162 Builder.CreateBr(ContBB);
1229 Builder.CreateUnreachable();
1230 Builder.ClearInsertionPoint();
1238 Builder.CreateBr(ContBB);
1258 Builder.SetInsertPoint(RethrowBlock);
1282 CGF.Builder.CreateFlagLoad(ForEHVar, "finally.endcatch");
1283 CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB);
1312 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(),
1325 CGF.Builder.CreateFlagLoad(ForEHVar, "finally.shouldthrow");
1326 CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB);
1331 CGF.Builder.CreateAlignedLoad(SavedExnVar, CGF.getPointerAlign()));
1335 CGF.Builder.CreateUnreachable();
1340 CGF.Builder.CreateStore(SavedCleanupDest,
1348 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
1350 CGF.Builder.restoreIP(SavedIP);
1402 ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh");
1403 CGF.Builder.CreateFlagStore(false, ForEHVar);
1427 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP();
1441 CGF.Builder.CreateAlignedStore(exn, SavedExnVar, CGF.getPointerAlign());
1445 CGF.Builder.CreateFlagStore(true, ForEHVar);
1450 CGF.Builder.restoreIP(savedIP);
1461 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1465 Builder.SetInsertPoint(TerminateLandingPad);
1474 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0);
1479 Exn = Builder.CreateExtractValue(LPadInst, 0);
1483 Builder.CreateUnreachable();
1486 Builder.restoreIP(SavedIP);
1498 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1499 Builder.SetInsertPoint(TerminateHandler);
1507 Builder.CreateUnreachable();
1510 Builder.restoreIP(SavedIP);
1523 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1528 Builder.SetInsertPoint(TerminateFunclet);
1537 CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad);
1547 Exn = Builder.CreateCall(GetExnFn, CurrentFuncletPad);
1552 Builder.CreateUnreachable();
1555 Builder.restoreIP(SavedIP);
1563 CGBuilderTy::InsertPoint SavedIP = Builder.saveIP();
1567 Builder.SetInsertPoint(EHResumeBlock);
1577 Builder.CreateUnreachable();
1578 Builder.restoreIP(SavedIP);
1588 LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val");
1589 LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val");
1591 Builder.CreateResume(LPadVal);
1592 Builder.restoreIP(SavedIP);
1634 FP = CGF.Builder.CreateCall(LocalAddrFn);
1902 R = Builder.CreateIntCast(R, ConvertType(getContext().LongTy),
1904 Builder.CreateStore(R, ReturnValue);
1940 SEHInfo = Builder.CreateConstInBoundsGEP1_32(Int8Ty, EntryFP, -20);
1941 SEHInfo = Builder.CreateBitCast(SEHInfo, Int8PtrTy->getPointerTo());
1942 SEHInfo = Builder.CreateAlignedLoad(Int8PtrTy, SEHInfo, getPointerAlign());
1956 llvm::Value *Ptrs = Builder.CreateBitCast(SEHInfo, PtrsTy->getPointerTo());
1957 llvm::Value *Rec = Builder.CreateStructGEP(PtrsTy, Ptrs, 0);
1958 Rec = Builder.CreateAlignedLoad(Rec, getPointerAlign());
1959 llvm::Value *Code = Builder.CreateAlignedLoad(Rec, getIntAlign());
1961 Builder.CreateStore(Code, SEHCodeSlotStack.back());
1975 return Builder.CreateLoad(SEHCodeSlotStack.back());
1982 return Builder.CreateZExt(&*AI, Int32Ty);
2057 Builder.CreateBr(ContBB);
2073 Builder.CreateCatchRet(CPI, ExceptBB);
2080 llvm::Value *Code = Builder.CreateCall(SEHCodeIntrin, {CPI});
2081 Builder.CreateStore(Code, SEHCodeSlotStack.back());
2091 Builder.CreateBr(ContBB);
2106 Builder.CreateUnreachable();
2107 Builder.ClearInsertionPoint();
tools/clang/lib/CodeGen/CGExpr.cpp 59 return Builder.CreateBitCast(value, destType);
89 llvm::IRBuilderBase::InsertPointGuard IPG(Builder);
94 Builder.SetInsertPoint(AllocaInsertPt);
110 return Builder.CreateAlloca(Ty, ArraySize, Name);
530 OldIP = Builder.saveIP();
532 Builder.restoreIP(CGBuilderTy::InsertPoint(
545 Builder.restoreIP(OldIP);
690 IsNonNull = Builder.CreateIsNotNull(Ptr);
703 Builder.CreateCondBr(IsNonNull, Rest, Done);
717 Size = Builder.CreateMul(Size, ArraySize);
728 llvm::Value *Min = Builder.getFalse();
729 llvm::Value *NullIsUnknown = Builder.getFalse();
730 llvm::Value *Dynamic = Builder.getFalse();
731 llvm::Value *CastAddr = Builder.CreateBitCast(Ptr, Int8PtrTy);
732 llvm::Value *LargeEnough = Builder.CreateICmpUGE(
733 Builder.CreateCall(F, {CastAddr, Min, NullIsUnknown, Dynamic}), Size);
750 PtrAsInt = Builder.CreatePtrToInt(Ptr, IntPtrTy);
751 llvm::Value *Align = Builder.CreateAnd(
754 Builder.CreateICmpEQ(Align, llvm::ConstantInt::get(IntPtrTy, 0));
786 IsNonNull = Builder.CreateIsNotNull(Ptr);
790 Builder.CreateCondBr(IsNonNull, VptrNotNull, Done);
812 Address VPtrAddr(Builder.CreateBitCast(Ptr, VPtrTy), getPointerAlign());
813 llvm::Value *VPtrVal = Builder.CreateLoad(VPtrAddr);
814 llvm::Value *High = Builder.CreateZExt(VPtrVal, Int64Ty);
816 llvm::Value *Hash = emitHash16Bytes(Builder, Low, High);
817 Hash = Builder.CreateTrunc(Hash, IntPtrTy);
824 llvm::Value *Slot = Builder.CreateAnd(Hash,
827 llvm::Value *Indices[] = { Builder.getInt32(0), Slot };
829 Builder.CreateAlignedLoad(Builder.CreateInBoundsGEP(Cache, Indices),
829 Builder.CreateAlignedLoad(Builder.CreateInBoundsGEP(Cache, Indices),
836 llvm::Value *EqualHash = Builder.CreateICmpEQ(CacheVal, Hash);
851 Builder.CreateBr(Done);
922 return Builder.CreateUDiv(SizeInBytes, SizeOfElement);
932 return CGF.Builder.getInt32(VT->getNumElements());
943 return CGF.Builder.getInt(CAT->getSize());
972 llvm::Value *IndexVal = Builder.CreateIntCast(Index, SizeTy, IndexSigned);
973 llvm::Value *BoundVal = Builder.CreateIntCast(Bound, SizeTy, false);
980 llvm::Value *Check = Accessed ? Builder.CreateICmpULT(IndexVal, BoundVal)
981 : Builder.CreateICmpULE(IndexVal, BoundVal);
998 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
1007 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
1093 ? Builder.CreateBitCast(Addr, ConvertType(E->getType()))
1094 : Builder.CreateAddrSpaceCast(Addr,
1617 Check = Builder.CreateICmpULE(Value, llvm::ConstantInt::get(Ctx, End));
1620 Builder.CreateICmpSLE(Value, llvm::ConstantInt::get(Ctx, End));
1622 Builder.CreateICmpSGE(Value, llvm::ConstantInt::get(Ctx, Min));
1623 Check = Builder.CreateAnd(Upper, Lower);
1653 Address Cast = Builder.CreateElementBitCast(Addr, vec4Ty, "castToVec4");
1655 llvm::Value *V = Builder.CreateLoad(Cast, Volatile, "loadVec4");
1658 V = Builder.CreateShuffleVector(V, llvm::UndefValue::get(vec4Ty),
1672 llvm::LoadInst *Load = Builder.CreateLoad(Addr, Volatile);
1675 Load->getContext(), llvm::ConstantAsMetadata::get(Builder.getInt32(1)));
1697 return Builder.CreateZExt(Value, ConvertTypeForMem(Ty), "frombool");
1710 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
1710 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
1729 llvm::Constant *Mask[] = {Builder.getInt32(0), Builder.getInt32(1),
1729 llvm::Constant *Mask[] = {Builder.getInt32(0), Builder.getInt32(1),
1730 Builder.getInt32(2),
1731 llvm::UndefValue::get(Builder.getInt32Ty())};
1733 Value = Builder.CreateShuffleVector(Value, llvm::UndefValue::get(VecTy),
1738 Addr = Builder.CreateElementBitCast(Addr, SrcTy, "storetmp");
1753 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
1757 llvm::ConstantAsMetadata::get(Builder.getInt32(1)));
1801 llvm::LoadInst *Load = Builder.CreateLoad(LV.getVectorAddress(),
1803 return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(),
1828 llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), "bf.load");
1834 Val = Builder.CreateShl(Val, HighBits, "bf.shl");
1836 Val = Builder.CreateAShr(Val, Info.Offset + HighBits, "bf.ashr");
1839 Val = Builder.CreateLShr(Val, Info.Offset, "bf.lshr");
1841 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(Info.StorageSize,
1845 Val = Builder.CreateIntCast(Val, ResLTy, Info.IsSigned, "bf.cast");
1853 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddress(),
1864 return RValue::get(Builder.CreateExtractElement(Vec, Elt));
1872 Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts)));
1875 Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()),
1888 Builder.CreateElementBitCast(VectorAddress, VectorElementTy,
1895 Builder.CreateConstInBoundsGEP(CastToPointerElement, ix,
1916 llvm::Value *Call = Builder.CreateCall(
1919 Call = Builder.CreateIntToPtr(Call, OrigTy);
1932 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddress(),
1934 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
1936 Builder.CreateStore(Vec, Dst.getVectorAddress(),
2004 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
2006 Builder.CreatePtrToInt(LvalueDst.getPointer(), ResultType,
2008 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
2034 SrcVal = Builder.CreateIntCast(SrcVal, Ptr.getElementType(),
2043 Builder.CreateLoad(Ptr, Dst.isVolatileQualified(), "bf.load");
2047 SrcVal = Builder.CreateAnd(SrcVal,
2053 SrcVal = Builder.CreateShl(SrcVal, Info.Offset, "bf.shl");
2056 Val = Builder.CreateAnd(Val,
2063 SrcVal = Builder.CreateOr(Val, SrcVal, "bf.set");
2069 Builder.CreateStore(SrcVal, Ptr, Dst.isVolatileQualified());
2080 ResultVal = Builder.CreateShl(ResultVal, HighBits, "bf.result.shl");
2081 ResultVal = Builder.CreateAShr(ResultVal, HighBits, "bf.result.ashr");
2085 ResultVal = Builder.CreateIntCast(ResultVal, ResLTy, Info.IsSigned,
2095 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddress(),
2110 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i);
2113 Vec = Builder.CreateShuffleVector(SrcVal,
2123 ExtMask.push_back(Builder.getInt32(i));
2127 Builder.CreateShuffleVector(SrcVal,
2133 Mask.push_back(Builder.getInt32(i));
2143 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts);
2145 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV);
2154 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt);
2157 Builder.CreateStore(Vec, Dst.getExtVectorAddress(),
2179 Value = Builder.CreatePtrToInt(Value, Ty);
2180 Builder.CreateCall(
2289 return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name);
2296 Addr = CGF.Builder.CreateElementBitCast(Addr, RealVarTy);
2323 llvm::LoadInst *Load = Builder.CreateLoad(RefLVal.getAddress(),
2346 llvm::Value *Addr = Builder.CreateLoad(Ptr);
2548 Addr = Builder.CreatePointerBitCastOrAddrSpaceCast(Addr, PTy);
2817 Builder.getInt16(TypeKind), Builder.getInt16(TypeInfo),
2817 Builder.getInt16(TypeKind), Builder.getInt16(TypeInfo),
2845 V = Builder.CreateBitCast(V, llvm::Type::getIntNTy(getLLVMContext(),
2852 return Builder.CreateZExt(V, TargetTy);
2857 Builder.CreateStore(V, Ptr);
2860 return Builder.CreatePtrToInt(V, TargetTy);
2915 llvm::Constant *Data[] = {Filename, Builder.getInt32(Line),
2916 Builder.getInt32(Column)};
2965 if (!CGF.Builder.getCurrentDebugLocation()) {
2999 CGF.Builder.CreateUnreachable();
3001 CGF.Builder.CreateBr(ContBB);
3027 Cond = Cond ? Builder.CreateAnd(Cond, Check) : Check;
3037 JointCond = Builder.CreateAnd(FatalCond, RecoverableCond);
3054 llvm::Instruction *Branch = Builder.CreateCondBr(JointCond, Cont, Handlers);
3079 Args.push_back(Builder.CreateBitCast(InfoPtr, Int8PtrTy));
3103 Builder.CreateCondBr(FatalCond, NonFatalHandlerBB, FatalHandlerBB);
3121 llvm::BranchInst *BI = Builder.CreateCondBr(Cond, Cont, CheckBB);
3145 CheckCall = Builder.CreateCall(
3146 SlowPathFn, {TypeId, Ptr, Builder.CreateBitCast(InfoPtr, Int8PtrTy)});
3151 CheckCall = Builder.CreateCall(SlowPathFn, {TypeId, Ptr});
3222 Builder.CreateICmpNE(Data, llvm::ConstantPointerNull::get(Int8PtrTy));
3230 llvm::Value *V = Builder.CreateConstGEP2_32(
3232 Builder.CreatePointerCast(Data, CfiCheckFailDataTy->getPointerTo(0)), 0,
3235 llvm::Value *CheckKind = Builder.CreateLoad(CheckKindAddr);
3240 llvm::Value *ValidVtable = Builder.CreateZExt(
3241 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::type_test),
3257 Builder.CreateICmpNE(CheckKind, llvm::ConstantInt::get(Int8Ty, Kind));
3274 EmitCheck(std::make_pair(static_cast<llvm::Value *>(Builder.getFalse()),
3279 Builder.CreateUnreachable();
3289 Builder.CreateCondBr(Checked, Cont, TrapBB);
3294 Builder.CreateUnreachable();
3296 Builder.CreateCondBr(Checked, Cont, TrapBB);
3303 llvm::CallInst *TrapCall = Builder.CreateCall(CGM.getIntrinsic(IntrID));
3327 Addr = Builder.CreateElementBitCast(Addr, NewTy);
3334 Addr = Builder.CreateConstArrayGEP(Addr, 0, "arraydecay");
3346 return Builder.CreateElementBitCast(Addr, ConvertTypeForMem(EltType));
3377 return CGF.Builder.CreateGEP(ptr, indices, name);
3441 eltPtr = CGF.Builder.CreatePreserveArrayAccessIndex(addr.getPointer(),
3472 Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom");
3524 Idx = Builder.CreateMul(Idx, numElements);
3526 Idx = Builder.CreateNSWMul(Idx, numElements);
3544 llvm::Value *ScaledIdx = Builder.CreateMul(Idx, InterfaceSizeVal);
3551 Addr = Builder.CreateElementBitCast(Addr, Int8Ty);
3562 Addr = Builder.CreateBitCast(Addr, OrigBaseTy);
3622 Addr = CGF.Builder.CreateElementBitCast(Addr, NewTy);
3629 Addr = CGF.Builder.CreateConstArrayGEP(Addr, 0, "arraydecay");
3632 return CGF.Builder.CreateElementBitCast(Addr,
3641 return Address(CGF.Builder.CreateLoad(BaseLVal.getAddress()), Align);
3660 Idx = Builder.CreateIntCast(
3692 ? Builder.CreateIntCast(
3698 ? Builder.CreateIntCast(
3702 Idx = Builder.CreateAdd(LowerBoundVal, LengthVal, "lb_add_len",
3706 Idx = Builder.CreateSub(
3726 auto *LengthVal = Builder.CreateIntCast(
3729 Idx = Builder.CreateSub(
3759 Idx = Builder.CreateMul(Idx, NumElements);
3761 Idx = Builder.CreateNSWMul(Idx, NumElements);
3827 Builder.CreateStore(Vec, VecMem);
3932 Base = CGF.Builder.CreateElementBitCast(Base, CGF.Int8Ty);
3933 return CGF.Builder.CreateConstInBoundsByteGEP(Base, Offset);
3950 return CGF.Builder.CreateStructGEP(base, idx, field->getName());
3962 return CGF.Builder.CreatePreserveStructAccessIndex(
3998 Addr = Builder.CreateStructGEP(Addr, Idx, field->getName());
4003 Addr = Builder.CreatePreserveStructAccessIndex(Addr, Idx,
4012 Addr = Builder.CreateElementBitCast(Addr, FieldIntTy);
4068 auto *stripped = Builder.CreateStripInvariantGroup(addr.getPointer());
4080 addr = Address(Builder.CreateLaunderInvariantGroup(addr.getPointer()),
4088 Builder.CreatePreserveUnionAccessIndex(
4094 addr = Builder.CreateElementBitCast(
4122 addr = Builder.CreateElementBitCast(
4150 V = Builder.CreateElementBitCast(V, llvmType, Field->getName());
4247 lhsBlock = Builder.GetInsertBlock();
4249 Builder.CreateBr(contBlock);
4259 rhsBlock = Builder.GetInsertBlock();
4264 llvm::PHINode *phi = Builder.CreatePHI(lhs->getPointer()->getType(),
4417 Address V = Builder.CreateBitCast(LV.getAddress(),
4439 Address V = Builder.CreateElementBitCast(LV.getAddress(),
4690 return Builder.CreateElementBitCast(CGM.GetAddrOfUuidDescriptor(E),
4806 llvm::Value *CalleePrefixStruct = Builder.CreateBitCast(
4809 Builder.CreateConstGEP2_32(PrefixStructTy, CalleePrefixStruct, 0, 0);
4811 Builder.CreateAlignedLoad(CalleeSigPtr, getIntAlign());
4812 llvm::Value *CalleeSigMatch = Builder.CreateICmpEQ(CalleeSig, PrefixSig);
4816 Builder.CreateCondBr(CalleeSigMatch, TypeCheck, Cont);
4820 Builder.CreateConstGEP2_32(PrefixStructTy, CalleePrefixStruct, 0, 1);
4822 Builder.CreateAlignedLoad(CalleeRTTIPtr, getPointerAlign());
4826 Builder.CreateICmpEQ(CalleeRTTI, FTRTTIConst);
4833 Builder.CreateBr(Cont);
4856 llvm::Value *CastedCallee = Builder.CreateBitCast(CalleePtr, Int8PtrTy);
4857 llvm::Value *TypeTest = Builder.CreateCall(
4878 Args.add(RValue::get(Builder.CreateBitCast(Chain, CGM.VoidPtrTy)),
4938 CalleePtr = Builder.CreateBitCast(CalleePtr, CalleeTy, "callee.knr.cast");
tools/clang/lib/CodeGen/CGExprAgg.cpp 61 : CGF(cgf), Builder(CGF.Builder), Dest(Dest),
785 CGF.Builder.CreateStructGEP(valueDest.getAddress(), 0);
1226 CGF.Builder.CreateBr(ContBlock);
1318 CleanupDominator = CGF.Builder.CreateAlignedLoad(
1504 cleanupDominator = CGF.Builder.CreateAlignedLoad(
1834 llvm::Constant *SizeVal = CGF.Builder.getInt64(Size.getQuantity());
1837 Loc = CGF.Builder.CreateElementBitCast(Loc, CGF.Int8Ty);
1838 CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, false);
1838 CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, false);
1967 SizeVal = Builder.CreateNUWMul(
1989 DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1990 SrcPtr = Builder.CreateElementBitCast(SrcPtr, Int8Ty);
2013 auto Inst = Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, isVolatile);
tools/clang/lib/CodeGen/CGExprCXX.cpp 148 EmitARCRelease(Builder.CreateLoad(BaseValue,
484 DestPtr = CGF.Builder.CreateElementBitCast(DestPtr, CGF.Int8Ty);
544 CGF.Builder.CreateMemCpy(
545 CGF.Builder.CreateConstInBoundsByteGEP(DestPtr, StoreOffset),
546 CGF.Builder.CreateConstInBoundsByteGEP(SrcPtr, StoreOffset),
558 CGF.Builder.CreateMemSet(
559 CGF.Builder.CreateConstInBoundsByteGEP(DestPtr, StoreOffset),
560 CGF.Builder.getInt8(0), StoreSizeVal);
813 hasOverflow = CGF.Builder.CreateICmpUGE(numElements, thresholdV);
814 numElements = CGF.Builder.CreateTrunc(numElements, CGF.SizeTy);
819 numElements = CGF.Builder.CreateSExt(numElements, CGF.SizeTy);
827 hasOverflow = CGF.Builder.CreateICmpSLT(numElements,
832 numElements = CGF.Builder.CreateZExt(numElements, CGF.SizeTy);
840 hasOverflow = CGF.Builder.CreateICmpULT(numElements,
846 hasOverflow = CGF.Builder.CreateOr(hasOverflow,
847 CGF.Builder.CreateICmpULT(numElements,
868 CGF.Builder.CreateCall(umul_with_overflow, {size, tsmV});
870 llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
872 hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
876 size = CGF.Builder.CreateExtractValue(result, 0);
890 numElements = CGF.Builder.CreateMul(numElements, asmV);
907 CGF.Builder.CreateCall(uadd_with_overflow, {size, cookieSizeV});
909 llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
911 hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
915 size = CGF.Builder.CreateExtractValue(result, 0);
922 size = CGF.Builder.CreateSelect(hasOverflow,
1004 RemainingSize = Builder.CreateSub(RemainingSize, InitializedSize);
1008 Builder.CreateMemSet(CurPtr, Builder.getInt8(0), RemainingSize, false);
1008 Builder.CreateMemSet(CurPtr, Builder.getInt8(0), RemainingSize, false);
1035 Address(Builder.CreateInBoundsGEP(CurPtr.getPointer(),
1036 Builder.getSize(InitListElements),
1059 CurPtr = Builder.CreateElementBitCast(CurPtr, ElementTy);
1071 CleanupDominator = Builder.CreateStore(BeginPtr.getPointer(), EndOfInit);
1085 Builder.CreateBitCast(CurPtr.getPointer(), BeginPtr.getType());
1086 Builder.CreateStore(FinishedPtr, EndOfInit);
1094 CurPtr = Address(Builder.CreateInBoundsGEP(CurPtr.getPointer(),
1095 Builder.getSize(1),
1115 CurPtr = Builder.CreateBitCast(CurPtr, BeginPtr.getType());
1149 Builder.CreateStore(CurPtr.getPointer(), EndOfInit);
1153 NumElements = Builder.CreateSub(
1207 llvm::BasicBlock *EntryBB = Builder.GetInsertBlock();
1213 Builder.CreateInBoundsGEP(BeginPtr.getPointer(), NumElements, "array.end");
1219 Builder.CreateICmpEQ(CurPtr.getPointer(), EndPtr, "array.isempty");
1220 Builder.CreateCondBr(IsEmpty, ContBB, LoopBB);
1228 Builder.CreatePHI(CurPtr.getType(), 2, "array.cur");
1235 Builder.CreateStore(CurPtr.getPointer(), EndOfInit);
1243 CleanupDominator = Builder.CreateUnreachable();
1258 Builder.CreateConstInBoundsGEP1_32(ElementTy, CurPtr.getPointer(), 1,
1263 llvm::Value *IsEnd = Builder.CreateICmpEQ(NextPtr, EndPtr, "array.atend");
1264 Builder.CreateCondBr(IsEnd, ContBB, LoopBB);
1265 CurPtrPhi->addIncoming(NextPtr, Builder.GetInsertBlock());
1660 nullCheckBB = Builder.GetInsertBlock();
1665 Builder.CreateIsNull(allocation.getPointer(), "new.isnull");
1666 Builder.CreateCondBr(isNull, contBB, notNullBB);
1679 cleanupDominator = Builder.CreateUnreachable();
1692 Address result = Builder.CreateElementBitCast(allocation, elementTy);
1700 result = Address(Builder.CreateLaunderInvariantGroup(result.getPointer()),
1723 result = Builder.CreateBitCast(result, resultType);
1737 llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
1740 llvm::PHINode *PHI = Builder.CreatePHI(resultPtr->getType(), 2);
1768 llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
1788 Size = Builder.CreateMul(Size, NumElements);
1792 Size = Builder.CreateAdd(
1999 CGF.Builder.CreateInBoundsGEP(arrayBegin, numElements, "delete.end");
2022 llvm::Value *IsNull = Builder.CreateIsNull(Ptr.getPointer(), "isnull");
2024 Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
2041 llvm::Value *Zero = Builder.getInt32(0);
2056 Ptr = Address(Builder.CreateInBoundsGEP(Ptr.getPointer(), GEP, "del.first"),
2131 llvm::Value *IsNull = CGF.Builder.CreateIsNull(ThisPtr.getPointer());
2132 CGF.Builder.CreateCondBr(IsNull, BadTypeidBlock, EndBlock);
2150 return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy);
2163 return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(OperandTy),
2236 llvm::Value *IsNull = Builder.CreateIsNull(ThisAddr.getPointer());
2237 Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
2250 CastNotNull = Builder.GetInsertBlock();
2263 llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
tools/clang/lib/CodeGen/CGExprComplex.cpp 50 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) {
335 return Builder.CreateStructGEP(addr, 0, addr.getName() + ".realp");
340 return Builder.CreateStructGEP(addr, 1, addr.getName() + ".imagp");
tools/clang/lib/CodeGen/CGExprScalar.cpp 238 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
2750 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), size);
3202 return CGF.Builder.CreateIntToPtr(index, pointer->getType());
3207 index = CGF.Builder.CreateIntCast(index, DL.getIntPtrType(PtrTy), isSigned,
3213 index = CGF.Builder.CreateNeg(index, "idx.neg");
3228 index = CGF.Builder.CreateMul(index, objectSize);
3230 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
3231 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
3232 return CGF.Builder.CreateBitCast(result, pointer->getType());
3246 index = CGF.Builder.CreateMul(index, numElements, "vla.index");
3247 pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
3249 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
3261 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
3262 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
3263 return CGF.Builder.CreateBitCast(result, pointer->getType());
3267 return CGF.Builder.CreateGEP(pointer, index, "add.ptr");
3554 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
4490 Addr = Builder.CreateElementBitCast(Addr, ConvertType(E->getType()));
4655 Value *GEPVal = Builder.CreateInBoundsGEP(Ptr, IdxList, Name);
4665 Builder.GetInsertBlock()->getParent(), PtrTy->getPointerAddressSpace());
4680 EmitGEPOffsetInBytes(Ptr, GEPVal, getLLVMContext(), CGM, Builder);
4683 EvaluatedGEP.OffsetOverflows == Builder.getFalse()) &&
4696 auto *IntPtr = Builder.CreatePtrToInt(Ptr, IntPtrTy);
4697 auto *ComputedGEP = Builder.CreateAdd(IntPtr, EvaluatedGEP.TotalOffset);
4713 auto *BaseIsNotNullptr = Builder.CreateIsNotNull(Ptr);
4714 auto *ResultIsNotNullptr = Builder.CreateIsNotNull(ComputedGEP);
4717 ? Builder.CreateICmpEQ(BaseIsNotNullptr, ResultIsNotNullptr)
4718 : Builder.CreateAnd(BaseIsNotNullptr, ResultIsNotNullptr);
4728 auto *NoOffsetOverflow = Builder.CreateNot(EvaluatedGEP.OffsetOverflows);
4735 auto *PosOrZeroValid = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
4737 Builder.CreateICmpSGE(EvaluatedGEP.TotalOffset, Zero);
4738 llvm::Value *NegValid = Builder.CreateICmpULT(ComputedGEP, IntPtr);
4740 Builder.CreateSelect(PosOrZeroOffset, PosOrZeroValid, NegValid);
4746 ValidGEP = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
4752 ValidGEP = Builder.CreateICmpULE(ComputedGEP, IntPtr);
4754 ValidGEP = Builder.CreateAnd(ValidGEP, NoOffsetOverflow);
tools/clang/lib/CodeGen/CGGPUBuiltin.cpp 111 llvm::Value *P = Builder.CreateStructGEP(AllocaTy, Alloca, I - 1);
113 Builder.CreateAlignedStore(Arg, P, DL.getPrefTypeAlignment(Arg->getType()));
115 BufferPtr = Builder.CreatePointerCast(Alloca, llvm::Type::getInt8PtrTy(Ctx));
120 return RValue::get(Builder.CreateCall(
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp 354 CGF.Builder.CreateNUWMul(BaseEltSizeVal, NumElts);
355 Address BC = CGF.Builder.CreateBitCast(DstAddr, CGF.CGM.Int8PtrTy);
357 CGF.Builder.CreateInBoundsGEP(BC.getPointer(), SizeInBytes);
358 DstArrayEnd = CGF.Builder.CreateBitCast(DstArrayEnd, CGF.CGM.Int8PtrPtrTy,
360 llvm::BasicBlock *PreheaderBB = CGF.Builder.GetInsertBlock();
368 PHIs[I] = CGF.Builder.CreatePHI(CGF.CGM.Int8PtrPtrTy, 2, "addr.cur");
379 CGF.Builder.CreateICmpEQ(PHIs[DstIdx], DstArrayEnd, "done");
380 CGF.Builder.CreateCondBr(Done, ExitBB, LoopBB);
396 LoopBB = CGF.Builder.GetInsertBlock();
406 CGF.Builder.CreateBr(HeaderBB);
415 Addr = CGF->Builder.CreateBitCast(Addr, CGF->CGM.Int8PtrTy);
416 Addr = CGF->Builder.CreateConstInBoundsGEP(Addr, Offset.getQuantity());
417 return CGF->Builder.CreateBitCast(Addr, CGF->CGM.Int8PtrPtrTy);
471 llvm::Value *V = CGF->Builder.CreateLoad(CGF->GetAddrOfLocalVar(Args[I]));
489 CallerCGF.Builder.CreateBitCast(Addrs[I], CallerCGF.CGM.Int8PtrPtrTy)
524 this->CGF->Builder.CreateElementBitCast(DstAddr, this->CGF->Int8Ty);
526 this->CGF->Builder.CreateElementBitCast(SrcAddr, this->CGF->Int8Ty);
527 this->CGF->Builder.CreateMemCpy(DstAddr, SrcAddr, SizeVal, false);
532 DstAddr = this->CGF->Builder.CreateElementBitCast(DstAddr, Ty);
533 SrcAddr = this->CGF->Builder.CreateElementBitCast(SrcAddr, Ty);
534 llvm::Value *SrcVal = this->CGF->Builder.CreateLoad(SrcAddr, false);
535 this->CGF->Builder.CreateStore(SrcVal, DstAddr, false);
550 this->CGF->Builder.CreateBitCast(DstAddr, PtrTy), FT);
554 this->CGF->Builder.CreateBitCast(SrcAddr, PtrTy), FT);
558 Address DstAddr = this->CGF->Builder.CreateBitCast(Addrs[DstIdx], Ty);
559 Address SrcAddr = this->CGF->Builder.CreateBitCast(Addrs[SrcIdx], Ty);
655 llvm::Constant *SizeVal = CGF->Builder.getInt64(Size.getQuantity());
657 Address Loc = CGF->Builder.CreateElementBitCast(DstAddr, CGF->Int8Ty);
658 CGF->Builder.CreateMemSet(Loc, CGF->Builder.getInt8(0), SizeVal,
658 CGF->Builder.CreateMemSet(Loc, CGF->Builder.getInt8(0), SizeVal,
809 Address DstPtr = Builder.CreateBitCast(Dst.getAddress(), CGM.Int8PtrPtrTy);
821 Addrs[I] = CGF.Builder.CreateBitCast(Addrs[I], CGF.CGM.Int8PtrPtrTy);
tools/clang/lib/CodeGen/CGObjC.cpp 92 Address BitCast = Builder.CreateBitCast(Temporary, ConvertType(ArgQT));
103 llvm::Value *Cast = Builder.CreateBitCast(GV, ConvertType(EncodingQT));
113 return Builder.CreateBitCast(result.getScalarVal(),
138 return Builder.CreateBitCast(Ptr, ConvertType(E->getType()));
167 LValue LV = MakeAddrLValue(Builder.CreateConstArrayGEP(Objects, i),
178 LValue KeyLV = MakeAddrLValue(Builder.CreateConstArrayGEP(Keys, i),
185 LValue ValueLV = MakeAddrLValue(Builder.CreateConstArrayGEP(Objects, i),
236 return Builder.CreateBitCast(result.getScalarVal(),
277 return RValue::get(CGF.Builder.CreateBitCast(Result.getScalarVal(),
596 Builder.CreateStore(getNullForVariable(selfAddr), selfAddr);
636 newSelf = Builder.CreateBitCast(newSelf, selfTy);
638 Builder.CreateStore(newSelf, selfAddr);
738 Address dest = CGF.Builder.CreateBitCast(CGF.ReturnValue, CGF.VoidPtrTy);
741 src = CGF.Builder.CreateBitCast(src, CGF.VoidPtrTy);
746 args.add(RValue::get(CGF.Builder.getInt1(isAtomic)), Context.BoolTy);
747 args.add(RValue::get(CGF.Builder.getInt1(hasStrong)), Context.BoolTy);
1007 ivarAddr = CGF.Builder.CreateBitCast(ivarAddr, CGF.Int8PtrTy);
1066 ivarAddr = Builder.CreateBitCast(ivarAddr, bitcastType);
1067 llvm::LoadInst *load = Builder.CreateLoad(ivarAddr, "load");
1078 ivarVal = Builder.CreateTrunc(load, newTy);
1081 Builder.CreateStore(ivarVal,
1082 Builder.CreateBitCast(ReturnValue, bitcastType));
1102 Builder.CreateLoad(GetAddrOfLocalVar(getterMethod->getCmdDecl()), "cmd");
1103 llvm::Value *self = Builder.CreateBitCast(LoadObjCSelf(), VoidPtrTy);
1111 args.add(RValue::get(Builder.getInt1(strategy.isAtomic())),
1126 RV = RValue::get(Builder.CreateBitCast(
1183 value = Builder.CreateBitCast(
1210 ivarAddr = CGF.Builder.CreateBitCast(ivarAddr, CGF.Int8PtrTy);
1219 argAddr = CGF.Builder.CreateBitCast(argAddr, CGF.Int8PtrTy);
1228 args.add(RValue::get(CGF.Builder.getTrue()), CGF.getContext().BoolTy);
1232 args.add(RValue::get(CGF.Builder.getFalse()), CGF.getContext().BoolTy);
1256 ivarAddr = CGF.Builder.CreateBitCast(ivarAddr, CGF.Int8PtrTy);
1265 argAddr = CGF.Builder.CreateBitCast(argAddr, CGF.Int8PtrTy);
1351 argAddr = Builder.CreateElementBitCast(argAddr, bitcastType);
1352 ivarAddr = Builder.CreateElementBitCast(ivarAddr, bitcastType);
1355 llvm::Value *load = Builder.CreateLoad(argAddr);
1358 llvm::StoreInst *store = Builder.CreateStore(load, ivarAddr);
1389 Builder.CreateLoad(GetAddrOfLocalVar(setterMethod->getCmdDecl()));
1391 Builder.CreateBitCast(LoadObjCSelf(), VoidPtrTy);
1395 llvm::Value *arg = Builder.CreateLoad(argAddr, "arg");
1396 arg = Builder.CreateBitCast(arg, VoidPtrTy);
1410 args.add(RValue::get(Builder.getInt1(strategy.isAtomic())),
1412 args.add(RValue::get(Builder.getInt1(strategy.isCopy())),
1596 Builder.CreateBitCast(LoadObjCSelf(), Types.ConvertType(IdTy));
1634 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
1721 Builder.CreateCondBr(
1722 Builder.CreateICmpEQ(initialBufferLimit, zero, "iszero"), EmptyBB,
1733 Builder.CreateStructGEP(StatePtr, 2, "mutationsptr.ptr");
1735 = Builder.CreateLoad(StateMutationsPtrPtr, "mutationsptr");
1738 Builder.CreateAlignedLoad(StateMutationsPtr, getPointerAlign(),
1747 llvm::PHINode *index = Builder.CreatePHI(NSUIntegerTy, 3, "forcoll.index");
1751 llvm::PHINode *count = Builder.CreatePHI(NSUIntegerTy, 3, "forcoll.count");
1759 StateMutationsPtr = Builder.CreateLoad(StateMutationsPtrPtr, "mutationsptr");
1761 = Builder.CreateAlignedLoad(StateMutationsPtr, getPointerAlign(),
1767 Builder.CreateCondBr(Builder.CreateICmpEQ(currentMutations, initialMutations),
1767 Builder.CreateCondBr(Builder.CreateICmpEQ(currentMutations, initialMutations),
1773 Builder.CreateBitCast(Collection,
1815 Builder.CreateStructGEP(StatePtr, 1, "stateitems.ptr");
1817 Builder.CreateLoad(StateItemsPtr, "stateitems");
1821 Builder.CreateGEP(EnumStateItems, index, "currentitem.ptr");
1823 Builder.CreateAlignedLoad(CurrentItemPtr, getPointerAlign());
1826 CurrentItem = Builder.CreateBitCast(CurrentItem, convertedElementType,
1862 Builder.CreateAdd(index, llvm::ConstantInt::get(NSUIntegerTy, 1));
1868 Builder.CreateCondBr(
1869 Builder.CreateICmpULT(indexPlusOne, count), LoopBodyBB, FetchMoreBB,
1887 index->addIncoming(zero, Builder.GetInsertBlock());
1888 count->addIncoming(refetchCount, Builder.GetInsertBlock());
1890 Builder.CreateCondBr(Builder.CreateICmpEQ(refetchCount, zero),
1890 Builder.CreateCondBr(Builder.CreateICmpEQ(refetchCount, zero),
1905 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
1997 value = CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy);
2004 return CGF.Builder.CreateBitCast(call, origType);
2019 addr = CGF.Builder.CreateBitCast(addr, CGF.Int8PtrPtrTy);
2026 result = CGF.Builder.CreateBitCast(result, origType);
2048 CGF.Builder.CreateBitCast(addr.getPointer(), CGF.Int8PtrPtrTy),
2049 CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy)
2055 return CGF.Builder.CreateBitCast(result, origType);
2071 CGF.Builder.CreateBitCast(dst.getPointer(), CGF.Int8PtrPtrTy),
2072 CGF.Builder.CreateBitCast(src.getPointer(), CGF.Int8PtrPtrTy)
2101 value = CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy);
2107 return CGF.Builder.CreateBitCast(Inst, origType);
2151 llvm::MDNode::get(Builder.getContext(), None));
2192 CGF.Builder.CreateCall(marker, None, CGF.getBundlesForFunclet(marker));
2242 value = Builder.CreateBitCast(value, Int8PtrTy);
2249 llvm::MDNode::get(Builder.getContext(), None));
2270 llvm::Value *value = Builder.CreateLoad(addr);
2288 Builder.CreateBitCast(addr.getPointer(), Int8PtrPtrTy),
2289 Builder.CreateBitCast(value, Int8PtrTy)
2374 value = Builder.CreateBitCast(value, Int8PtrTy);
2377 return Builder.CreateBitCast(value, origType);
2425 Builder.CreateStore(value, addr);
2444 addr = Builder.CreateBitCast(addr, Int8PtrPtrTy);
2505 llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrTy, false);
2606 llvm::Value *value = CGF.Builder.CreateLoad(addr);
2639 llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrTy, false);
2648 value = Builder.CreateBitCast(value, Int8PtrTy);
2655 llvm::MDNode::get(Builder.getContext(), None));
2773 CGBuilderTy::InsertPoint ip = CGF.Builder.saveIP();
2776 CGF.Builder.SetInsertPoint(call->getParent(),
2780 CGF.Builder.restoreIP(ip);
2783 CGBuilderTy::InsertPoint ip = CGF.Builder.saveIP();
2787 CGF.Builder.SetInsertPoint(BB, BB->begin());
2790 CGF.Builder.restoreIP(ip);
3143 value = CGF.Builder.CreateBitCast(value, resultType);
3320 return CGF.Builder.CreateBitCast(value, resultType);
3445 DI->EmitLexicalBlockStart(Builder, S.getLBracLoc());
3461 DI->EmitLexicalBlockEnd(Builder, S.getRBracLoc());
3475 object = Builder.CreateBitCast(object, VoidPtrTy);
3711 return Builder.CreateICmpNE(CallRes, llvm::Constant::getNullValue(Int32Ty));
3745 CGF.Builder.SetInsertPoint(CGF.createBasicBlock("", CFLinkCheckFunc));
3748 CGF.Builder.CreateUnreachable();
tools/clang/lib/CodeGen/CGObjCGNU.cpp 689 CGBuilderTy &Builder = CGF.Builder;
700 CGBuilderTy &Builder = CGF.Builder;
751 CGBuilderTy &Builder = CGF.Builder;
792 CGBuilderTy &Builder = CGF.Builder;
1199 CGBuilderTy &Builder = CGF.Builder;
1254 return CGF.Builder.CreateLoad(Address(GetClassVar(Name, isWeak),
1325 return CGF.Builder.CreateAlignedLoad(Ref, CGM.getPointerAlign());
1682 llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(IvarOffsetPointer, Align);
1684 Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
2040 CGBuilderTy &Builder = CGF.Builder;
2057 CGBuilderTy &Builder = CGF.Builder;
2345 CGF.Builder.CreateStore(SelValue, tmp);
2503 CGBuilderTy &Builder = CGF.Builder;
2621 CGBuilderTy &Builder = CGF.Builder;
2729 messageBB = CGF.Builder.GetInsertBlock();
2730 CGF.Builder.CreateBr(continueBB);
3038 return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
3958 ExceptionAsObject = CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy);
3963 CGF.Builder.CreateUnreachable();
3965 CGF.Builder.ClearInsertionPoint();
3970 CGBuilderTy &B = CGF.Builder;
3977 CGBuilderTy &B = CGF.Builder;
3986 CGBuilderTy &B = CGF.Builder;
3997 CGBuilderTy &B = CGF.Builder;
4005 CGBuilderTy &B = CGF.Builder;
4015 CGBuilderTy &B = CGF.Builder;
4075 return CGF.Builder.CreateZExtOrBitCast(
4076 CGF.Builder.CreateAlignedLoad(
4077 Int32Ty, CGF.Builder.CreateAlignedLoad(
4093 Offset = CGF.Builder.CreateAlignedLoad(Offset, Align);
4095 Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
tools/clang/lib/CodeGen/CGObjCMac.cpp 1718 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1719 CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1741 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1744 CGF.Builder.CreateBr(contBB);
1766 assert(CGF.Builder.GetInsertBlock() == NullBB);
1785 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1812 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1815 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
2068 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
2069 CGF.Builder.CreateStore(ReceiverAsObject,
2070 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
2083 Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2084 Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign());
2088 CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2090 CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign());
2097 ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2098 Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign());
2104 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2105 CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
2105 CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
2150 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2214 CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType));
3025 CGF.Builder.CreateBitCast(className,
3028 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
4141 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4141 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4159 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4164 CGF.Builder.CreateStore(CurCleanupDest,
4174 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4464 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4469 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4492 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4514 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4516 llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4528 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4529 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4533 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4533 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4537 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4549 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4549 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4576 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4589 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4593 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4598 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4598 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4663 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4663 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4678 CGF.Builder.CreateBitCast(Caught,
4717 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4720 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4720 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4729 CGF.Builder.restoreIP(TryFallthroughIP);
4731 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4731 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4736 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4742 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4754 CGF.Builder.CreateUnreachable();
4757 CGF.Builder.restoreIP(SavedIP);
4768 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4777 CGF.Builder.CreateUnreachable();
4781 CGF.Builder.ClearInsertionPoint();
4790 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4795 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4808 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4809 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4810 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4812 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4813 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4829 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4830 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4831 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4833 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4834 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4855 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4856 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4857 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4859 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4860 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4874 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4875 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4876 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4878 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4879 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4889 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
4890 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
5100 return CGF.Builder.CreateAlignedLoad(Entry, CGF.getPointerAlign());
5121 return CGF.Builder.CreateLoad(EmitSelectorAddr(CGF, Sel));
6522 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6533 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
7073 CGF.Builder.CreateAlignedLoad(GV, CGF.getSizeAlign(), "ivar");
7084 IvarOffsetValue = CGF.Builder.CreateIntCast(
7127 arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
7205 Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
7212 Address calleeAddr = CGF.Builder.CreateStructGEP(mref, 0);
7213 llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");
7215 calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
7314 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7408 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7447 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
7448 CGF.Builder.CreateStore(ReceiverAsObject,
7449 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
7462 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
7463 CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
7463 CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
7479 llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
7520 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7521 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7522 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7524 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7525 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7540 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7541 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7542 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7544 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7545 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7556 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
7557 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
7569 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
7573 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
7586 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7587 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7588 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7590 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7591 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7607 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7608 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7609 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7611 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7612 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7668 Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7678 CGF.Builder.CreateUnreachable();
7680 CGF.Builder.ClearInsertionPoint();
tools/clang/lib/CodeGen/CGObjCRuntime.cpp 65 llvm::Value *V = CGF.Builder.CreateBitCast(BaseValue, CGF.Int8PtrTy);
66 V = CGF.Builder.CreateInBoundsGEP(V, Offset, "add.ptr");
69 V = CGF.Builder.CreateBitCast(V, llvm::PointerType::getUnqual(LTy));
109 Addr = CGF.Builder.CreateElementBitCast(Addr,
223 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
258 llvm::Value *CastExn = CGF.Builder.CreateBitCast(Exn, CatchType);
277 CGF.Builder.restoreIP(SavedIP);
301 CGF.Builder.CreateStore(exn, paramAddr);
340 lock = CGF.Builder.CreateBitCast(lock, CGF.VoidPtrTy);
343 CGF.Builder.CreateCall(syncEnterFn, lock)->setDoesNotThrow();
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 152 UntiedSwitch = CGF.Builder.CreateSwitch(Res, DoneBB);
156 UntiedSwitch->addCase(CGF.Builder.getInt32(0),
157 CGF.Builder.GetInsertBlock());
166 CGF.EmitStoreOfScalar(CGF.Builder.getInt32(UntiedSwitch->getNumCases()),
173 UntiedSwitch->addCase(CGF.Builder.getInt32(UntiedSwitch->getNumCases()),
174 CGF.Builder.GetInsertBlock());
871 CGF.Builder.CreateElementBitCast(DestAddr, DestAddr.getElementType());
874 CGF.Builder.CreateElementBitCast(SrcAddr, DestAddr.getElementType());
881 llvm::Value *DestEnd = CGF.Builder.CreateGEP(DestBegin, NumElements);
886 CGF.Builder.CreateICmpEQ(DestBegin, DestEnd, "omp.arrayinit.isempty");
887 CGF.Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);
890 llvm::BasicBlock *EntryBB = CGF.Builder.GetInsertBlock();
898 SrcElementPHI = CGF.Builder.CreatePHI(SrcBegin->getType(), 2,
905 llvm::PHINode *DestElementPHI = CGF.Builder.CreatePHI(
925 llvm::Value *SrcElementNext = CGF.Builder.CreateConstGEP1_32(
927 SrcElementPHI->addIncoming(SrcElementNext, CGF.Builder.GetInsertBlock());
931 llvm::Value *DestElementNext = CGF.Builder.CreateConstGEP1_32(
935 CGF.Builder.CreateICmpEQ(DestElementNext, DestEnd, "omp.arraycpy.done");
936 CGF.Builder.CreateCondBr(Done, DoneBB, BodyBB);
937 DestElementPHI->addIncoming(DestElementNext, CGF.Builder.GetInsertBlock());
1014 Size = CGF.Builder.CreatePtrDiff(SharedAddresses[N].second.getPointer(),
1016 Size = CGF.Builder.CreateNUWAdd(
1018 SizeInChars = CGF.Builder.CreateNUWMul(Size, ElemSizeOf);
1022 Size = CGF.Builder.CreateExactUDiv(SizeInChars, ElemSizeOf);
1061 PrivateAddr = CGF.Builder.CreateElementBitCast(
1065 CGF.Builder.CreateElementBitCast(SharedLVal.getAddress(),
1098 PrivateAddr = CGF.Builder.CreateElementBitCast(
1118 CGF.Builder.CreateElementBitCast(BaseLV.getAddress(),
1135 CGF.Builder.CreateStore(Tmp.getPointer(), TopTmp);
1144 Addr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(Addr, Ty);
1146 CGF.Builder.CreateStore(Addr, Tmp);
1181 llvm::Value *Adjustment = CGF.Builder.CreatePtrDiff(
1184 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
1187 llvm::Value *Ptr = CGF.Builder.CreateGEP(PrivatePointer, Adjustment);
1608 Undef, CGF.Int32Ty, "svcpt", CGF.Builder.GetInsertBlock());
1653 CGBuilderTy::InsertPointGuard IPG(CGF.Builder);
1654 CGF.Builder.SetInsertPoint(Elem.second.ServiceInsertPt);
1655 CGF.Builder.CreateMemCpy(LocValue, getOrCreateDefaultLocation(Flags),
1675 OMPDebugLoc = CGF.Builder.CreateGlobalStringPtr(OS2.str());
1708 CGF.Builder.GetInsertBlock() == TopBlock ||
1712 CGF.Builder.GetInsertBlock()) {
1716 if (CGF.Builder.GetInsertBlock() == TopBlock) {
1732 CGBuilderTy::InsertPointGuard IPG(CGF.Builder);
1733 CGF.Builder.SetInsertPoint(Elem.second.ServiceInsertPt);
1734 llvm::CallInst *Call = CGF.Builder.CreateCall(
2728 CGF.Builder.CreatePointerCast(VDAddr.getPointer(),
2748 OMPLoc, CGF.Builder.CreatePointerCast(VDAddr.getPointer(), CGM.VoidPtrTy),
2789 Arg = CtorCGF.Builder.CreateElementBitCast(
2796 CtorCGF.Builder.CreateStore(ArgVal, CtorCGF.ReturnValue);
2998 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(GAddr, CGM.VoidPtrTy),
2999 CGF.Builder.CreateIntCast(CGF.getTypeSize(VarType), CGM.SizeTy,
3004 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
3063 CGF.Builder.getInt32(CapturedVars.size()), // Number of captured vars
3064 CGF.Builder.CreateBitCast(OutlinedFn, RT.getKmpc_MicroPointerTy())};
3088 CGF.InitTempAlloca(ZeroAddrBound, CGF.Builder.getInt32(/*C*/ 0));
3179 llvm::Value *CallBool = CGF.Builder.CreateIsNotNull(EnterRes);
3183 CGF.Builder.CreateCondBr(CallBool, ThenBlock, ContBlock);
3213 EnterArgs.push_back(CGF.Builder.CreateIntCast(
3278 Address PtrAddr = CGF.Builder.CreateConstArrayGEP(Array, Index);
3279 llvm::Value *Ptr = CGF.Builder.CreateLoad(PtrAddr);
3282 Addr = CGF.Builder.CreateElementBitCast(
3314 Address LHS(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
3315 CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(&LHSArg)),
3317 Address RHS(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
3318 CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(&RHSArg)),
3369 CGF.Builder.CreateStore(CGF.Builder.getInt32(0), DidIt);
3369 CGF.Builder.CreateStore(CGF.Builder.getInt32(0), DidIt);
3380 CGF.Builder.CreateStore(CGF.Builder.getInt32(1), DidIt);
3380 CGF.Builder.CreateStore(CGF.Builder.getInt32(1), DidIt);
3394 Address Elem = CGF.Builder.CreateConstArrayGEP(CopyprivateList, I);
3395 CGF.Builder.CreateStore(
3396 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
3407 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(CopyprivateList,
3409 llvm::Value *DidItVal = CGF.Builder.CreateLoad(DidIt);
3499 llvm::Value *Cmp = CGF.Builder.CreateIsNotNull(Result);
3500 CGF.Builder.CreateCondBr(Cmp, ExitBB, ContBB);
3644 : CGF.Builder.getIntN(IVSize, 1);
3648 CGF.Builder.getInt32(addMonoNonMonoModifier(
3652 CGF.Builder.getIntN(IVSize, 1), // Stride
3684 Chunk = CGF.Builder.getIntN(Values.IVSize, 1);
3695 CGF.Builder.getInt32(addMonoNonMonoModifier(CGF.CGM, Schedule, M1,
3701 CGF.Builder.getIntN(Values.IVSize, 1), // Incr
3804 CGF.Builder.CreateIntCast(NumThreads, CGF.Int32Ty, /*isSigned*/ true)};
4544 llvm::Value *SharedsParam = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
4552 PrivatesParam = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
4560 CGF.Builder
4592 CGF.EmitStoreThroughLValue(RValue::get(CGF.Builder.getInt32(/*C=*/0)),
4772 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5046 TaskPrivatesMap = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5082 ? CGF.Builder.CreateSelect(Data.Final.getPointer(),
5083 CGF.Builder.getInt32(FinalFlag),
5084 CGF.Builder.getInt32(/*C=*/0))
5085 : CGF.Builder.getInt32(Data.Final.getInt() ? FinalFlag : 0);
5086 TaskFlags = CGF.Builder.CreateOr(TaskFlags, CGF.Builder.getInt32(Flags));
5086 TaskFlags = CGF.Builder.CreateOr(TaskFlags, CGF.Builder.getInt32(Flags));
5090 SharedsSize, CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5101 DeviceID = CGF.Builder.CreateIntCast(CGF.EmitScalarExpr(Device),
5104 DeviceID = CGF.Builder.getInt64(OMP_DEVICEID_UNDEF);
5113 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5161 CGF.EmitStoreOfScalar(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5237 CGF.Builder.CreateConstGEP1_32(UpAddrLVal.getPointer(), /*Idx0=*/1);
5239 CGF.Builder.CreatePtrToInt(Addr.getPointer(), CGM.SizeTy);
5240 llvm::Value *UpIntPtr = CGF.Builder.CreatePtrToInt(UpAddr, CGM.SizeTy);
5241 Size = CGF.Builder.CreateNUWSub(UpIntPtr, LowIntPtr);
5246 CGF.Builder.CreateConstArrayGEP(DependenciesArray, I),
5252 CGF.Builder.CreatePtrToInt(Addr.getPointer(), CGF.IntPtrTy),
5282 DependenciesArray = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5283 CGF.Builder.CreateConstArrayGEP(DependenciesArray, 0), CGF.VoidPtrTy);
5300 DepTaskArgs[3] = CGF.Builder.getInt32(NumDependencies);
5302 DepTaskArgs[5] = CGF.Builder.getInt32(0);
5311 CGF.EmitStoreOfScalar(CGF.Builder.getInt32(0), PartIdLVal);
5330 DepWaitTaskArgs[2] = CGF.Builder.getInt32(NumDependencies);
5332 DepWaitTaskArgs[4] = CGF.Builder.getInt32(0);
5395 IfVal = CGF.Builder.CreateIntCast(CGF.EvaluateExprAsBool(IfCond), CGF.IntTy,
5448 ? CGF.Builder.CreateIntCast(Data.Schedule.getPointer(), CGF.Int64Ty,
5451 Result.TaskDupFn ? CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5485 llvm::Value *LHSEnd = CGF.Builder.CreateGEP(LHSBegin, NumElements);
5490 CGF.Builder.CreateICmpEQ(LHSBegin, LHSEnd, "omp.arraycpy.isempty");
5491 CGF.Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);
5494 llvm::BasicBlock *EntryBB = CGF.Builder.GetInsertBlock();
5499 llvm::PHINode *RHSElementPHI = CGF.Builder.CreatePHI(
5506 llvm::PHINode *LHSElementPHI = CGF.Builder.CreatePHI(
5522 llvm::Value *LHSElementNext = CGF.Builder.CreateConstGEP1_32(
5524 llvm::Value *RHSElementNext = CGF.Builder.CreateConstGEP1_32(
5528 CGF.Builder.CreateICmpEQ(LHSElementNext, LHSEnd, "omp.arraycpy.done");
5529 CGF.Builder.CreateCondBr(Done, DoneBB, BodyBB);
5530 LHSElementPHI->addIncoming(LHSElementNext, CGF.Builder.GetInsertBlock());
5531 RHSElementPHI->addIncoming(RHSElementNext, CGF.Builder.GetInsertBlock());
5585 Address LHS(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5586 CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(&LHSArg)),
5588 Address RHS(CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5589 CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(&RHSArg)),
5613 Address Elem = CGF.Builder.CreateConstArrayGEP(LHS, Idx);
5614 llvm::Value *Ptr = CGF.Builder.CreateLoad(Elem);
5619 CGF, OVE, RValue::get(CGF.Builder.CreatePtrToInt(Ptr, CGF.SizeTy)));
5751 Address Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
5752 CGF.Builder.CreateStore(
5753 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5759 Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
5760 llvm::Value *Size = CGF.Builder.CreateIntCast(
5765 CGF.Builder.CreateStore(CGF.Builder.CreateIntToPtr(Size, CGF.VoidPtrTy),
5765 CGF.Builder.CreateStore(CGF.Builder.CreateIntToPtr(Size, CGF.VoidPtrTy),
5784 llvm::Value *RL = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
5789 CGF.Builder.getInt32(RHSExprs.size()), // i32 <n>
5803 CGF.Builder.CreateSwitch(Res, DefaultBB, /*NumCases=*/2);
5812 SwInst->addCase(CGF.Builder.getInt32(1), Case1BB);
5852 SwInst->addCase(CGF.Builder.getInt32(2), Case2BB);
6115 return CGF.Builder.CreateElementBitCast(
6123 return CGF.Builder.CreateElementBitCast(
6247 SizeValInChars = CGF.Builder.CreateIntCast(SizeValInChars, CGM.SizeTy,
6282 CGF.Builder.CreateIntCast(getThreadID(CGF, Loc), CGM.IntTy,
6285 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(TaskRedInput.getPointer(),
6299 llvm::Value *SizeVal = CGF.Builder.CreateIntCast(Sizes.second, CGM.SizeTy,
6304 CGF.Builder.CreateStore(SizeVal, SizeAddr, /*IsVolatile=*/false);
6311 CGF.Builder.CreateStore(
6312 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
6325 CGF.Builder.CreateIntCast(getThreadID(CGF, Loc), CGM.IntTy,
6328 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(SharedLVal.getPointer(),
6398 CGF.Builder.getInt32(getCancellationKind(CancelRegion))};
6407 llvm::Value *Cmp = CGF.Builder.CreateIsNotNull(Result);
6408 CGF.Builder.CreateCondBr(Cmp, ExitBB, ContBB);
6433 CGF.Builder.getInt32(getCancellationKind(CancelRegion))};
6442 llvm::Value *Cmp = CGF.Builder.CreateIsNotNull(Result);
6443 CGF.Builder.CreateCondBr(Cmp, ExitBB, ContBB);
6610 CGBuilderTy &Bld = CGF.Builder;
6744 return CGF.Builder.getInt32(1);
6785 NumThreads = CGF.Builder.CreateIntCast(NumThreads, CGF.Int32Ty,
6788 NumThreads = CGF.Builder.CreateSelect(
6789 CGF.Builder.CreateICmpULT(DefaultThreadLimitVal, NumThreads),
6793 : CGF.Builder.getInt32(0);
6797 NumThreads = CGF.Builder.CreateSelect(CondVal, NumThreads,
6798 CGF.Builder.getInt32(1));
6803 return CGF.Builder.getInt32(1);
6807 : CGF.Builder.getInt32(0);
6827 CGBuilderTy &Bld = CGF.Builder;
7211 return CGF.Builder.CreateNUWMul(LengthVal, ElemSize);
7221 LBVal = CGF.Builder.CreateNUWMul(LBVal, ElemSize);
7222 llvm::Value *Cmp = CGF.Builder.CreateICmpUGT(LengthVal, LBVal);
7223 llvm::Value *TrueVal = CGF.Builder.CreateNUWSub(LengthVal, LBVal);
7224 LengthVal = CGF.Builder.CreateSelect(
7632 Address HB = CGF.Builder.CreateConstGEP(
7633 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(LB,
7659 Size = CGF.Builder.CreatePtrDiff(
7667 Sizes.push_back(CGF.Builder.CreateIntCast(Size, CGF.Int64Ty,
7670 LB = CGF.Builder.CreateConstGEP(ComponentLB, 1);
7674 Size = CGF.Builder.CreatePtrDiff(
7676 CGF.Builder.CreateConstGEP(HB, 1).getPointer()),
7679 CGF.Builder.CreateIntCast(Size, CGF.Int64Ty, /*isSigned=*/true));
7688 CGF.Builder.CreateIntCast(Size, CGF.Int64Ty, /*isSigned=*/true));
7890 llvm::Value *HAddr = CGF.Builder.CreateConstGEP1_32(HB, /*Idx0=*/1);
7891 llvm::Value *CLAddr = CGF.Builder.CreatePointerCast(LB, CGF.VoidPtrTy);
7892 llvm::Value *CHAddr = CGF.Builder.CreatePointerCast(HAddr, CGF.VoidPtrTy);
7893 llvm::Value *Diff = CGF.Builder.CreatePtrDiff(CHAddr, CLAddr);
7894 llvm::Value *Size = CGF.Builder.CreateIntCast(Diff, CGF.Int64Ty,
8188 CGF.Builder.CreateIntCast(CGF.getTypeSize(CGF.getContext().VoidPtrTy),
8207 Sizes.push_back(CGF.Builder.CreateIntCast(
8275 CGF.Builder.CreateIntCast(CGF.getTypeSize(CGF.getContext().VoidPtrTy),
8479 CGF.Builder.CreateIntCast(CGF.getTypeSize(PtrTy->getPointeeType()),
8490 CurSizes.push_back(CGF.Builder.CreateIntCast(
8506 CurSizes.push_back(CGF.Builder.CreateIntCast(
8519 CGF.Builder.CreateMemCpy(
8621 llvm::ConstantDataArray::get(CGF.Builder.getContext(), Mapping);
8633 llvm::Value *BP = CGF.Builder.CreateConstInBoundsGEP2_32(
8636 BP = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
8639 CGF.Builder.CreateStore(BPVal, BPAddr);
8646 llvm::Value *P = CGF.Builder.CreateConstInBoundsGEP2_32(
8649 P = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
8652 CGF.Builder.CreateStore(PVal, PAddr);
8655 llvm::Value *S = CGF.Builder.CreateConstInBoundsGEP2_32(
8661 CGF.Builder.CreateStore(
8662 CGF.Builder.CreateIntCast(Sizes[I], CGM.Int64Ty, /*isSigned=*/true),
8677 BasePointersArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
8681 PointersArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
8686 SizesArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
8689 MapTypesArrayArg = CGF.Builder.CreateConstInBoundsGEP2_32(
8879 llvm::Value *PtrBegin = MapperCGF.Builder.CreateBitCast(
8882 llvm::Value *PtrEnd = MapperCGF.Builder.CreateGEP(PtrBegin, Size);
8911 MapperCGF.Builder.CreateICmpEQ(PtrBegin, PtrEnd, "omp.arraymap.isempty");
8912 MapperCGF.Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);
8913 llvm::BasicBlock *EntryBB = MapperCGF.Builder.GetInsertBlock();
8917 llvm::PHINode *PtrPHI = MapperCGF.Builder.CreatePHI(
8946 llvm::Value *ShiftedPreviousSize = MapperCGF.Builder.CreateShl(
8948 MapperCGF.Builder.getInt64(MappableExprsHandler::getFlagMemberOffset()));
8952 llvm::Value *CurBaseArg = MapperCGF.Builder.CreateBitCast(
8954 llvm::Value *CurBeginArg = MapperCGF.Builder.CreateBitCast(
8961 llvm::Value *OriMapType = MapperCGF.Builder.getInt64(MapTypes[I]);
8962 llvm::Value *Member = MapperCGF.Builder.CreateAnd(
8964 MapperCGF.Builder.getInt64(MappableExprsHandler::OMP_MAP_MEMBER_OF));
8968 llvm::Value *IsMember = MapperCGF.Builder.CreateIsNull(Member);
8969 MapperCGF.Builder.CreateCondBr(IsMember, TypeBB, MemberCombineBB);
8974 MapperCGF.Builder.CreateNUWAdd(OriMapType, ShiftedPreviousSize);
8978 MapperCGF.Builder.CreatePHI(CGM.Int64Ty, 4, "omp.membermaptype");
8994 llvm::Value *LeftToFrom = MapperCGF.Builder.CreateAnd(
8996 MapperCGF.Builder.getInt64(MappableExprsHandler::OMP_MAP_TO |
9005 llvm::Value *IsAlloc = MapperCGF.Builder.CreateIsNull(LeftToFrom);
9006 MapperCGF.Builder.CreateCondBr(IsAlloc, AllocBB, AllocElseBB);
9009 llvm::Value *AllocMapType = MapperCGF.Builder.CreateAnd(
9011 MapperCGF.Builder.getInt64(~(MappableExprsHandler::OMP_MAP_TO |
9013 MapperCGF.Builder.CreateBr(EndBB);
9015 llvm::Value *IsTo = MapperCGF.Builder.CreateICmpEQ(
9017 MapperCGF.Builder.getInt64(MappableExprsHandler::OMP_MAP_TO));
9018 MapperCGF.Builder.CreateCondBr(IsTo, ToBB, ToElseBB);
9021 llvm::Value *ToMapType = MapperCGF.Builder.CreateAnd(
9023 MapperCGF.Builder.getInt64(~MappableExprsHandler::OMP_MAP_FROM));
9024 MapperCGF.Builder.CreateBr(EndBB);
9026 llvm::Value *IsFrom = MapperCGF.Builder.CreateICmpEQ(
9028 MapperCGF.Builder.getInt64(MappableExprsHandler::OMP_MAP_FROM));
9029 MapperCGF.Builder.CreateCondBr(IsFrom, FromBB, EndBB);
9032 llvm::Value *FromMapType = MapperCGF.Builder.CreateAnd(
9034 MapperCGF.Builder.getInt64(~MappableExprsHandler::OMP_MAP_TO));
9038 MapperCGF.Builder.CreatePHI(CGM.Int64Ty, 4, "omp.maptype");
9057 llvm::Value *PtrNext = MapperCGF.Builder.CreateConstGEP1_32(
9061 MapperCGF.Builder.CreateICmpEQ(PtrNext, PtrEnd, "omp.arraymap.isdone");
9063 MapperCGF.Builder.CreateCondBr(IsDone, ExitBB, BodyBB);
9097 llvm::Value *IsArray = MapperCGF.Builder.CreateICmpSGE(
9098 Size, MapperCGF.Builder.getInt64(1), "omp.arrayinit.isarray");
9099 MapperCGF.Builder.CreateCondBr(IsArray, IsDeleteBB, ExitBB);
9103 llvm::Value *DeleteBit = MapperCGF.Builder.CreateAnd(
9105 MapperCGF.Builder.getInt64(MappableExprsHandler::OMP_MAP_DELETE));
9108 DeleteCond = MapperCGF.Builder.CreateIsNull(
9111 DeleteCond = MapperCGF.Builder.CreateIsNotNull(
9114 MapperCGF.Builder.CreateCondBr(DeleteCond, BodyBB, ExitBB);
9119 llvm::Value *ArraySize = MapperCGF.Builder.CreateNUWMul(
9120 Size, MapperCGF.Builder.getInt64(ElementSize.getQuantity()));
9123 llvm::Value *MapTypeArg = MapperCGF.Builder.CreateAnd(
9125 MapperCGF.Builder.getInt64(~(MappableExprsHandler::OMP_MAP_TO |
9201 DeviceID = CGF.Builder.CreateIntCast(CGF.EmitScalarExpr(Device),
9204 DeviceID = CGF.Builder.getInt64(OMP_DEVICEID_UNDEF);
9209 CGF.Builder.getInt32(InputInfo.NumberOfTargetItems);
9288 llvm::Value *Failed = CGF.Builder.CreateIsNotNull(Return);
9289 CGF.Builder.CreateCondBr(Failed, OffloadFailedBlock, OffloadContBlock);
9342 CurSizes.push_back(CGF.Builder.CreateIntCast(
9909 CGF.Builder.getInt32(CapturedVars.size()), // Number of captured vars
9910 CGF.Builder.CreateBitCast(OutlinedFn, getKmpc_MicroPointerTy())};
9930 ? CGF.Builder.CreateIntCast(CGF.EmitScalarExpr(NumTeams),
9932 : CGF.Builder.getInt32(0);
9936 ? CGF.Builder.CreateIntCast(CGF.EmitScalarExpr(ThreadLimit),
9938 : CGF.Builder.getInt32(0);
9985 DeviceID = CGF.Builder.CreateIntCast(CGF.EmitScalarExpr(Device),
9988 DeviceID = CGF.Builder.getInt64(OMP_DEVICEID_UNDEF);
9992 llvm::Value *PointerNum = CGF.Builder.getInt32(Info.NumberOfPtrs);
10021 DeviceID = CGF.Builder.CreateIntCast(CGF.EmitScalarExpr(Device),
10024 DeviceID = CGF.Builder.getInt64(OMP_DEVICEID_UNDEF);
10028 llvm::Value *PointerNum = CGF.Builder.getInt32(Info.NumberOfPtrs);
10093 DeviceID = CGF.Builder.CreateIntCast(CGF.EmitScalarExpr(Device),
10096 DeviceID = CGF.Builder.getInt64(OMP_DEVICEID_UNDEF);
10101 CGF.Builder.getInt32(InputInfo.NumberOfTargetItems);
10840 CGF.Builder.CreateConstArrayGEP(DimsAddr, I), KmpDimTy);
10862 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
10863 CGF.Builder.CreateConstArrayGEP(DimsAddr, 0).getPointer(),
10891 CGF.EmitStoreOfScalar(CntVal, CGF.Builder.CreateConstArrayGEP(CntAddr, I),
10897 CGF.Builder.CreateConstArrayGEP(CntAddr, 0).getPointer()};
10984 Size = CGF.Builder.CreateNUWAdd(
10986 Size = CGF.Builder.CreateUDiv(Size, CGM.getSize(Align));
10987 Size = CGF.Builder.CreateNUWMul(Size, CGM.getSize(Align));
10999 Allocator = CGF.Builder.CreateIntToPtr(Allocator, CGM.VoidPtrTy);
11001 Allocator = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(Allocator,
11014 Addr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 135 llvm::Value *CallBool = CGF.Builder.CreateIsNotNull(EnterRes);
139 CGF.Builder.CreateCondBr(CallBool, ThenBlock, ContBlock);
640 CGBuilderTy &Bld = CGF.Builder;
648 CGBuilderTy &Bld = CGF.Builder;
668 CGBuilderTy &Bld = CGF.Builder;
683 CGBuilderTy &Bld = CGF.Builder;
1202 CGBuilderTy &Bld = CGF.Builder;
1258 llvm::Value *Args[] = {CGF.Builder.getInt16(/*IsOMPRuntimeInitialized=*/1)};
1324 CGBuilderTy &Bld = CGF.Builder;
1365 CGF.Builder.getInt16(RequiresFullRuntime ? 1 : 0)};
1412 CGBuilderTy &Bld = CGF.Builder;
2115 CGBuilderTy &Bld = CGF.Builder;
2185 Size, CGF.Builder.getInt16(/*UseSharedMemory=*/0)};
2275 CGF.Builder.getInt16(/*UseSharedMemory=*/0)};
2316 llvm::Value *Ptr = CGF.Builder.CreateInBoundsGEP(
2362 CGBuilderTy &Bld = CGF.Builder;
2374 Size, CGF.Builder.getInt16(/*UseSharedMemory=*/0)};
2412 CGBuilderTy &Bld = CGF.Builder;
2465 CGF.InitTempAlloca(ZeroAddr, CGF.Builder.getInt32(/*C*/ 0));
2495 CGF.InitTempAlloca(ZeroAddr, CGF.Builder.getInt32(/*C*/ 0));
2505 CGF.InitTempAlloca(ZeroAddr, CGF.Builder.getInt32(/*C*/ 0));
2531 CGBuilderTy &Bld = CGF.Builder;
2612 CGBuilderTy &Bld = CGF.Builder;
2664 CGF.InitTempAlloca(ZeroAddr, CGF.Builder.getInt32(/*C*/ 0));
2674 CGF.InitTempAlloca(ZeroAddr, CGF.Builder.getInt32(/*C*/ 0));
2773 llvm::Value *CmpLoopBound = CGF.Builder.CreateICmpSLT(CounterVal, TeamWidth);
2774 CGF.Builder.CreateCondBr(CmpLoopBound, TestBB, ExitBB);
2781 CGF.Builder.CreateICmpEQ(ThreadID, CounterVal);
2782 CGF.Builder.CreateCondBr(CmpThreadToCounter, BodyBB, SyncBB);
2801 CGF.Builder.CreateNSWAdd(CounterVal, CGF.Builder.getInt32(1));
2801 CGF.Builder.CreateNSWAdd(CounterVal, CGF.Builder.getInt32(1));
2822 return CGF.Builder.CreateBitCast(Val, LLVMCastTy);
2824 return CGF.Builder.CreateIntCast(Val, LLVMCastTy,
2827 Address ValCastItem = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
2841 CGBuilderTy &Bld = CGF.Builder;
2869 CGBuilderTy &Bld = CGF.Builder;
2968 CGBuilderTy &Bld = CGF.Builder;
3198 CGBuilderTy &Bld = CGF.Builder;
3498 CGBuilderTy &Bld = CGF.Builder;
3653 CGBuilderTy &Bld = CGF.Builder;
3759 CGBuilderTy &Bld = CGF.Builder;
3780 Address Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
3792 Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
3793 llvm::Value *Size = CGF.Builder.CreateIntCast(
3798 CGF.Builder.CreateStore(CGF.Builder.CreateIntToPtr(Size, CGF.VoidPtrTy),
3798 CGF.Builder.CreateStore(CGF.Builder.CreateIntToPtr(Size, CGF.VoidPtrTy),
3853 CGBuilderTy &Bld = CGF.Builder;
3959 CGBuilderTy &Bld = CGF.Builder;
3980 Address Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
3992 Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
3993 llvm::Value *Size = CGF.Builder.CreateIntCast(
3998 CGF.Builder.CreateStore(CGF.Builder.CreateIntToPtr(Size, CGF.VoidPtrTy),
3998 CGF.Builder.CreateStore(CGF.Builder.CreateIntToPtr(Size, CGF.VoidPtrTy),
4306 Address Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
4307 CGF.Builder.CreateStore(
4308 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
4314 Elem = CGF.Builder.CreateConstArrayGEP(ReductionList, Idx);
4315 llvm::Value *Size = CGF.Builder.CreateIntCast(
4320 CGF.Builder.CreateStore(CGF.Builder.CreateIntToPtr(Size, CGF.VoidPtrTy),
4320 CGF.Builder.CreateStore(CGF.Builder.CreateIntToPtr(Size, CGF.VoidPtrTy),
4325 llvm::Value *RL = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
4339 CGF.Builder.getInt32(RHSExprs.size()),
4386 CGF.Builder.getInt32(C.getLangOpts().OpenMPCUDAReductionBufNum),
4404 llvm::Value *Cond = CGF.Builder.CreateICmpEQ(
4406 CGF.Builder.CreateCondBr(Cond, ThenBB, ExitBB);
4495 TargetAddr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
4499 TargetAddr = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
4525 llvm::Value *TargetArg = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
4529 CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(TargetArg, TargetType));
4577 CGF.InitTempAlloca(ZeroAddr, CGF.Builder.getInt32(/*C*/ 0));
4584 CGBuilderTy &Bld = CGF.Builder;
tools/clang/lib/CodeGen/CGStmt.cpp 38 DI->EmitLocation(Builder, Loc);
109 llvm::BasicBlock *incoming = Builder.GetInsertBlock();
114 llvm::BasicBlock *outgoing = Builder.GetInsertBlock();
131 Builder.ClearInsertionPoint();
466 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
482 Builder.SetInsertPoint(BB);
489 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
496 Builder.CreateBr(Target);
499 Builder.ClearInsertionPoint();
516 Builder.SetInsertPoint(block);
560 DI->EmitLabel(D, Builder);
618 llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()),
620 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
758 Builder.CreateCondBr(
843 Builder.CreateCondBr(
913 Builder.CreateCondBr(
994 Builder.CreateCondBr(
1038 Builder.CreateStore(RV.getScalarVal(), ReturnValue);
1062 Builder.CreateStore(Builder.CreateBitCast(SLocPtr, Int8PtrTy),
1062 Builder.CreateStore(Builder.CreateBitCast(SLocPtr, Int8PtrTy),
1068 Builder.CreateUnreachable();
1069 Builder.ClearInsertionPoint();
1096 Builder.CreateFlagStore(Builder.getTrue(), NRVOFlag);
1096 Builder.CreateFlagStore(Builder.getTrue(), NRVOFlag);
1108 Builder.CreateStore(Result.getScalarVal(), ReturnValue);
1112 Builder.CreateStore(EmitScalarExpr(RV), ReturnValue);
1207 SwitchInsn->addCase(Builder.getInt(LHS), CaseDest);
1215 llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock();
1224 Builder.SetInsertPoint(CaseRangeBlock);
1228 Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS));
1228 Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS));
1230 Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds");
1230 Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds");
1243 Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights);
1247 Builder.SetInsertPoint(RestoreBB);
1249 Builder.ClearInsertionPoint();
1270 Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext()));
1288 if (Builder.GetInsertBlock()) {
1289 Builder.CreateBr(Block.getBlock());
1290 Builder.ClearInsertionPoint();
1318 Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext()));
1646 SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock);
1667 Builder.ClearInsertionPoint();
1833 Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(),
1833 Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(),
1955 llvm::Value *Tmp = CGF.Builder.CreateExtractValue(&Result, i, "asmresult");
2108 Arg = Builder.CreateBitCast(Arg, AdjTy);
2175 Arg = Builder.CreatePtrToInt(Arg, IntPtrTy);
2178 Arg = Builder.CreateZExt(Arg, OutputTy);
2180 Arg = Builder.CreateZExt(Arg, IntPtrTy);
2183 Arg = Builder.CreateFPExt(Arg, OutputTy);
2192 Arg = Builder.CreateBitCast(Arg, AdjTy);
2282 Builder.CreateCallBr(IA, Fallthrough, Transfer, Args);
2288 Builder.CreateCall(IA, Args, getBundlesForFunclet(IA));
2310 Tmp = Builder.CreateFPTrunc(Tmp, TruncTy);
2313 Tmp = Builder.CreateTrunc(Tmp,
2315 Tmp = Builder.CreateIntToPtr(Tmp, TruncTy);
2318 Tmp = Builder.CreatePtrToInt(Tmp,
2320 Tmp = Builder.CreateTrunc(Tmp, TruncTy);
2322 Tmp = Builder.CreateZExtOrTrunc(Tmp, TruncTy);
2324 Tmp = Builder.CreateBitCast(Tmp, TruncTy);
2333 Address A = Builder.CreateBitCast(Dest.getAddress(),
2428 CapturedStmtInfo->setContextValue(Builder.CreateLoad(DeclPtr));
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 274 Size = Size ? Builder.CreateNUWMul(Size, VlaSize.NumElts)
280 return Builder.CreateNUWMul(Size, CGM.getSize(SizeInChars));
648 SrcAddr = Builder.CreateElementBitCast(SrcAddr, DestAddr.getElementType());
653 llvm::Value *DestEnd = Builder.CreateGEP(DestBegin, NumElements);
658 Builder.CreateICmpEQ(DestBegin, DestEnd, "omp.arraycpy.isempty");
659 Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);
662 llvm::BasicBlock *EntryBB = Builder.GetInsertBlock();
668 Builder.CreatePHI(SrcBegin->getType(), 2, "omp.arraycpy.srcElementPast");
675 Builder.CreatePHI(DestBegin->getType(), 2, "omp.arraycpy.destElementPast");
685 llvm::Value *DestElementNext = Builder.CreateConstGEP1_32(
687 llvm::Value *SrcElementNext = Builder.CreateConstGEP1_32(
691 Builder.CreateICmpEQ(DestElementNext, DestEnd, "omp.arraycpy.done");
692 Builder.CreateCondBr(Done, DoneBB, BodyBB);
693 DestElementPHI->addIncoming(DestElementNext, Builder.GetInsertBlock());
694 SrcElementPHI->addIncoming(SrcElementNext, Builder.GetInsertBlock());
942 Builder.CreateCondBr(
943 Builder.CreateICmpNE(
944 Builder.CreatePtrToInt(MasterAddr.getPointer(), CGM.IntPtrTy),
945 Builder.CreatePtrToInt(PrivateAddr.getPointer(),
1044 Builder.CreateCondBr(IsLastIterCond, ThenBB, DoneBB);
1086 Address(Builder.CreateLoad(PrivateAddr),
1174 return Builder.CreateElementBitCast(GetAddrOfLocalVar(PrivateVD),
1185 OriginalAddr = Builder.CreateElementBitCast(
1192 ? Builder.CreateElementBitCast(
1248 CGF.Builder.CreateCondBr(Cond, ThenBB, DoneBB);
1495 Builder.CreateCondBr(Cond, ThenBB, DoneBB);
1730 Builder.CreateCondBr(Cond, ThenBB, DoneBB);
1909 Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock);
2207 llvm::Value *LBCast = CGF.Builder.CreateIntCast(
2208 CGF.Builder.CreateLoad(LB.getAddress()), CGF.SizeTy, /*isSigned=*/false);
2213 llvm::Value *UBCast = CGF.Builder.CreateIntCast(
2214 CGF.Builder.CreateLoad(UB.getAddress()), CGF.SizeTy, /*isSigned=*/false);
2498 return CGF.Builder.CreateIsNotNull(
2509 return CGF.Builder.CreateIsNotNull(
2516 Builder.CreateIsNotNull(EmitLoadOfScalar(IL, S.getBeginLoc())));
2519 return CGF.Builder.CreateIsNotNull(
2555 llvm::Value *LBVal = CGF.Builder.getIntN(IVSize, 0);
2618 CGF.Builder.getInt32(0));
2620 ? CGF.Builder.getInt32(CS->size() - 1)
2621 : CGF.Builder.getInt32(0);
2625 CGF.Builder.getInt32(1));
2627 CGF.Builder.getInt32(0));
2654 CGF.Builder.CreateSwitch(CGF.EmitLoadOfScalar(IV, S.getBeginLoc()),
2661 SwitchStmt->addCase(CGF.Builder.getInt32(CaseNumber), CaseBB);
2669 SwitchStmt->addCase(CGF.Builder.getInt32(0), CaseBB);
2702 llvm::Value *MinUBGlobalUB = CGF.Builder.CreateSelect(
2703 CGF.Builder.CreateICmpSLT(UBVal, GlobalUBVal), UBVal, GlobalUBVal);
2719 return CGF.Builder.CreateIsNotNull(
2727 CGF.Builder.CreateIsNotNull(
2988 CGF.Builder.getVoidTy(), {CGF.Builder.getInt8PtrTy()}, true);
2988 CGF.Builder.getVoidTy(), {CGF.Builder.getInt8PtrTy()}, true);
2990 llvm::Value *CopyFn = CGF.Builder.CreateLoad(
2992 llvm::Value *PrivatesPtr = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(
3035 Address Replacement(CGF.Builder.CreateLoad(Pair.second),
3044 llvm::Value *ReductionsPtr = CGF.Builder.CreateLoad(
3226 CGF.Builder.getVoidTy(), {CGF.Builder.getInt8PtrTy()}, true);
3226 CGF.Builder.getVoidTy(), {CGF.Builder.getInt8PtrTy()}, true);
3228 llvm::Value *CopyFn = CGF.Builder.CreateLoad(
3230 llvm::Value *PrivatesPtr = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(
3247 Address Replacement(CGF.Builder.CreateLoad(Pair.second),
3255 InputInfo.BasePointersArray = CGF.Builder.CreateConstArrayGEP(
3257 InputInfo.PointersArray = CGF.Builder.CreateConstArrayGEP(
3259 InputInfo.SizesArray = CGF.Builder.CreateConstArrayGEP(
3563 return CGF.Builder.CreateIsNotNull(
3574 return CGF.Builder.CreateIsNotNull(
3582 Builder.CreateIsNotNull(EmitLoadOfScalar(IL, S.getBeginLoc())));
3832 UpdateVal = CGF.Builder.CreateIntCast(
3837 CGF.Builder.CreateAtomicRMW(RMWOp, X.getPointer(), UpdateVal, AO);
4183 NumIterations = CGF.Builder.CreateIntCast(NumIterations, CGF.Int64Ty,
4674 Address InitAddr = Builder.CreateBitCast(InitAddrIt->second, AddrTy);
5072 CGF.Builder.CreateIsNotNull(CGF.EmitLoadOfScalar(
tools/clang/lib/CodeGen/CGVTables.cpp 85 llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue);
86 CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull);
97 CGF.Builder.CreateBr(AdjustEnd);
99 CGF.Builder.CreateBr(AdjustEnd);
102 llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2);
210 Builder.SetInsertPoint(&*ThisStore);
213 AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr,
224 Builder.SetInsertPoint(&BB);
226 Builder.CreateRet(RV.getScalarVal());
407 AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType);
414 AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType);
415 Builder.CreateStore(AdjustedThisPtr, ThisAddr);
420 llvm::CallInst *Call = Builder.CreateCall(Callee, Args);
432 Builder.CreateRetVoid();
434 Builder.CreateRet(Call);
tools/clang/lib/CodeGen/CodeGenFunction.cpp 89 Builder.setFastMathFlags(FMF);
245 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
272 Builder.SetInsertPoint(BI->getParent());
316 DI->EmitLocation(Builder, LastStopPoint);
318 DI->EmitLocation(Builder, EndLoc);
334 DI->EmitLocation(Builder, EndLoc);
352 DI->EmitFunctionEnd(Builder, CurFn);
367 Builder.ClearInsertionPoint();
453 Builder.ClearInsertionPoint();
526 auto *PCRelAsInt = Builder.CreateSExt(EncodedAddr, IntPtrTy);
527 auto *FuncAsInt = Builder.CreatePtrToInt(F, IntPtrTy, "func_addr.int");
528 auto *GOTAsInt = Builder.CreateAdd(PCRelAsInt, FuncAsInt, "global_addr.int");
529 auto *GOTAddr = Builder.CreateIntToPtr(GOTAsInt, Int8PtrPtrTy, "global_addr");
532 return Builder.CreateLoad(Address(GOTAddr, getPointerAlign()),
563 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
564 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
565 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
571 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
572 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
573 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
580 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getSubGroupSize()))};
840 Builder.SetInsertPoint(EntryBB);
864 Builder);
912 Builder.CreateStore(Builder.CreatePointerBitCastOrAddrSpaceCast(
912 Builder.CreateStore(Builder.CreatePointerBitCastOrAddrSpaceCast(
922 llvm::Value *Addr = Builder.CreateStructGEP(nullptr, &*EI, Idx);
924 Addr = Builder.CreateAlignedLoad(Addr, getPointerAlign(), "agg.result");
1030 DI->EmitLocation(Builder, StartLoc);
1218 !FD->getReturnType()->isVoidType() && Builder.GetInsertBlock()) {
1224 llvm::Value *IsFalse = Builder.getFalse();
1233 Builder.CreateUnreachable();
1234 Builder.ClearInsertionPoint();
1558 Builder.CreateCondBr(CondV, TrueBlock, FalseBlock, Weights, Unpredictable);
1577 CGBuilderTy &Builder = CGF.Builder;
1588 llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock();
1630 DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1648 SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize));
1675 Address SrcPtr(Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()),
1675 Address SrcPtr(Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()),
1681 Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, false);
1688 Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, false);
1688 Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, false);
1754 llvm::ConstantInt *zero = Builder.getInt32(0);
1790 addr = Builder.CreateElementBitCast(addr, baseType, "array.begin");
1793 addr = Address(Builder.CreateInBoundsGEP(addr.getPointer(),
1805 numElements = Builder.CreateNUWMul(numVLAElements, numElements);
1833 numElements = Builder.CreateNUWMul(numElements, vlaSize);
1947 EmitCheck(std::make_pair(Builder.CreateICmpSGT(Size, Zero),
1954 entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false);
2031 Builder.GetInsertBlock());
2051 llvm::Instruction *Assumption = Builder.CreateAlignmentAssumption(
2079 Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy),
2080 Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy),
2083 return Builder.CreateCall(AnnotationFn, Args);
2092 Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()),
2109 V = Builder.CreateBitCast(V, CGM.Int8PtrTy);
2111 V = Builder.CreateBitCast(V, VTy);
2244 llvm::IRBuilder<> IRB(Builder.GetInsertBlock(), Builder.GetInsertPoint());
2244 llvm::IRBuilder<> IRB(Builder.GetInsertBlock(), Builder.GetInsertPoint());
2245 IRB.SetCurrentDebugLocation(Builder.getCurrentDebugLocation());
2259 Condition ? Builder.CreateAnd(Condition, FeatureCond) : FeatureCond;
2299 Builder.SetInsertPoint(CurBlock);
2303 Builder.SetInsertPoint(CurBlock);
2310 CreateMultiVersionResolverReturn(CGM, Resolver, Builder, RO.Function,
2320 Builder.CreateCondBr(Condition, RetBlock, CurBlock);
2324 Builder.SetInsertPoint(CurBlock);
2328 Builder.CreateUnreachable();
2329 Builder.ClearInsertionPoint();
2346 Builder.GetInsertBlock()->getParent()->getParent(),
2349 assert(&(Builder.GetInsertBlock()->back()) == Assumption &&
2369 OffsetValue = Builder.getInt1(0); // no offset.
2383 Builder.Insert(Assumption);
tools/clang/lib/CodeGen/CodeGenFunction.h 781 DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin());
793 DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
855 CGF.Builder.CreateStore(TempAddr.getPointer(), Temp);
1008 : StartBB(CGF.Builder.GetInsertBlock()) {}
1288 auto IP = CGF.Builder.saveAndClearIP();
1292 CGF.Builder.restoreIP(IP);
1322 CGF.Builder.CreateUnreachable();
1323 CGF.Builder.ClearInsertionPoint();
1344 PGO.emitCounterIncrement(Builder, S, StepV);
2103 return Builder.GetInsertBlock() != nullptr;
4381 CGF.Builder.CreateStore(value, alloca);
4393 return CGF.Builder.CreateAlignedLoad(alloca, alloca->getAlignment());
tools/clang/lib/CodeGen/CodeGenModule.cpp 1303 llvm::ConstantAsMetadata::get(CGF->Builder.getInt32(
1345 llvm::ConstantAsMetadata::get(CGF->Builder.getInt32(AddrSpc)));
5927 return CGF.Builder.CreateCall(CreateRuntimeFunction(FTy,
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 579 CGBuilderTy &Builder = CGF.Builder;
791 CGBuilderTy &Builder = CGF.Builder;
848 CGBuilderTy &Builder = CGF.Builder;
1045 CGBuilderTy &Builder = CGF.Builder;
1117 CGBuilderTy &Builder = CGF.Builder;
1186 llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
1189 CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1193 CGF.Builder.CreateBitCast(Ptr.getPointer(), CGF.Int8PtrTy);
1194 CompletePtr = CGF.Builder.CreateInBoundsGEP(CompletePtr, Offset);
1376 CGF.Builder.CreateUnreachable();
1389 Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL);
1390 return CGF.Builder.CreateAlignedLoad(Value, CGF.getPointerAlign());
1423 Value = CGF.Builder.CreateBitCast(Value, DestLTy);
1431 llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1432 CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1457 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL);
1459 CGF.Builder.CreateAlignedLoad(OffsetToTop, CGF.getPointerAlign(),
1465 Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop);
1467 return CGF.Builder.CreateBitCast(Value, DestLTy);
1474 CGF.Builder.CreateUnreachable();
1489 CGF.Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset.getQuantity(),
1491 VBaseOffsetPtr = CGF.Builder.CreateBitCast(VBaseOffsetPtr,
1495 CGF.Builder.CreateAlignedLoad(VBaseOffsetPtr, CGF.getPointerAlign(),
1583 getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
1596 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1729 VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex);
1732 return CGF.Builder.CreateAlignedLoad(VTT, CGF.getPointerAlign());
1793 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, VTableIndex, "vfn");
1795 CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
1914 Address V = CGF.Builder.CreateElementBitCast(InitialPtr, CGF.Int8Ty);
1918 V = CGF.Builder.CreateConstInBoundsByteGEP(V,
1928 Address VTablePtrPtr = CGF.Builder.CreateElementBitCast(V, CGF.Int8PtrTy);
1929 llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
1932 CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
1934 OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
1938 CGF.Builder.CreateAlignedLoad(OffsetPtr, CGF.getPointerAlign());
1941 ResultPtr = CGF.Builder.CreateInBoundsGEP(V.getPointer(), Offset);
1949 ResultPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ResultPtr,
1954 return CGF.Builder.CreateBitCast(ResultPtr, InitialPtr.getType());
2014 CookiePtr = CGF.Builder.CreateConstInBoundsByteGEP(CookiePtr, CookieOffset);
2018 CGF.Builder.CreateElementBitCast(CookiePtr, CGF.SizeTy);
2019 llvm::Instruction *SI = CGF.Builder.CreateStore(NumElements, NumElementsPtr);
2031 CGF.Builder.CreateCall(F, NumElementsPtr.getPointer());
2036 return CGF.Builder.CreateConstInBoundsByteGEP(NewPtr, CookieSize);
2047 CGF.Builder.CreateConstInBoundsByteGEP(numElementsPtr, numElementsOffset);
2050 numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
2052 return CGF.Builder.CreateLoad(numElementsPtr);
2062 return CGF.Builder.CreateCall(F, numElementsPtr.getPointer());
2089 cookie = CGF.Builder.CreateElementBitCast(cookie, CGF.SizeTy);
2092 CGF.Builder.CreateStore(elementSize, cookie);
2095 cookie = CGF.Builder.CreateConstInBoundsGEP(cookie, 1);
2096 CGF.Builder.CreateStore(numElements, cookie);
2101 return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
2110 = CGF.Builder.CreateConstInBoundsByteGEP(allocPtr, CGF.getSizeSize());
2112 numElementsPtr = CGF.Builder.CreateElementBitCast(numElementsPtr, CGF.SizeTy);
2113 return CGF.Builder.CreateLoad(numElementsPtr);
2173 CGBuilderTy &Builder = CGF.Builder;
2722 llvm::CallInst *CallVal = CGF.Builder.CreateCall(Wrapper);
4122 AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize);
4146 llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4147 CGF.Builder.CreateStore(Casted, ExnPtrTmp);
4155 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
4156 CGF.Builder.CreateStore(ExnCast, ParamAddr);
4169 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
4179 CGF.Builder.CreateStore(CastExn, ParamAddr);
4192 llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
4223 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
4237 Address adjustedExn(CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy),
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 870 llvm::BasicBlock *CatchPadBB = CGF.Builder.GetInsertBlock();
894 Value = CGF.Builder.CreateBitCast(Value, CGF.Int8PtrTy);
919 llvm::Value *Ptr = CGF.Builder.CreateInBoundsGEP(Value.getPointer(), Offset);
946 CGF.Builder.CreateUnreachable();
956 return CGF.Builder.CreateBitCast(Typeid, StdTypeInfoPtrTy);
980 Offset = CGF.Builder.CreateTrunc(Offset, CGF.Int32Ty);
997 return CGF.Builder.CreateBitCast(ThisPtr, DestLTy);
1038 CGF.Builder.CreateSExtOrBitCast(VBPtrToNewBase, CGM.PtrDiffTy);
1039 return CGF.Builder.CreateNSWAdd(VBPtrOffset, VBPtrToNewBase);
1118 CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object");
1122 CGF.Builder.CreateCondBr(IsCompleteObject,
1141 CGF.Builder.CreateIsNotNull(IsMostDerivedClass, "is_complete_object");
1145 CGF.Builder.CreateCondBr(IsCompleteObject,
1172 CGBuilderTy &Builder = CGF.Builder;
1236 This = CGF.Builder.CreateElementBitCast(This, CGM.Int8Ty, "this.int8");
1250 Address VBPtr = CGF.Builder.CreateConstInBoundsByteGEP(This, Offs);
1252 CGF.Builder.CreateConstInBoundsGEP2_32(GV->getValueType(), GV, 0, 0);
1253 VBPtr = CGF.Builder.CreateElementBitCast(VBPtr, GVPtr->getType(),
1255 CGF.Builder.CreateStore(GVPtr, VBPtr);
1389 This = CGF.Builder.CreateElementBitCast(This, CGF.Int8Ty);
1391 return CGF.Builder.CreateConstByteGEP(This, Adjustment);
1420 Result = CGF.Builder.CreateElementBitCast(Result, CGF.Int8Ty);
1427 CGF.Builder.CreateInBoundsGEP(Result.getPointer(), VBaseOffset);
1434 Result = CGF.Builder.CreateElementBitCast(Result, CGF.Int8Ty);
1440 Result = CGF.Builder.CreateConstByteGEP(Result, StaticOffset);
1442 Result = CGF.Builder.CreateConstInBoundsByteGEP(Result, StaticOffset);
1502 This = CGF.Builder.CreateBitCast(This, charPtrTy);
1504 This = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, This,
1506 This = CGF.Builder.CreateBitCast(This, thisTy, "this.adjusted");
1520 CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
1522 CGF.Builder.CreateStore(CGF.EmitCastToVoidPtr(getThisValue(CGF)),
1529 = CGF.Builder.CreateLoad(
1538 = CGF.Builder.CreateLoad(
1601 CGF.Builder.CreateBr(BaseDtorEndBB);
1861 CGBuilderTy &Builder = CGF.Builder;
2028 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn");
2030 CGF.Builder.CreateAlignedLoad(VFuncPtr, CGF.getPointerAlign());
2132 This = CGF.Builder.CreateElementBitCast(This, CGF.Int8Ty);
2141 CGF.Builder.CreateConstInBoundsByteGEP(This,
2143 VtorDispPtr = CGF.Builder.CreateElementBitCast(VtorDispPtr, CGF.Int32Ty);
2144 llvm::Value *VtorDisp = CGF.Builder.CreateLoad(VtorDispPtr, "vtordisp");
2145 V = CGF.Builder.CreateGEP(This.getPointer(),
2146 CGF.Builder.CreateNeg(VtorDisp));
2163 V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset);
2171 V = CGF.Builder.CreateConstGEP1_32(V, TA.NonVirtual);
2185 Ret = CGF.Builder.CreateElementBitCast(Ret, CGF.Int8Ty);
2195 V = CGF.Builder.CreateInBoundsGEP(VBPtr, VBaseOffset);
2199 V = CGF.Builder.CreateConstInBoundsGEP1_32(CGF.Int8Ty, V, RA.NonVirtual);
2202 return CGF.Builder.CreateBitCast(V, OrigTy);
2230 CGF.Builder.CreateElementBitCast(allocPtr, CGF.SizeTy);
2231 return CGF.Builder.CreateLoad(numElementsPtr);
2249 = CGF.Builder.CreateElementBitCast(cookiePtr, CGF.SizeTy);
2250 CGF.Builder.CreateStore(numElements, numElementsPtr);
2254 return CGF.Builder.CreateConstInBoundsByteGEP(newPtr, cookieSize);
2408 CGBuilderTy &Builder = CGF.Builder;
2448 CGBuilderTy &Builder = CGF.Builder;
2822 CGBuilderTy &Builder = CGF.Builder;
2880 CGBuilderTy &Builder = CGF.Builder;
2944 CGBuilderTy &Builder = CGF.Builder;
2980 CGBuilderTy &Builder = CGF.Builder;
3040 CGBuilderTy &Builder = CGF.Builder;
3108 CGBuilderTy &Builder = CGF.Builder;
3333 CGBuilderTy &Builder = CGF.Builder;
3952 IsCopy ? CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(&SrcParam), "src")
4287 CGF.Builder.CreateBitCast(AI.getPointer(), CGM.Int8PtrTy),
tools/clang/lib/CodeGen/TargetInfo.cpp 262 PtrAsInt = CGF.Builder.CreatePtrToInt(PtrAsInt, CGF.IntPtrTy);
263 PtrAsInt = CGF.Builder.CreateAdd(PtrAsInt,
265 PtrAsInt = CGF.Builder.CreateAnd(PtrAsInt,
267 PtrAsInt = CGF.Builder.CreateIntToPtr(PtrAsInt,
297 VAListAddr = CGF.Builder.CreateElementBitCast(VAListAddr, CGF.Int8PtrTy);
299 llvm::Value *Ptr = CGF.Builder.CreateLoad(VAListAddr, "argp.cur");
313 CGF.Builder.CreateConstInBoundsByteGEP(Addr, FullDirectSize, "argp.next");
314 CGF.Builder.CreateStore(NextPtr.getPointer(), VAListAddr);
320 Addr = CGF.Builder.CreateConstInBoundsByteGEP(Addr, SlotSize - DirectSize);
323 Addr = CGF.Builder.CreateElementBitCast(Addr, DirectTy);
366 Addr = Address(CGF.Builder.CreateLoad(Addr), ValueInfo.second);
378 llvm::PHINode *PHI = CGF.Builder.CreatePHI(Addr1.getType(), 2, Name);
453 return CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
633 CGF.Builder.CreateVAArg(VAListAddr.getPointer(), BaseTy);
649 Val = CGF.Builder.CreateVAArg(VAListAddr.getPointer(), CGF.ConvertType(Ty));
650 CGF.Builder.CreateStore(Val, Temp);
1228 ReturnSlot.setAddress(CGF.Builder.CreateBitCast(ReturnSlot.getAddress(),
1999 CodeGen::CGBuilderTy &Builder = CGF.Builder;
2308 AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
2445 AssignToArrayRange(CGF.Builder, Address, Eight8, 0, 16);
3683 CGF.Builder.CreateStructGEP(VAListAddr, 2, "overflow_arg_area_p");
3685 CGF.Builder.CreateLoad(overflow_arg_area_p, "overflow_arg_area");
3700 CGF.Builder.CreateBitCast(overflow_arg_area,
3711 overflow_arg_area = CGF.Builder.CreateGEP(overflow_arg_area, Offset,
3713 CGF.Builder.CreateStore(overflow_arg_area, overflow_arg_area_p);
3754 gp_offset_p = CGF.Builder.CreateStructGEP(VAListAddr, 0, "gp_offset_p");
3755 gp_offset = CGF.Builder.CreateLoad(gp_offset_p, "gp_offset");
3757 InRegs = CGF.Builder.CreateICmpULE(gp_offset, InRegs, "fits_in_gp");
3761 fp_offset_p = CGF.Builder.CreateStructGEP(VAListAddr, 1, "fp_offset_p");
3762 fp_offset = CGF.Builder.CreateLoad(fp_offset_p, "fp_offset");
3765 FitsInFP = CGF.Builder.CreateICmpULE(fp_offset, FitsInFP, "fits_in_fp");
3766 InRegs = InRegs ? CGF.Builder.CreateAnd(InRegs, FitsInFP) : FitsInFP;
3772 CGF.Builder.CreateCondBr(InRegs, InRegBlock, InMemBlock);
3789 llvm::Value *RegSaveArea = CGF.Builder.CreateLoad(
3790 CGF.Builder.CreateStructGEP(VAListAddr, 3), "reg_save_area");
3798 Tmp = CGF.Builder.CreateElementBitCast(Tmp, ST);
3806 llvm::Value *GPAddr = CGF.Builder.CreateGEP(RegSaveArea, gp_offset);
3807 llvm::Value *FPAddr = CGF.Builder.CreateGEP(RegSaveArea, fp_offset);
3813 llvm::Value *V = CGF.Builder.CreateAlignedLoad(
3814 TyLo, CGF.Builder.CreateBitCast(RegLoAddr, PTyLo),
3816 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 0));
3816 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 0));
3819 V = CGF.Builder.CreateAlignedLoad(
3820 TyHi, CGF.Builder.CreateBitCast(RegHiAddr, PTyHi),
3822 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1));
3822 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1));
3824 RegAddr = CGF.Builder.CreateElementBitCast(Tmp, LTy);
3826 RegAddr = Address(CGF.Builder.CreateGEP(RegSaveArea, gp_offset),
3828 RegAddr = CGF.Builder.CreateElementBitCast(RegAddr, LTy);
3840 CGF.Builder.CreateMemCpy(Tmp, RegAddr, TySize, false);
3845 RegAddr = Address(CGF.Builder.CreateGEP(RegSaveArea, fp_offset),
3847 RegAddr = CGF.Builder.CreateElementBitCast(RegAddr, LTy);
3856 Address RegAddrLo = Address(CGF.Builder.CreateGEP(RegSaveArea, fp_offset),
3859 CGF.Builder.CreateConstInBoundsByteGEP(RegAddrLo,
3866 Tmp = CGF.Builder.CreateElementBitCast(Tmp, ST);
3867 V = CGF.Builder.CreateLoad(CGF.Builder.CreateElementBitCast(
3867 V = CGF.Builder.CreateLoad(CGF.Builder.CreateElementBitCast(
3869 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 0));
3869 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 0));
3870 V = CGF.Builder.CreateLoad(CGF.Builder.CreateElementBitCast(
3870 V = CGF.Builder.CreateLoad(CGF.Builder.CreateElementBitCast(
3872 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1));
3872 CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1));
3874 RegAddr = CGF.Builder.CreateElementBitCast(Tmp, LTy);
3882 CGF.Builder.CreateStore(CGF.Builder.CreateAdd(gp_offset, Offset),
3882 CGF.Builder.CreateStore(CGF.Builder.CreateAdd(gp_offset, Offset),
3887 CGF.Builder.CreateStore(CGF.Builder.CreateAdd(fp_offset, Offset),
3887 CGF.Builder.CreateStore(CGF.Builder.CreateAdd(fp_offset, Offset),
4217 CGBuilderTy &Builder = CGF.Builder;
4340 CodeGen::CGBuilderTy &Builder = CGF.Builder;
4881 RealAddr = CGF.Builder.CreateConstInBoundsByteGEP(RealAddr,
4883 ImagAddr = CGF.Builder.CreateConstInBoundsByteGEP(ImagAddr,
4886 ImagAddr = CGF.Builder.CreateConstInBoundsByteGEP(RealAddr, SlotSize);
4890 RealAddr = CGF.Builder.CreateElementBitCast(RealAddr, EltTy);
4891 ImagAddr = CGF.Builder.CreateElementBitCast(ImagAddr, EltTy);
4892 llvm::Value *Real = CGF.Builder.CreateLoad(RealAddr, ".vareal");
4893 llvm::Value *Imag = CGF.Builder.CreateLoad(ImagAddr, ".vaimag");
4913 CodeGen::CGBuilderTy &Builder = CGF.Builder;
5343 reg_offs_p = CGF.Builder.CreateStructGEP(VAListAddr, 3, "gr_offs_p");
5344 reg_offs = CGF.Builder.CreateLoad(reg_offs_p, "gr_offs");
5349 reg_offs_p = CGF.Builder.CreateStructGEP(VAListAddr, 4, "vr_offs_p");
5350 reg_offs = CGF.Builder.CreateLoad(reg_offs_p, "vr_offs");
5364 UsingStack = CGF.Builder.CreateICmpSGE(
5367 CGF.Builder.CreateCondBr(UsingStack, OnStackBlock, MaybeRegBlock);
5379 reg_offs = CGF.Builder.CreateAdd(
5382 reg_offs = CGF.Builder.CreateAnd(
5392 NewOffset = CGF.Builder.CreateAdd(
5394 CGF.Builder.CreateStore(NewOffset, reg_offs_p);
5399 InRegs = CGF.Builder.CreateICmpSLE(
5402 CGF.Builder.CreateCondBr(InRegs, InRegBlock, OnStackBlock);
5414 CGF.Builder.CreateStructGEP(VAListAddr, reg_top_index, "reg_top_p");
5415 reg_top = CGF.Builder.CreateLoad(reg_top_p, "reg_top");
5416 Address BaseAddr(CGF.Builder.CreateInBoundsGEP(reg_top, reg_offs),
5451 CGF.Builder.CreateConstInBoundsByteGEP(BaseAddr, BaseOffset);
5452 LoadAddr = CGF.Builder.CreateElementBitCast(LoadAddr, BaseTy);
5454 Address StoreAddr = CGF.Builder.CreateConstArrayGEP(Tmp, i);
5456 llvm::Value *Elem = CGF.Builder.CreateLoad(LoadAddr);
5457 CGF.Builder.CreateStore(Elem, StoreAddr);
5460 RegAddr = CGF.Builder.CreateElementBitCast(Tmp, MemTy);
5470 BaseAddr = CGF.Builder.CreateConstInBoundsByteGEP(BaseAddr, Offset);
5473 RegAddr = CGF.Builder.CreateElementBitCast(BaseAddr, MemTy);
5483 Address stack_p = CGF.Builder.CreateStructGEP(VAListAddr, 0, "stack_p");
5484 llvm::Value *OnStackPtr = CGF.Builder.CreateLoad(stack_p, "stack");
5491 OnStackPtr = CGF.Builder.CreatePtrToInt(OnStackPtr, CGF.Int64Ty);
5493 OnStackPtr = CGF.Builder.CreateAdd(
5496 OnStackPtr = CGF.Builder.CreateAnd(
5500 OnStackPtr = CGF.Builder.CreateIntToPtr(OnStackPtr, CGF.Int8PtrTy);
5513 llvm::Value *StackSizeC = CGF.Builder.getSize(StackSize);
5515 CGF.Builder.CreateInBoundsGEP(OnStackPtr, StackSizeC, "new_stack");
5518 CGF.Builder.CreateStore(NewStack, stack_p);
5523 OnStackAddr = CGF.Builder.CreateConstInBoundsByteGEP(OnStackAddr, Offset);
5526 OnStackAddr = CGF.Builder.CreateElementBitCast(OnStackAddr, MemTy);
5539 return Address(CGF.Builder.CreateLoad(ResAddr, "vaarg.addr"),
5557 Address Addr(CGF.Builder.CreateLoad(VAListAddr, "ap.cur"), SlotSize);
5558 Addr = CGF.Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(Ty));
5698 AssignToArrayRange(CGF.Builder, Address, Four8, 0, 15);
6291 Address Addr(CGF.Builder.CreateLoad(VAListAddr), SlotSize);
6292 Addr = CGF.Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(Ty));
6724 CGF.Builder.CreateStructGEP(VAListAddr, 2, "overflow_arg_area_ptr");
6726 Address(CGF.Builder.CreateLoad(OverflowArgAreaPtr, "overflow_arg_area"),
6729 CGF.Builder.CreateElementBitCast(OverflowArgArea, DirectTy, "mem_addr");
6733 CGF.Builder.CreateGEP(OverflowArgArea.getPointer(), PaddedSizeV,
6735 CGF.Builder.CreateStore(NewOverflowArgArea, OverflowArgAreaPtr);
6757 CGF.Builder.CreateStructGEP(VAListAddr, RegCountField, "reg_count_ptr");
6758 llvm::Value *RegCount = CGF.Builder.CreateLoad(RegCountPtr, "reg_count");
6760 llvm::Value *InRegs = CGF.Builder.CreateICmpULT(RegCount, MaxRegsV,
6766 CGF.Builder.CreateCondBr(InRegs, InRegBlock, InMemBlock);
6773 CGF.Builder.CreateMul(RegCount, PaddedSizeV, "scaled_reg_count");
6778 CGF.Builder.CreateAdd(ScaledRegCount, RegBase, "reg_offset");
6780 CGF.Builder.CreateStructGEP(VAListAddr, 3, "reg_save_area_ptr");
6782 CGF.Builder.CreateLoad(RegSaveAreaPtr, "reg_save_area");
6783 Address RawRegAddr(CGF.Builder.CreateGEP(RegSaveArea, RegOffset,
6787 CGF.Builder.CreateElementBitCast(RawRegAddr, DirectTy, "reg_addr");
6792 CGF.Builder.CreateAdd(RegCount, One, "reg_count");
6793 CGF.Builder.CreateStore(NewRegCount, RegCountPtr);
6801 CGF.Builder.CreateStructGEP(VAListAddr, 2, "overflow_arg_area_ptr");
6803 Address(CGF.Builder.CreateLoad(OverflowArgAreaPtr, "overflow_arg_area"),
6806 CGF.Builder.CreateConstByteGEP(OverflowArgArea, Padding, "raw_mem_addr");
6808 CGF.Builder.CreateElementBitCast(RawMemAddr, DirectTy, "mem_addr");
6812 CGF.Builder.CreateGEP(OverflowArgArea.getPointer(), PaddedSizeV,
6814 CGF.Builder.CreateStore(NewOverflowArgArea, OverflowArgAreaPtr);
6823 ResAddr = Address(CGF.Builder.CreateLoad(ResAddr, "indirect_arg"),
7282 llvm::Value *Promoted = CGF.Builder.CreateLoad(Addr);
7287 llvm::Value *V = CGF.Builder.CreateTrunc(Promoted, IntTy);
7289 V = CGF.Builder.CreateIntToPtr(V, Temp.getElementType());
7291 CGF.Builder.CreateStore(V, Temp);
7322 AssignToArrayRange(CGF.Builder, Address, Four8, 0, 65);
7332 AssignToArrayRange(CGF.Builder, Address, Four8, 80, 181);
8360 CGBuilderTy &Builder = CGF.Builder;
8433 CodeGen::CGBuilderTy &Builder = CGF.Builder;
8713 CGBuilderTy &Builder = CGF.Builder;
9640 Address Addr(CGF.Builder.CreateLoad(VAListAddr), SlotSize);
9641 Addr = CGF.Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(Ty));
9900 auto IP = CGF.Builder.saveIP();
9902 auto &Builder = CGF.Builder;
9924 auto &Builder = CGF.Builder;
9959 auto IP = CGF.Builder.saveIP();