Lines Matching refs:Builder
66 return CGF.Builder.CreatePtrToInt(V, IntType);
77 return CGF.Builder.CreateIntToPtr(V, ResultType);
103 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
109 CGF.Builder.CreateAtomicRMW(Kind, Args[0], Args[1],
120 Value *BC = CGF.Builder.CreateBitCast(
168 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
171 CGF.Builder.CreateAtomicRMW(Kind, Args[0], Args[1],
173 Result = CGF.Builder.CreateBinOp(Op, Result, Args[1]);
175 Result = CGF.Builder.CreateBinOp(llvm::Instruction::Xor, Result,
203 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
209 Value *Pair = CGF.Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2],
214 return CGF.Builder.CreateZExt(CGF.Builder.CreateExtractValue(Pair, 1),
218 return EmitFromInt(CGF, CGF.Builder.CreateExtractValue(Pair, 0), T,
225 llvm::CallInst *Call = CGF.Builder.CreateCall(F, V);
238 V = CGF.Builder.CreateBitCast(V, IntTy);
250 V = CGF.Builder.CreateLShr(V, ShiftCst);
255 V = CGF.Builder.CreateTrunc(V, IntTy);
258 return CGF.Builder.CreateICmpSLT(V, Zero);
286 llvm::Value *Tmp = CGF.Builder.CreateCall(Callee, {X, Y});
287 Carry = CGF.Builder.CreateExtractValue(Tmp, 1);
288 return CGF.Builder.CreateExtractValue(Tmp, 0);
339 Builder.CreateBitCast(ArgValue, DestType, ArgValue->getName().data());
342 return Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue);
403 auto *CI = ConstantInt::get(Builder
405 llvm::Type *Tys[] = {ResType, Builder.getInt8PtrTy(0)};
407 return Builder.CreateCall(F, {EmitScalarExpr(E), CI});
445 DstPtr = Builder.CreateBitCast(DstPtr, Type);
446 SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
447 return RValue::get(Builder.CreateCall(CGM.getIntrinsic(Intrinsic::vacopy),
455 Value *NegOp = Builder.CreateNeg(ArgValue, "neg");
457 Builder.CreateICmpSGE(ArgValue,
461 Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
477 Value *Result = Builder.CreateFRem(Arg1, Arg2, "fmod");
492 Imag = Builder.CreateFSub(Zero, Imag, "sub");
525 Value *ZeroUndef = Builder.getInt1(getTarget().isCLZForZeroUndef());
526 Value *Result = Builder.CreateCall(F, {ArgValue, ZeroUndef});
528 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
542 Value *ZeroUndef = Builder.getInt1(getTarget().isCLZForZeroUndef());
543 Value *Result = Builder.CreateCall(F, {ArgValue, ZeroUndef});
545 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
560 Builder.CreateAdd(Builder.CreateCall(F, {ArgValue, Builder.getTrue()}),
563 Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
564 Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
566 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
580 Value *Tmp = Builder.CreateCall(F, ArgValue);
581 Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1));
583 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
596 Value *Result = Builder.CreateCall(F, ArgValue);
598 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
621 Builder.CreateCall(FnExpect, {ArgValue, ExpectedValue}, "expval");
643 return RValue::get(Builder.CreateCall(FnAssume, ArgValue));
651 return RValue::get(Builder.CreateCall(F, ArgValue));
671 return RValue::get(Builder.CreateCall(F, {Address, RW, Locality, Data}));
675 return RValue::get(Builder.CreateCall(F));
681 return RValue::get(Builder.CreateCall(F, {Begin, End}));
690 EmitCheck(std::make_pair(static_cast<llvm::Value *>(Builder.getFalse()),
695 Builder.CreateUnreachable();
710 return RValue::get(Builder.CreateCall(F, {Base, Exponent}));
727 LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
730 LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
733 LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
736 LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
739 LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
742 LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
746 return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType())));
750 V = Builder.CreateFCmpUNO(V, V, "cmp");
751 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
759 V = Builder.CreateFCmpOEQ(V, ConstantFP::getInfinity(V->getType()),"isinf");
760 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
767 Value *IsInf = Builder.CreateFCmpOEQ(
775 Value *SignResult = Builder.CreateSelect(IsNeg, NegativeOne, One);
776 Value *Result = Builder.CreateSelect(IsInf, SignResult, Zero);
783 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
787 Builder.CreateFCmpULT(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
791 Builder.CreateFCmpUGE(Abs, ConstantFP::get(V->getContext(), Smallest),
793 V = Builder.CreateAnd(Eq, IsLessThanInf, "and");
794 V = Builder.CreateAnd(V, IsNormal, "and");
795 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
801 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
805 Builder.CreateFCmpUNE(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
807 V = Builder.CreateAnd(Eq, IsNotInf, "and");
808 return RValue::get(Builder
816 BasicBlock *Begin = Builder.GetInsertBlock();
818 Builder.SetInsertPoint(End);
820 Builder.CreatePHI(ConvertType(E->getArg(0)->getType()), 4,
824 Builder.SetInsertPoint(Begin);
825 Value *IsZero = Builder.CreateFCmpOEQ(V, Constant::getNullValue(Ty),
829 Builder.CreateCondBr(IsZero, End, NotZero);
833 Builder.SetInsertPoint(NotZero);
834 Value *IsNan = Builder.CreateFCmpUNO(V, V, "cmp");
837 Builder.CreateCondBr(IsNan, End, NotNan);
841 Builder.SetInsertPoint(NotNan);
844 Builder.CreateFCmpOEQ(VAbs, ConstantFP::getInfinity(V->getType()),
848 Builder.CreateCondBr(IsInf, End, NotInf);
852 Builder.SetInsertPoint(NotInf);
856 Builder.CreateFCmpUGE(VAbs, ConstantFP::get(V->getContext(), Smallest),
859 Builder.CreateSelect(IsNormal, EmitScalarExpr(E->getArg(2)),
861 Builder.CreateBr(End);
865 Builder.SetInsertPoint(End);
873 return RValue::get(Builder.CreateAlloca(Builder.getInt8Ty(), Size));
881 Builder.CreateMemSet(Dest, Builder.getInt8(0), SizeVal, false);
893 Builder.CreateMemCpy(Dest, Src, SizeVal, false);
907 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
908 Builder.CreateMemCpy(Dest, Src, SizeVal, false);
931 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
932 Builder.CreateMemMove(Dest, Src, SizeVal, false);
945 Builder.CreateMemMove(Dest, Src, SizeVal, false);
951 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
952 Builder.getInt8Ty());
956 Builder.CreateMemSet(Dest, ByteVal, SizeVal, false);
968 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
969 Builder.getInt8Ty());
970 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
971 Builder.CreateMemSet(Dest, ByteVal, SizeVal, false);
986 return RValue::get(Builder.CreateCall(F,
993 return RValue::get(Builder.CreateCall(F, Depth));
999 return RValue::get(Builder.CreateCall(F, Depth));
1037 Builder.CreateCall(F, {Int, Ptr});
1038 Builder.CreateUnreachable();
1047 return RValue::get(Builder.CreateCall(F));
1062 Value *Result = Builder.CreatePtrToInt(Ptr, IntPtrTy, "extend.cast");
1070 return RValue::get(Builder.CreateSExt(Result, Int64Ty, "extend.sext"));
1072 return RValue::get(Builder.CreateZExt(Result, Int64Ty, "extend.zext"));
1080 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::frameaddress),
1082 Builder.CreateStore(FrameAddr, Buf);
1086 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::stacksave));
1088 Builder.CreateConstInBoundsGEP(Buf, 2, getPointerSize());
1089 Builder.CreateStore(StackAddr, StackSaveSlot);
1093 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
1094 return RValue::get(Builder.CreateCall(F, Buf.getPointer()));
1098 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
1101 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::eh_sjlj_longjmp), Buf);
1104 Builder.CreateUnreachable();
1257 Ptr = Builder.CreateBitCast(Ptr, ITy->getPointerTo());
1259 Builder.CreateAlignedStore(llvm::Constant::getNullValue(ITy), Ptr,
1273 Builder.CreateFence(llvm::SequentiallyConsistent);
1314 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
1315 Value *NewVal = Builder.getInt8(1);
1323 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1329 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1334 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1339 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1344 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1350 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
1367 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1368 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
1370 Builder.SetInsertPoint(ContBB);
1371 PHINode *Result = Builder.CreatePHI(Int8Ty, 5, "was_set");
1374 Builder.SetInsertPoint(BBs[i]);
1375 AtomicRMWInst *RMW = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1379 Builder.CreateBr(ContBB);
1382 SI->addCase(Builder.getInt32(0), BBs[0]);
1383 SI->addCase(Builder.getInt32(1), BBs[1]);
1384 SI->addCase(Builder.getInt32(2), BBs[1]);
1385 SI->addCase(Builder.getInt32(3), BBs[2]);
1386 SI->addCase(Builder.getInt32(4), BBs[3]);
1387 SI->addCase(Builder.getInt32(5), BBs[4]);
1389 Builder.SetInsertPoint(ContBB);
1390 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
1400 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
1401 Value *NewVal = Builder.getInt8(0);
1405 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
1432 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1433 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
1436 Builder.SetInsertPoint(BBs[i]);
1437 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
1439 Builder.CreateBr(ContBB);
1442 SI->addCase(Builder.getInt32(0), BBs[0]);
1443 SI->addCase(Builder.getInt32(3), BBs[1]);
1444 SI->addCase(Builder.getInt32(5), BBs[2]);
1446 Builder.SetInsertPoint(ContBB);
1469 Builder.CreateFence(llvm::Acquire, Scope);
1472 Builder.CreateFence(llvm::Release, Scope);
1475 Builder.CreateFence(llvm::AcquireRelease, Scope);
1478 Builder.CreateFence(llvm::SequentiallyConsistent, Scope);
1491 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1492 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, ContBB);
1494 Builder.SetInsertPoint(AcquireBB);
1495 Builder.CreateFence(llvm::Acquire, Scope);
1496 Builder.CreateBr(ContBB);
1497 SI->addCase(Builder.getInt32(1), AcquireBB);
1498 SI->addCase(Builder.getInt32(2), AcquireBB);
1500 Builder.SetInsertPoint(ReleaseBB);
1501 Builder.CreateFence(llvm::Release, Scope);
1502 Builder.CreateBr(ContBB);
1503 SI->addCase(Builder.getInt32(3), ReleaseBB);
1505 Builder.SetInsertPoint(AcqRelBB);
1506 Builder.CreateFence(llvm::AcquireRelease, Scope);
1507 Builder.CreateBr(ContBB);
1508 SI->addCase(Builder.getInt32(4), AcqRelBB);
1510 Builder.SetInsertPoint(SeqCstBB);
1511 Builder.CreateFence(llvm::SequentiallyConsistent, Scope);
1512 Builder.CreateBr(ContBB);
1513 SI->addCase(Builder.getInt32(5), SeqCstBB);
1515 Builder.SetInsertPoint(ContBB);
1535 return RValue::get(Builder.CreateCall(F, Arg0));
1551 return RValue::get(Builder.CreateCall(F, {Base, Exponent}));
1565 Builder.CreateCall(F, {FirstArg, EmitScalarExpr(E->getArg(1)),
1573 Builder.CreateZExt(EmitSignBit(*this, EmitScalarExpr(E->getArg(0))),
1648 llvm::Value *CarryOut = Builder.CreateZExt(Builder.CreateOr(Carry1, Carry2),
1650 Builder.CreateStore(CarryOut, CarryOutPtr);
1704 Left = Builder.CreateIntCast(Left, EncompassingLLVMTy, LeftInfo.Signed);
1705 Right = Builder.CreateIntCast(Right, EncompassingLLVMTy, RightInfo.Signed);
1714 llvm::Value *ResultTrunc = Builder.CreateTrunc(Result, ResultLLVMTy);
1718 llvm::Value *ResultTruncExt = Builder.CreateIntCast(
1721 Builder.CreateICmpNE(Result, ResultTruncExt);
1723 Overflow = Builder.CreateOr(Overflow, TruncationOverflow);
1730 Builder.CreateStore(EmitToMemory(Result, ResultQTy), ResultPtr, isVolatile);
1800 Builder.CreateStore(Sum, SumOutPtr);
1833 Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), IntPtrType);
1837 Exchange = Builder.CreatePtrToInt(Exchange, IntType);
1840 Builder.CreatePtrToInt(EmitScalarExpr(E->getArg(2)), IntType);
1842 auto Result = Builder.CreateAtomicCmpXchg(Destination, Comparand, Exchange,
1847 return RValue::get(Builder.CreateIntToPtr(Builder.CreateExtractValue(Result,
1852 AtomicCmpXchgInst *CXI = Builder.CreateAtomicCmpXchg(
1859 return RValue::get(Builder.CreateExtractValue(CXI, 0));
1862 AtomicRMWInst *RMWI = Builder.CreateAtomicRMW(
1868 return RValue::get(Builder.CreateAdd(RMWI, ConstantInt::get(Int32Ty, 1)));
1871 AtomicRMWInst *RMWI = Builder.CreateAtomicRMW(
1877 return RValue::get(Builder.CreateSub(RMWI, ConstantInt::get(Int32Ty, 1)));
1880 AtomicRMWInst *RMWI = Builder.CreateAtomicRMW(
1890 Builder.CreateIntToPtr(EmitScalarExpr(E->getArg(0)),
1893 Builder.CreateAlignedLoad(IntToPtr, /*Align=*/4, /*isVolatile=*/true);
1915 llvm::Value *Buf = Builder.CreateBitOrPointerCast(
1918 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::frameaddress),
1932 llvm::Value *Buf = Builder.CreateBitOrPointerCast(
1949 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::frameaddress),
2034 ArgValue = Builder.CreateBitCast(ArgValue, PTy);
2040 Value *V = Builder.CreateCall(F, Args);
2050 V = Builder.CreateBitCast(V, RetTy);
2160 return Builder.CreateShuffleVector(V, V, SV, "lane");
2172 Ops[j] = Builder.CreateBitCast(Ops[j], ai->getType(), name);
2174 return Builder.CreateCall(F, Ops, name);
2192 Vec = Builder.CreateBitCast(Vec, Ty);
2210 return Builder.CreateLShr(Vec, Shift, name);
2212 return Builder.CreateAShr(Vec, Shift, name);
2911 CGF.Builder.CreateTruncOrBitCast(Ops[j], ArgTy->getVectorElementType());
2913 CGF.Builder.CreateInsertElement(UndefValue::get(ArgTy), Ops[j], C0);
2920 return CGF.Builder.CreateExtractElement(Result, C0);
2922 return CGF.Builder.CreateBitCast(Result, ResultType, s);
2946 return Builder.getInt32(addr.getAlignment().getQuantity());
2965 Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
2966 Ops[1] = Builder.CreateBitCast(Ops[1], SrcTy);
2967 Ops[0] = Builder.CreateAdd(Ops[0], Ops[1], "vaddhn");
2972 Ops[0] = Builder.CreateLShr(Ops[0], ShiftAmt, "vaddhn");
2975 return Builder.CreateTrunc(Ops[0], VTy, "vaddhn");
2997 Ops.push_back(Builder.getInt1(getTarget().isCLZForZeroUndef()));
3001 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
3003 return Usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
3004 : Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
3034 Ops[0] = Builder.CreateBitCast(Ops[0], GetFloatNeonType(this, Type));
3035 return Usgn ? Builder.CreateFPToUI(Ops[0], Ty, "vcvt")
3036 : Builder.CreateFPToSI(Ops[0], Ty, "vcvt");
3080 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
3081 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
3083 return Builder.CreateShuffleVector(Ops[0], Ops[1], SV, "vext");
3088 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
3089 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
3090 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
3093 return Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0]});
3110 Ops[1] = Builder.CreateCall(F, {Ops[1], Align}, NameHint);
3112 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
3113 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
3119 PtrOp0 = Builder.CreateBitCast(PtrOp0, Ty);
3120 LoadInst *Ld = Builder.CreateLoad(PtrOp0);
3122 Ops[0] = Builder.CreateInsertElement(V, Ld, CI);
3134 Ops[I] = Builder.CreateBitCast(Ops[I], Ty);
3136 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), NameHint);
3138 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
3139 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
3143 Ops[0] = Builder.CreateBitCast(Ops[0], DTy);
3145 return Builder.CreateZExt(Ops[0], Ty, "vmovl");
3146 return Builder.CreateSExt(Ops[0], Ty, "vmovl");
3150 Ops[0] = Builder.CreateBitCast(Ops[0], QTy);
3151 return Builder.CreateTrunc(Ops[0], Ty, "vmovn");
3213 return Builder.CreateShl(Builder.CreateBitCast(Ops[0],Ty), Ops[1],
3217 Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
3219 Ops[0] = Builder.CreateZExt(Ops[0], VTy);
3221 Ops[0] = Builder.CreateSExt(Ops[0], VTy);
3223 return Builder.CreateShl(Ops[0], Ops[1], "vshll_n");
3227 Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
3230 Ops[0] = Builder.CreateLShr(Ops[0], Ops[1]);
3232 Ops[0] = Builder.CreateAShr(Ops[0], Ops[1]);
3233 return Builder.CreateTrunc(Ops[0], Ty, "vshrn_n");
3261 Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
3262 Ops[1] = Builder.CreateBitCast(Ops[1], SrcTy);
3263 Ops[0] = Builder.CreateSub(Ops[0], Ops[1], "vsubhn");
3268 Ops[0] = Builder.CreateLShr(Ops[0], ShiftAmt, "vsubhn");
3271 return Builder.CreateTrunc(Ops[0], VTy, "vsubhn");
3275 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
3276 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
3277 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
3283 Indices.push_back(Builder.getInt32(i+vi));
3284 Indices.push_back(Builder.getInt32(i+e+vi));
3286 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
3288 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vtrn");
3289 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
3295 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
3296 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
3297 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
3298 Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
3300 return Builder.CreateSExt(Ops[0], Ty, "vtst");
3304 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
3305 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
3306 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
3314 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
3316 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vuzp");
3317 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
3323 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
3324 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
3325 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
3334 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
3336 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vzip");
3337 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
3352 return Builder.CreateBitCast(Result, ResultType, NameHint);
3367 Op = Builder.CreateBitCast(Op, OTy);
3369 Op = Builder.CreateFCmp(Fp, Op, Constant::getNullValue(OTy));
3371 Op = Builder.CreateICmp(Ip, Op, Constant::getNullValue(OTy));
3373 return Builder.CreateSExt(Op, Ty, Name);
3395 TblOps.push_back(CGF.Builder.CreateShuffleVector(Ops[PairPos],
3404 TblOps.push_back(CGF.Builder.CreateShuffleVector(Ops[PairPos],
3445 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_hint),
3460 CodeGen::CGBuilderTy &Builder = CGF.Builder;
3479 llvm::Value *Call = Builder.CreateCall(F, Metadata);
3483 return Builder.CreateTrunc(Call, ValueType);
3487 return Builder.CreateIntToPtr(Call, ValueType);
3496 ArgValue = Builder.CreateZExt(ArgValue, RegisterType);
3497 return Builder.CreateCall(F, { Metadata, ArgValue });
3502 ArgValue = Builder.CreatePtrToInt(ArgValue, RegisterType);
3503 return Builder.CreateCall(F, { Metadata, ArgValue });
3506 return Builder.CreateCall(F, { Metadata, ArgValue });
3567 return Builder.CreateCall(Emit);
3572 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_dbg), Option);
3584 return Builder.CreateCall(F, {Address, RW, Locality, IsData});
3588 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_rbit),
3625 Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
3628 Value *Val0 = Builder.CreateExtractValue(Val, 1);
3629 Value *Val1 = Builder.CreateExtractValue(Val, 0);
3630 Val0 = Builder.CreateZExt(Val0, Int64Ty);
3631 Val1 = Builder.CreateZExt(Val1, Int64Ty);
3634 Val = Builder.CreateShl(Val0, ShiftCst, "shl", true /* nuw */);
3635 Val = Builder.CreateOr(Val, Val1);
3636 return Builder.CreateBitCast(Val, ConvertType(E->getType()));
3647 LoadAddr = Builder.CreateBitCast(LoadAddr, IntResTy->getPointerTo());
3653 Value *Val = Builder.CreateCall(F, LoadAddr, "ldrex");
3656 return Builder.CreateIntToPtr(Val, RealResTy);
3658 Val = Builder.CreateTruncOrBitCast(Val, IntResTy);
3659 return Builder.CreateBitCast(Val, RealResTy);
3674 Builder.CreateStore(Val, Tmp);
3676 Address LdPtr = Builder.CreateBitCast(Tmp,llvm::PointerType::getUnqual(STy));
3677 Val = Builder.CreateLoad(LdPtr);
3679 Value *Arg0 = Builder.CreateExtractValue(Val, 0);
3680 Value *Arg1 = Builder.CreateExtractValue(Val, 1);
3681 Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), Int8PtrTy);
3682 return Builder.CreateCall(F, {Arg0, Arg1, StPtr}, "strexd");
3693 StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
3696 StoreVal = Builder.CreatePtrToInt(StoreVal, Int32Ty);
3698 StoreVal = Builder.CreateBitCast(StoreVal, StoreTy);
3699 StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int32Ty);
3706 return Builder.CreateCall(F, {StoreVal, StoreAddr}, "strex");
3711 return Builder.CreateCall(F);
3742 Value *Arg1a = Builder.CreateTruncOrBitCast(Arg1, Int32Ty);
3743 Value *Arg1b = Builder.CreateLShr(Arg1, C1);
3744 Arg1b = Builder.CreateTruncOrBitCast(Arg1b, Int32Ty);
3747 Value *Res = Builder.CreateCall(F, {Arg0, Arg1a});
3748 return Builder.CreateCall(F, {Res, Arg1b});
3750 Arg1 = Builder.CreateZExtOrBitCast(Arg1, Int32Ty);
3753 return Builder.CreateCall(F, {Arg0, Arg1});
3796 return Builder.getInt32(addr.getAlignment().getQuantity());
3886 return Builder.CreateExtractElement(Ops[0], Ops[1], "vget_lane");
3898 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
3919 return Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0],
3946 return Builder.CreateCall(F, Ops, "vcvtr");
3977 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
3980 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
3986 Value *Ld = Builder.CreateCall(F, {Ops[0], Align});
3990 return Builder.CreateShuffleVector(Ops[1], Ld, SV, "vld1q_lane");
3994 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
3995 PtrOp0 = Builder.CreateElementBitCast(PtrOp0, VTy->getElementType());
3996 Value *Ld = Builder.CreateLoad(PtrOp0);
3997 return Builder.CreateInsertElement(Ops[1], Ld, Ops[2], "vld1_lane");
4019 Ops[1] = Builder.CreateCall(F, {Ops[1], Align}, "vld_dup");
4021 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
4022 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
4048 Ops[1] = Builder.CreateCall(F, Args, "vld_dup");
4051 Value *Val = Builder.CreateExtractValue(Ops[1], i);
4052 Value *Elt = Builder.CreateBitCast(Val, Ty);
4054 Elt = Builder.CreateBitCast(Elt, Val->getType());
4055 Ops[1] = Builder.CreateInsertValue(Ops[1], Elt, i);
4058 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
4059 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
4085 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
4086 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
4089 Ops[1] = Builder.CreateCall(CGM.getIntrinsic(Int, Ty), {Ops[1], Ops[2]});
4090 return Builder.CreateAdd(Ops[0], Ops[1], "vrsra_n");
4101 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
4103 return Builder.CreateAdd(Ops[0], Ops[1]);
4108 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
4110 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
4113 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_neon_vst1,
4118 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
4119 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2]);
4121 auto St = Builder.CreateStore(Ops[1], Builder.CreateBitCast(PtrOp0, Ty));
4202 CodeGen::CGBuilderTy &Builder = CGF.Builder;
4233 Value *CmpRes = Builder.CreateICmp(ICmpInst::ICMP_UGE, Ops[2], EightV);
4234 CmpRes = Builder.CreateSExt(CmpRes, Ty);
4236 Value *EltsFromInput = Builder.CreateAnd(CmpRes, Ops[0]);
4237 Value *EltsFromTbl = Builder.CreateAnd(Builder.CreateNot(CmpRes), TblRes);
4238 return Builder.CreateOr(EltsFromInput, EltsFromTbl, "vtbx");
4251 Value *CmpRes = Builder.CreateICmp(ICmpInst::ICMP_UGE, Ops[4],
4253 CmpRes = Builder.CreateSExt(CmpRes, Ty);
4255 Value *EltsFromInput = Builder.CreateAnd(CmpRes, Ops[0]);
4256 Value *EltsFromTbl = Builder.CreateAnd(Builder.CreateNot(CmpRes), TblRes);
4257 return Builder.CreateOr(EltsFromInput, EltsFromTbl, "vtbx");
4300 Op = Builder.CreateBitCast(Op, Int16Ty);
4303 Op = Builder.CreateInsertElement(V, Op, CI);
4334 return Builder.CreateCall(F, llvm::ConstantInt::get(Int32Ty, HintID));
4357 return Builder.CreateCall(F, {Address, RW, Locality, IsData});
4364 return Builder.CreateCall(
4371 return Builder.CreateCall(
4395 Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
4398 Value *Val0 = Builder.CreateExtractValue(Val, 1);
4399 Value *Val1 = Builder.CreateExtractValue(Val, 0);
4401 Val0 = Builder.CreateZExt(Val0, Int128Ty);
4402 Val1 = Builder.CreateZExt(Val1, Int128Ty);
4405 Val = Builder.CreateShl(Val0, ShiftCst, "shl", true /* nuw */);
4406 Val = Builder.CreateOr(Val, Val1);
4407 return Builder.CreateBitCast(Val, ConvertType(E->getType()));
4416 LoadAddr = Builder.CreateBitCast(LoadAddr, IntResTy->getPointerTo());
4422 Value *Val = Builder.CreateCall(F, LoadAddr, "ldxr");
4425 return Builder.CreateIntToPtr(Val, RealResTy);
4427 Val = Builder.CreateTruncOrBitCast(Val, IntResTy);
4428 return Builder.CreateBitCast(Val, RealResTy);
4442 Tmp = Builder.CreateBitCast(Tmp, llvm::PointerType::getUnqual(STy));
4443 llvm::Value *Val = Builder.CreateLoad(Tmp);
4445 Value *Arg0 = Builder.CreateExtractValue(Val, 0);
4446 Value *Arg1 = Builder.CreateExtractValue(Val, 1);
4447 Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)),
4449 return Builder.CreateCall(F, {Arg0, Arg1, StPtr}, "stxp");
4460 StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
4463 StoreVal = Builder.CreatePtrToInt(StoreVal, Int64Ty);
4465 StoreVal = Builder.CreateBitCast(StoreVal, StoreTy);
4466 StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int64Ty);
4473 return Builder.CreateCall(F, {StoreVal, StoreAddr}, "stxr");
4478 return Builder.CreateCall(F);
4483 return Builder.CreateCall(F);
4513 Arg1 = Builder.CreateZExtOrBitCast(Arg1, DataTy);
4515 return Builder.CreateCall(F, {Arg0, Arg1});
4596 Value *Ptr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), Int128PTy);
4597 return Builder.CreateDefaultAlignedLoad(Ptr);
4601 Value *Ptr = Builder.CreateBitCast(Ops[0], Int128PTy);
4602 return Builder.CreateDefaultAlignedStore(EmitScalarExpr(E->getArg(1)), Ptr);
4614 Ops[0] = Builder.CreateBitCast(Ops[0], FTy);
4616 return Builder.CreateFPToUI(Ops[0], InTy);
4617 return Builder.CreateFPToSI(Ops[0], InTy);
4629 Ops[0] = Builder.CreateBitCast(Ops[0], InTy);
4631 return Builder.CreateUIToFP(Ops[0], FTy);
4632 return Builder.CreateSIToFP(Ops[0], FTy);
4638 Vec = Builder.CreateBitCast(Vec, Ty, "v2i64");
4641 Value *Op0 = Builder.CreateExtractElement(Vec, Idx0, "lane0");
4642 Value *Op1 = Builder.CreateExtractElement(Vec, Idx1, "lane1");
4644 return Builder.CreateAdd(Op0, Op1, "vpaddd");
4651 Vec = Builder.CreateBitCast(Vec, Ty, "v2f64");
4654 Value *Op0 = Builder.CreateExtractElement(Vec, Idx0, "lane0");
4655 Value *Op1 = Builder.CreateExtractElement(Vec, Idx1, "lane1");
4657 return Builder.CreateFAdd(Op0, Op1, "vpaddd");
4664 Vec = Builder.CreateBitCast(Vec, Ty, "v2f32");
4667 Value *Op0 = Builder.CreateExtractElement(Vec, Idx0, "lane0");
4668 Value *Op1 = Builder.CreateExtractElement(Vec, Idx1, "lane1");
4670 return Builder.CreateFAdd(Op0, Op1, "vpaddd");
4710 Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
4712 Builder.CreateICmpEQ(Ops[0], llvm::Constant::getNullValue(Int64Ty));
4713 return Builder.CreateSExt(Ops[0], Int64Ty, "vceqzd");
4730 Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
4731 Ops[1] = Builder.CreateBitCast(Ops[1], DoubleTy);
4732 Ops[0] = Builder.CreateFCmp(P, Ops[0], Ops[1]);
4733 return Builder.CreateSExt(Ops[0], Int64Ty, "vcmpd");
4750 Ops[0] = Builder.CreateBitCast(Ops[0], FloatTy);
4751 Ops[1] = Builder.CreateBitCast(Ops[1], FloatTy);
4752 Ops[0] = Builder.CreateFCmp(P, Ops[0], Ops[1]);
4753 return Builder.CreateSExt(Ops[0], Int32Ty, "vcmpd");
4780 Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
4781 Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
4782 Ops[0] = Builder.CreateICmp(P, Ops[0], Ops[1]);
4783 return Builder.CreateSExt(Ops[0], Int64Ty, "vceqd");
4788 Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
4789 Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
4790 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
4791 Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
4793 return Builder.CreateSExt(Ops[0], Int64Ty, "vtstd");
4806 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
4809 Ops[1] = Builder.CreateBitCast(Ops[1],
4812 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
4815 Ops[1] = Builder.CreateBitCast(Ops[1],
4818 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
4822 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int8Ty, 8));
4823 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4827 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int8Ty, 16));
4828 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4832 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int16Ty, 4));
4833 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4837 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int16Ty, 8));
4838 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4842 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 2));
4843 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4846 Ops[0] = Builder.CreateBitCast(Ops[0],
4848 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4852 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int32Ty, 4));
4853 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4857 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 1));
4858 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4861 Ops[0] = Builder.CreateBitCast(Ops[0],
4863 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4867 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::VectorType::get(Int64Ty, 2));
4868 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4871 Ops[0] = Builder.CreateBitCast(Ops[0],
4873 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4876 Ops[0] = Builder.CreateBitCast(Ops[0],
4878 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4882 Ops[0] = Builder.CreateBitCast(Ops[0],
4884 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4888 Ops[0] = Builder.CreateBitCast(Ops[0],
4890 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
4894 return Builder.CreateAdd(Ops[0], EmitScalarExpr(E->getArg(1)), "vaddd");
4897 return Builder.CreateSub(Ops[0], EmitScalarExpr(E->getArg(1)), "vsubd");
4907 Ops[1] = Builder.CreateExtractElement(Ops[1], CI, "lane0");
4916 Ops[1] = Builder.CreateZExt(Ops[1], Int64Ty);
4926 Ops[1] = Builder.CreateZExt(Ops[1], Int64Ty);
4944 Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
4945 Builder.CreateNeg(EmitScalarExpr(E->getArg(2))));
4946 Ops[1] = Builder.CreateCall(CGM.getIntrinsic(Int, Int64Ty),
4947 {Ops[1], Builder.CreateSExt(Ops[2], Int64Ty)});
4948 return Builder.CreateAdd(Ops[0], Builder.CreateBitCast(Ops[1], Int64Ty));
4953 return Builder.CreateShl(
4958 return Builder.CreateAShr(
4969 return Builder.CreateLShr(Ops[0], ConstantInt::get(Int64Ty, ShiftAmt),
4974 Ops[1] = Builder.CreateAShr(
4978 return Builder.CreateAdd(Ops[0], Ops[1]);
4987 Ops[1] = Builder.CreateLShr(Ops[1], ConstantInt::get(Int64Ty, ShiftAmt),
4989 return Builder.CreateAdd(Ops[0], Ops[1]);
4995 Ops[2] = Builder.CreateExtractElement(Ops[2], EmitScalarExpr(E->getArg(3)),
5004 Ops[1] = Builder.CreateExtractElement(Ops[1], CI, "lane0");
5031 Ops[2] = Builder.CreateExtractElement(Ops[2], EmitScalarExpr(E->getArg(3)),
5074 Ops[0] = Builder.CreateBitCast(Ops[0], BitTy, "vbsl");
5075 Ops[1] = Builder.CreateBitCast(Ops[1], BitTy, "vbsl");
5076 Ops[2] = Builder.CreateBitCast(Ops[2], BitTy, "vbsl");
5078 Ops[1] = Builder.CreateAnd(Ops[0], Ops[1], "vbsl");
5079 Ops[2] = Builder.CreateAnd(Builder.CreateNot(Ops[0]), Ops[2], "vbsl");
5080 Ops[0] = Builder.CreateOr(Ops[1], Ops[2], "vbsl");
5081 return Builder.CreateBitCast(Ops[0], Ty);
5100 Ops[1] = Builder.CreateBitCast(Ops[1], SourceTy);
5101 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV, "lane");
5111 Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
5112 Ops[1] = Builder.CreateBitCast(Ops[1], DoubleTy);
5115 Ops[2] = Builder.CreateBitCast(Ops[2], VTy);
5116 Ops[2] = Builder.CreateExtractElement(Ops[2], Ops[3], "extract");
5118 Value *Result = Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0]});
5119 return Builder.CreateBitCast(Result, Ty);
5122 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5123 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5127 Ops[2] = Builder.CreateBitCast(Ops[2], STy);
5130 Ops[2] = Builder.CreateShuffleVector(Ops[2], Ops[2], SV, "lane");
5132 return Builder.CreateCall(F, {Ops[2], Ops[1], Ops[0]});
5136 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5137 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5139 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
5141 return Builder.CreateCall(F, {Ops[2], Ops[1], Ops[0]});
5150 Ops[2] = Builder.CreateExtractElement(Ops[2], Ops[3], "extract");
5151 return Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0]});
5164 Ops[1] = Builder.CreateBitCast(Ops[1], VTy);
5165 Ops[1] = Builder.CreateFNeg(Ops[1]);
5205 llvm::Value *addend = Builder.CreateBitCast(Ops[0], tmp->getType());
5206 return Builder.CreateAdd(tmp, addend);
5310 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5312 return usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
5313 : Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
5318 Ops[0] = Builder.CreateBitCast(Ops[0], GetNeonType(this, SrcFlag));
5320 return Builder.CreateFPExt(Ops[0], Ty, "vcvt");
5326 Ops[0] = Builder.CreateBitCast(Ops[0], GetNeonType(this, SrcFlag));
5328 return Builder.CreateFPTrunc(Ops[0], Ty, "vcvt");
5338 Ops[0] = Builder.CreateBitCast(Ops[0], GetFloatNeonType(this, Type));
5340 return Builder.CreateFPToUI(Ops[0], Ty);
5341 return Builder.CreateFPToSI(Ops[0], Ty);
5402 Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
5405 Ops[1] = Builder.CreateBitCast(Ops[1], VTy);
5406 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2], "extract");
5407 Value *Result = Builder.CreateFMul(Ops[0], Ops[1]);
5408 return Builder.CreateBitCast(Result, Ty);
5411 return Builder.CreateNeg(EmitScalarExpr(E->getArg(0)), "vnegd");
5425 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5444 return Builder.CreateTrunc(Ops[0], Int8Ty);
5456 return Builder.CreateTrunc(Ops[0], Int16Ty);
5468 return Builder.CreateTrunc(Ops[0], Int8Ty);
5480 return Builder.CreateTrunc(Ops[0], Int16Ty);
5489 return Builder.CreateTrunc(Ops[0], Int8Ty);
5498 return Builder.CreateTrunc(Ops[0], Int16Ty);
5507 return Builder.CreateTrunc(Ops[0], Int8Ty);
5516 return Builder.CreateTrunc(Ops[0], Int16Ty);
5525 return Builder.CreateTrunc(Ops[0], Int8Ty);
5534 return Builder.CreateTrunc(Ops[0], Int16Ty);
5543 return Builder.CreateTrunc(Ops[0], Int8Ty);
5552 return Builder.CreateTrunc(Ops[0], Int16Ty);
5561 return Builder.CreateTrunc(Ops[0], Int8Ty);
5570 return Builder.CreateTrunc(Ops[0], Int16Ty);
5579 return Builder.CreateTrunc(Ops[0], Int8Ty);
5588 return Builder.CreateTrunc(Ops[0], Int16Ty);
5597 return Builder.CreateTrunc(Ops[0], Int8Ty);
5606 return Builder.CreateTrunc(Ops[0], Int16Ty);
5615 return Builder.CreateTrunc(Ops[0], Int8Ty);
5624 return Builder.CreateTrunc(Ops[0], Int16Ty);
5627 Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
5628 Value *RHS = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), DoubleTy);
5629 return Builder.CreateFMul(Ops[0], RHS);
5638 return Builder.CreateTrunc(Ops[0], Int16Ty);
5655 return Builder.CreateTrunc(Ops[0], Int16Ty);
5672 return Builder.CreateTrunc(Ops[0], Int16Ty);
5689 return Builder.CreateTrunc(Ops[0], Int16Ty);
5713 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5715 return Builder.CreateAdd(Ops[0], Ops[1]);
5724 Ops[0] = Builder.CreateBitCast(Ops[0], VTy);
5725 return Builder.CreateAdd(Ops[0], tmp);
5736 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
5754 Ops[1] = Builder.CreateCall(F, Ops[1], "vld1xN");
5756 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5757 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5787 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
5788 return Builder.CreateDefaultAlignedLoad(Ops[0]);
5791 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
5792 Ops[1] = Builder.CreateBitCast(Ops[1], VTy);
5793 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5796 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5798 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5799 Ops[0] = Builder.CreateDefaultAlignedLoad(Ops[0]);
5800 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vld1_lane");
5805 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5806 Ops[0] = Builder.CreateDefaultAlignedLoad(Ops[0]);
5808 Ops[0] = Builder.CreateInsertElement(V, Ops[0], CI);
5813 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5814 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2]);
5816 return Builder.CreateDefaultAlignedStore(Ops[1],
5817 Builder.CreateBitCast(Ops[0], Ty));
5821 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
5824 Ops[1] = Builder.CreateCall(F, Ops[1], "vld2");
5825 Ops[0] = Builder.CreateBitCast(Ops[0],
5827 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5832 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
5835 Ops[1] = Builder.CreateCall(F, Ops[1], "vld3");
5836 Ops[0] = Builder.CreateBitCast(Ops[0],
5838 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5843 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
5846 Ops[1] = Builder.CreateCall(F, Ops[1], "vld4");
5847 Ops[0] = Builder.CreateBitCast(Ops[0],
5849 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5855 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
5858 Ops[1] = Builder.CreateCall(F, Ops[1], "vld2");
5859 Ops[0] = Builder.CreateBitCast(Ops[0],
5861 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5867 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
5870 Ops[1] = Builder.CreateCall(F, Ops[1], "vld3");
5871 Ops[0] = Builder.CreateBitCast(Ops[0],
5873 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5879 Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
5882 Ops[1] = Builder.CreateCall(F, Ops[1], "vld4");
5883 Ops[0] = Builder.CreateBitCast(Ops[0],
5885 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5893 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5894 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
5895 Ops[3] = Builder.CreateZExt(Ops[3], Int64Ty);
5896 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld2_lane");
5898 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5899 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5907 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5908 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
5909 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
5910 Ops[4] = Builder.CreateZExt(Ops[4], Int64Ty);
5911 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane");
5913 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5914 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5922 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5923 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
5924 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
5925 Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
5926 Ops[5] = Builder.CreateZExt(Ops[5], Int64Ty);
5927 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld4_lane");
5929 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
5930 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
5944 Ops[2] = Builder.CreateZExt(Ops[2], Int64Ty);
5961 Ops[3] = Builder.CreateZExt(Ops[3], Int64Ty);
5978 Ops[4] = Builder.CreateZExt(Ops[4], Int64Ty);
5985 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
5986 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
5987 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
5996 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
5998 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vtrn");
5999 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
6005 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
6006 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
6007 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
6015 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
6017 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vuzp");
6018 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
6024 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
6025 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
6026 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
6035 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
6037 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vzip");
6038 SV = Builder.CreateDefaultAlignedStore(SV, Addr);
6108 Result = Builder.CreateInsertElement(Result, Ops[i], Builder.getInt32(i));
6131 DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), BPP, "cp"),
6133 SrcAddr = Address(Builder.CreateBitCast(SrcAddr.getPointer(), BPP, "ap"),
6136 Value *ArgPtr = Builder.CreateLoad(SrcAddr, "ap.val");
6137 return Builder.CreateStore(ArgPtr, DestAddr);
6234 Value *CpuFeatures = Builder.CreateGEP(STy, CpuModel, Idxs);
6235 Value *Features = Builder.CreateAlignedLoad(CpuFeatures,
6239 Value *Bitset = Builder.CreateAnd(
6241 return Builder.CreateICmpNE(Bitset, llvm::ConstantInt::get(Int32Ty, 0));
6249 return Builder.CreateCall(F, {Address, RW, Locality, Data});
6258 return Builder.CreateBitCast(BuildVector(Ops),
6261 return Builder.CreateExtractElement(Ops[0],
6265 Builder.CreateStore(Ops[0], Tmp);
6266 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
6267 Builder.CreateBitCast(Tmp.getPointer(), Int8PtrTy));
6271 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
6272 Builder.CreateBitCast(Tmp.getPointer(), Int8PtrTy));
6273 return Builder.CreateLoad(Tmp, "stmxcsr");
6308 Value *Mhi = Builder.CreateTrunc(
6309 Builder.CreateLShr(Ops[1], ConstantInt::get(Int64Ty, 32)), Int32Ty);
6310 Value *Mlo = Builder.CreateTrunc(Ops[1], Int32Ty);
6313 return Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
6321 Ops[1] = Builder.CreateBitCast(Ops[1], VecTy, "cast");
6326 Ops[1] = Builder.CreateExtractElement(Ops[1], Idx, "extract");
6329 Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
6330 return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
6368 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
6389 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
6393 SV = Builder.CreateShuffleVector(Zero, Ops[0], SV, "pslldq");
6395 return Builder.CreateBitCast(SV, ResultType, "cast");
6416 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
6420 SV = Builder.CreateShuffleVector(Ops[0], Zero, SV, "psrldq");
6422 return Builder.CreateBitCast(SV, ResultType, "cast");
6433 getLLVMContext(), llvm::ConstantAsMetadata::get(Builder.getInt32(1)));
6436 Value *BC = Builder.CreateBitCast(Ops[0],
6439 StoreInst *SI = Builder.CreateDefaultAlignedStore(Ops[1], BC);
6457 Ops[0] = Builder.CreateBitCast(Ops[0], MMXTy, "cast");
6459 return Builder.CreateCall(F, Ops, "pswapd");
6490 Value *Call = Builder.CreateCall(CGM.getIntrinsic(ID));
6491 Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 0),
6493 return Builder.CreateExtractValue(Call, 1);
6642 return Builder.CreateCall(F, Ops, name);
6662 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::readcyclecounter));
6675 Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
6677 Ops[0] = Builder.CreateGEP(Ops[1], Ops[0]);
6711 return Builder.CreateCall(F, Ops, "");
6723 Ops[2] = Builder.CreateBitCast(Ops[2], Int8PtrTy);
6724 Ops[1] = Builder.CreateGEP(Ops[2], Ops[1]);
6752 return Builder.CreateCall(F, Ops, "");
6761 return Builder.CreateCall(F, X);
6770 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
6772 return Builder.CreateCall(F, {X, Undef});
6782 return Builder.CreateCall(F, {X, Y});
6813 return Builder.CreateCall(F, X);
6833 return Builder.CreateCall(F, {X, Y, Z});
6836 return Builder.CreateFSub(Zero,
6837 Builder.CreateCall(F, {X, Y, Z}), "sub");
6840 return Builder.CreateCall(F,
6841 {X, Y, Builder.CreateFSub(Zero, Z, "sub")});
6845 Builder.CreateCall(F, {X, Y, Builder.CreateFSub(Zero, Z, "sub")});
6846 return Builder.CreateFSub(Zero, FsubRes, "sub");
6861 return CGF.Builder.CreateCall(F, Src0);
6873 return CGF.Builder.CreateCall(F, {Src0, Src1, Src2});
6884 return CGF.Builder.CreateCall(F, {Src0, Src1});
6904 llvm::Value *Tmp = Builder.CreateCall(Callee, {X, Y, Z});
6906 llvm::Value *Result = Builder.CreateExtractValue(Tmp, 0);
6907 llvm::Value *Flag = Builder.CreateExtractValue(Tmp, 1);
6912 llvm::Value *FlagExt = Builder.CreateZExt(Flag, RealFlagType);
6913 Builder.CreateStore(FlagExt, FlagOutPtr);
6925 llvm::Value *Src3ToBool = Builder.CreateIsNotNull(Src3);
6926 return Builder.CreateCall(F, {Src0, Src1, Src2, Src3ToBool});
6966 Value *Call = CGF.Builder.CreateCall(F, Args);
6967 Value *CC = CGF.Builder.CreateExtractValue(Call, 1);
6968 CGF.Builder.CreateStore(CC, CCPtr);
6969 return CGF.Builder.CreateExtractValue(Call, 0);
6979 return Builder.CreateCall(F, {TDB, Control});
6985 return Builder.CreateCall(F, {TDB, Control});
6991 return Builder.CreateCall(F, {TDB, Control});
6996 return Builder.CreateCall(F, Builder.CreateSExt(Data, Int64Ty, "tabort"));
7002 return Builder.CreateCall(F, {Data, Address});
7017 return Builder.CreateCall(F, X);
7026 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
7028 return Builder.CreateCall(F, {X, Undef});
7037 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
7039 return Builder.CreateCall(F, {X, Undef});
7046 return Builder.CreateCall(F, X);
7054 return Builder.CreateCall(F, {X, Y, Z});
7063 return Builder.CreateCall(F, {X, Y, Builder.CreateFSub(Zero, Z, "sub")});
7069 return Builder.CreateCall(F, X);
7076 return Builder.CreateFSub(Zero, Builder.CreateCall(F, X), "sub");
7111 return Builder.CreateCall(F, X);
7116 return Builder.CreateCall(F, {X, M4Value, M5Value});
7264 return Builder.CreateCall(FnALAF32, {Ptr, Val});
7278 return Builder.CreateCall(Callee);
7283 return Builder.CreateCall(Callee, X);
