Lines Matching refs:Builder
60 return CGF.Builder.CreatePtrToInt(V, IntType);
71 return CGF.Builder.CreateIntToPtr(V, ResultType);
97 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
103 CGF.Builder.CreateAtomicRMW(Kind, Args[0], Args[1],
134 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
137 CGF.Builder.CreateAtomicRMW(Kind, Args[0], Args[1],
139 Result = CGF.Builder.CreateBinOp(Op, Result, Args[1]);
191 llvm::Value *Tmp = CGF.Builder.CreateCall2(Callee, X, Y);
192 Carry = CGF.Builder.CreateExtractValue(Tmp, 1);
193 return CGF.Builder.CreateExtractValue(Tmp, 0);
221 ArgValue = Builder.CreateBitCast(ArgValue, DestType,
226 return RValue::get(Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue));
234 DstPtr = Builder.CreateBitCast(DstPtr, Type);
235 SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
236 return RValue::get(Builder.CreateCall2(CGM.getIntrinsic(Intrinsic::vacopy),
244 Value *NegOp = Builder.CreateNeg(ArgValue, "neg");
246 Builder.CreateICmpSGE(ArgValue,
250 Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
266 Imag = Builder.CreateFSub(Zero, Imag, "sub");
299 Value *ZeroUndef = Builder.getInt1(Target.isCLZForZeroUndef());
300 Value *Result = Builder.CreateCall2(F, ArgValue, ZeroUndef);
302 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
316 Value *ZeroUndef = Builder.getInt1(Target.isCLZForZeroUndef());
317 Value *Result = Builder.CreateCall2(F, ArgValue, ZeroUndef);
319 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
333 Value *Tmp = Builder.CreateAdd(Builder.CreateCall2(F, ArgValue,
334 Builder.getTrue()),
337 Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
338 Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
340 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
354 Value *Tmp = Builder.CreateCall(F, ArgValue);
355 Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1));
357 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
370 Value *Result = Builder.CreateCall(F, ArgValue);
372 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
383 Value *Result = Builder.CreateCall2(FnExpect, ArgValue, ExpectedValue,
393 return RValue::get(Builder.CreateCall(F, ArgValue));
410 CI = ConstantInt::get(Builder.getInt1Ty(), (val & 0x2) >> 1);
413 return RValue::get(Builder.CreateCall2(F, EmitScalarExpr(E->getArg(0)),CI));
424 return RValue::get(Builder.CreateCall4(F, Address, RW, Locality, Data));
428 return RValue::get(Builder.CreateCall(F));
432 return RValue::get(Builder.CreateCall(F));
436 return RValue::get(Builder.CreateCall(F));
440 EmitCheck(Builder.getFalse(), "builtin_unreachable",
444 Builder.CreateUnreachable();
459 return RValue::get(Builder.CreateCall2(F, Base, Exponent));
476 LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
479 LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
482 LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
485 LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
488 LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
491 LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
495 return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType())));
499 V = Builder.CreateFCmpUNO(V, V, "cmp");
500 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
508 V = Builder.CreateFCmpOEQ(V, ConstantFP::getInfinity(V->getType()),"isinf");
509 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
518 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
522 Builder.CreateFCmpULT(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
526 Builder.CreateFCmpUGE(Abs, ConstantFP::get(V->getContext(), Smallest),
528 V = Builder.CreateAnd(Eq, IsLessThanInf, "and");
529 V = Builder.CreateAnd(V, IsNormal, "and");
530 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
536 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
540 Builder.CreateFCmpUNE(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
542 V = Builder.CreateAnd(Eq, IsNotInf, "and");
543 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
551 BasicBlock *Begin = Builder.GetInsertBlock();
553 Builder.SetInsertPoint(End);
555 Builder.CreatePHI(ConvertType(E->getArg(0)->getType()), 4,
559 Builder.SetInsertPoint(Begin);
560 Value *IsZero = Builder.CreateFCmpOEQ(V, Constant::getNullValue(Ty),
564 Builder.CreateCondBr(IsZero, End, NotZero);
568 Builder.SetInsertPoint(NotZero);
569 Value *IsNan = Builder.CreateFCmpUNO(V, V, "cmp");
572 Builder.CreateCondBr(IsNan, End, NotNan);
576 Builder.SetInsertPoint(NotNan);
579 Builder.CreateFCmpOEQ(VAbs, ConstantFP::getInfinity(V->getType()),
583 Builder.CreateCondBr(IsInf, End, NotInf);
587 Builder.SetInsertPoint(NotInf);
591 Builder.CreateFCmpUGE(VAbs, ConstantFP::get(V->getContext(), Smallest),
594 Builder.CreateSelect(IsNormal, EmitScalarExpr(E->getArg(2)),
596 Builder.CreateBr(End);
600 Builder.SetInsertPoint(End);
607 return RValue::get(Builder.CreateAlloca(Builder.getInt8Ty(), Size));
614 Builder.CreateMemSet(Dest.first, Builder.getInt8(0), SizeVal,
626 Builder.CreateMemCpy(Dest.first, Src.first, SizeVal, Align, false);
642 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
644 Builder.CreateMemCpy(Dest.first, Src.first, SizeVal, Align, false);
669 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
671 Builder.CreateMemMove(Dest.first, Src.first, SizeVal, Align, false);
683 Builder.CreateMemMove(Dest.first, Src.first, SizeVal, Align, false);
690 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
691 Builder.getInt8Ty());
693 Builder.CreateMemSet(Dest.first, ByteVal, SizeVal, Dest.second, false);
706 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
707 Builder.getInt8Ty());
708 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
709 Builder.CreateMemSet(Dest.first, ByteVal, SizeVal, Dest.second, false);
724 return RValue::get(Builder.CreateCall(F,
729 Depth = Builder.CreateIntCast(Depth, Int32Ty, false);
731 return RValue::get(Builder.CreateCall(F, Depth));
735 Depth = Builder.CreateIntCast(Depth, Int32Ty, false);
737 return RValue::get(Builder.CreateCall(F, Depth));
775 Builder.CreateCall2(F, Int, Ptr);
776 Builder.CreateUnreachable();
785 return RValue::get(Builder.CreateCall(F));
800 Value *Result = Builder.CreatePtrToInt(Ptr, IntPtrTy, "extend.cast");
808 return RValue::get(Builder.CreateSExt(Result, Int64Ty, "extend.sext"));
810 return RValue::get(Builder.CreateZExt(Result, Int64Ty, "extend.zext"));
818 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::frameaddress),
820 Builder.CreateStore(FrameAddr, Buf);
824 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::stacksave));
826 Builder.CreateGEP(Buf, ConstantInt::get(Int32Ty, 2));
827 Builder.CreateStore(StackAddr, StackSaveSlot);
831 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
832 return RValue::get(Builder.CreateCall(F, Buf));
836 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
839 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::eh_sjlj_longjmp), Buf);
842 Builder.CreateUnreachable();
957 Args[0] = Builder.CreateBitCast(DestPtr, IntPtrType);
963 Value *Result = Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2],
984 Args[0] = Builder.CreateBitCast(DestPtr, IntPtrType);
989 Value *PrevVal = Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2],
991 Value *Result = Builder.CreateICmpEQ(PrevVal, OldVal);
993 Result = Builder.CreateZExt(Result, ConvertType(E->getType()));
1021 Ptr = Builder.CreateBitCast(Ptr, ITy->getPointerTo());
1023 Builder.CreateStore(llvm::Constant::getNullValue(ITy), Ptr);
1037 Builder.CreateFence(llvm::SequentiallyConsistent);
1074 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
1075 Value *NewVal = Builder.getInt8(1);
1083 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1089 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1094 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1099 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1104 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1110 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
1127 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1128 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
1130 Builder.SetInsertPoint(ContBB);
1131 PHINode *Result = Builder.CreatePHI(Int8Ty, 5, "was_set");
1134 Builder.SetInsertPoint(BBs[i]);
1135 AtomicRMWInst *RMW = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1139 Builder.CreateBr(ContBB);
1142 SI->addCase(Builder.getInt32(0), BBs[0]);
1143 SI->addCase(Builder.getInt32(1), BBs[1]);
1144 SI->addCase(Builder.getInt32(2), BBs[1]);
1145 SI->addCase(Builder.getInt32(3), BBs[2]);
1146 SI->addCase(Builder.getInt32(4), BBs[3]);
1147 SI->addCase(Builder.getInt32(5), BBs[4]);
1149 Builder.SetInsertPoint(ContBB);
1150 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
1160 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
1161 Value *NewVal = Builder.getInt8(0);
1165 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
1193 Order = Builder.CreateIntCast(Order, Builder
1194 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
1197 Builder.SetInsertPoint(BBs[i]);
1198 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
1201 Builder.CreateBr(ContBB);
1204 SI->addCase(Builder.getInt32(0), BBs[0]);
1205 SI->addCase(Builder.getInt32(3), BBs[1]);
1206 SI->addCase(Builder.getInt32(5), BBs[2]);
1208 Builder.SetInsertPoint(ContBB);
1231 Builder.CreateFence(llvm::Acquire, Scope);
1234 Builder.CreateFence(llvm::Release, Scope);
1237 Builder.CreateFence(llvm::AcquireRelease, Scope);
1240 Builder.CreateFence(llvm::SequentiallyConsistent, Scope);
1253 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1254 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, ContBB);
1256 Builder.SetInsertPoint(AcquireBB);
1257 Builder.CreateFence(llvm::Acquire, Scope);
1258 Builder.CreateBr(ContBB);
1259 SI->addCase(Builder.getInt32(1), AcquireBB);
1260 SI->addCase(Builder.getInt32(2), AcquireBB);
1262 Builder.SetInsertPoint(ReleaseBB);
1263 Builder.CreateFence(llvm::Release, Scope);
1264 Builder.CreateBr(ContBB);
1265 SI->addCase(Builder.getInt32(3), ReleaseBB);
1267 Builder.SetInsertPoint(AcqRelBB);
1268 Builder.CreateFence(llvm::AcquireRelease, Scope);
1269 Builder.CreateBr(ContBB);
1270 SI->addCase(Builder.getInt32(4), AcqRelBB);
1272 Builder.SetInsertPoint(SeqCstBB);
1273 Builder.CreateFence(llvm::SequentiallyConsistent, Scope);
1274 Builder.CreateBr(ContBB);
1275 SI->addCase(Builder.getInt32(5), SeqCstBB);
1277 Builder.SetInsertPoint(ContBB);
1303 return RValue::get(Builder.CreateCall2(F, Base, Exponent));
1316 return RValue::get(Builder.CreateCall3(F, FirstArg,
1332 Value *BCArg = Builder.CreateBitCast(Arg, ArgIntTy);
1334 Value *Result = Builder.CreateICmpSLT(BCArg, ZeroCmp);
1335 return RValue::get(Builder.CreateZExt(Result, ConvertType(E->getType())));
1406 llvm::Value *CarryOut = Builder.CreateZExt(Builder.CreateOr(Carry1, Carry2),
1408 llvm::StoreInst *CarryOutStore = Builder.CreateStore(CarryOut,
1470 ArgValue = Builder.CreateBitCast(ArgValue, PTy);
1476 Value *V = Builder.CreateCall(F, Args);
1486 V = Builder.CreateBitCast(V, RetTy);
1543 return Builder.CreateShuffleVector(V, V, SV, "lane");
1555 Ops[j] = Builder.CreateBitCast(Ops[j], ai->getType(), name);
1557 return Builder.CreateCall(F, Ops, name);
1581 Ptr.first = Builder.CreateBitCast(Ptr.first,
1643 Value *Val = Builder.CreateCall(F, LdPtr, "ldrexd");
1645 Value *Val0 = Builder.CreateExtractValue(Val, 1);
1646 Value *Val1 = Builder.CreateExtractValue(Val, 0);
1647 Val0 = Builder.CreateZExt(Val0, Int64Ty);
1648 Val1 = Builder.CreateZExt(Val1, Int64Ty);
1651 Val = Builder.CreateShl(Val0, ShiftCst, "shl", true /* nuw */);
1652 return Builder.CreateOr(Val, Val1);
1660 Value *Tmp = Builder.CreateAlloca(Int64Ty, One);
1662 Builder.CreateStore(Val, Tmp);
1664 Value *LdPtr = Builder.CreateBitCast(Tmp,llvm::PointerType::getUnqual(STy));
1665 Val = Builder.CreateLoad(LdPtr);
1667 Value *Arg0 = Builder.CreateExtractValue(Val, 0);
1668 Value *Arg1 = Builder.CreateExtractValue(Val, 1);
1670 return Builder.CreateCall3(F, Arg0, Arg1, StPtr, "strexd");
1705 Align = Builder.getInt32(Src.second);
1731 Align = Builder.getInt32(Src.second);
1752 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
1765 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
1789 return Builder.CreateCall(F, Ops, "vcvtr");
1855 Ops.push_back(Builder.getInt1(Target.isCLZForZeroUndef()));
1878 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1880 return usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
1881 : Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
1888 Ops[0] = Builder.CreateBitCast(Ops[0], FloatTy);
1889 return usgn ? Builder.CreateFPToUI(Ops[0], Ty, "vcvt")
1890 : Builder.CreateFPToSI(Ops[0], Ty, "vcvt");
1921 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1922 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1924 return Builder.CreateShuffleVector(Ops[0], Ops[1], SV, "vext");
1944 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1947 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
1951 Value *Ld = Builder.CreateCall2(F, Ops[0], Align);
1957 return Builder.CreateShuffleVector(Ops[1], Ld, SV, "vld1q_lane");
1961 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1963 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1964 LoadInst *Ld = Builder.CreateLoad(Ops[0]);
1966 return Builder.CreateInsertElement(Ops[1], Ld, Ops[2], "vld1_lane");
1972 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1973 LoadInst *Ld = Builder.CreateLoad(Ops[0]);
1976 Ops[0] = Builder.CreateInsertElement(V, Ld, CI);
1982 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld2");
1984 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1985 return Builder.CreateStore(Ops[1], Ops[0]);
1990 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld3");
1992 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1993 return Builder.CreateStore(Ops[1], Ops[0]);
1998 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld4");
2000 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2001 return Builder.CreateStore(Ops[1], Ops[0]);
2006 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2007 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
2009 Ops[1] = Builder
2011 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2012 return Builder.CreateStore(Ops[1], Ops[0]);
2017 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2018 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
2019 Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
2021 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane");
2023 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2024 return Builder.CreateStore(Ops[1], Ops[0]);
2029 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2030 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
2031 Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
2032 Ops[5] = Builder.CreateBitCast(Ops[5], Ty);
2034 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane");
2036 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2037 return Builder.CreateStore(Ops[1], Ops[0]);
2057 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld_dup");
2059 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2060 return Builder.CreateStore(Ops[1], Ops[0]);
2085 Ops[1] = Builder.CreateCall(F, Args, "vld_dup");
2088 Value *Val = Builder.CreateExtractValue(Ops[1], i);
2089 Value *Elt = Builder.CreateBitCast(Val, Ty);
2091 Elt = Builder.CreateBitCast(Elt, Val->getType());
2092 Ops[1] = Builder.CreateInsertValue(Ops[1], Elt, i);
2095 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2096 return Builder.CreateStore(Ops[1], Ops[0]);
2108 Ops[0] = Builder.CreateBitCast(Ops[0], DTy);
2110 return Builder.CreateZExt(Ops[0], Ty, "vmovl");
2111 return Builder.CreateSExt(Ops[0], Ty, "vmovl");
2115 Ops[0] = Builder.CreateBitCast(Ops[0], QTy);
2116 return Builder.CreateTrunc(Ops[0], Ty, "vmovn");
2130 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2131 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2132 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2135 return Builder.CreateCall3(F, Ops[1], Ops[2], Ops[0]);
2276 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2277 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2280 Ops[1] = Builder.CreateCall2(CGM.getIntrinsic(Int, Ty), Ops[1], Ops[2]);
2281 return Builder.CreateAdd(Ops[0], Ops[1], "vrsra_n");
2295 return Builder.CreateShl(Builder.CreateBitCast(Ops[0],Ty), Ops[1],
2302 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2305 return Builder.CreateLShr(Ops[0], Ops[1], "vshr_n");
2307 return Builder.CreateAShr(Ops[0], Ops[1], "vshr_n");
2318 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2319 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2322 Ops[1] = Builder.CreateLShr(Ops[1], Ops[2], "vsra_n");
2324 Ops[1] = Builder.CreateAShr(Ops[1], Ops[2], "vsra_n");
2325 return Builder.CreateAdd(Ops[0], Ops[1]);
2335 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2337 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
2339 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_neon_vst1,
2344 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2345 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2]);
2347 StoreInst *St = Builder.CreateStore(Ops[1],
2348 Builder
2411 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2412 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2413 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
2414 Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
2416 return Builder.CreateSExt(Ops[0], Ty, "vtst");
2420 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
2421 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2422 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2428 Indices.push_back(Builder.getInt32(i+vi));
2429 Indices.push_back(Builder.getInt32(i+e+vi));
2431 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ops[0], vi);
2433 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vtrn");
2434 SV = Builder.CreateStore(SV, Addr);
2440 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
2441 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2442 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2450 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ops[0], vi);
2452 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vuzp");
2453 SV = Builder.CreateStore(SV, Addr);
2459 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
2460 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2461 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2470 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ops[0], vi);
2472 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vzip");
2473 SV = Builder.CreateStore(SV, Addr);
2501 Result = Builder.CreateInsertElement(Result, Ops[i], Builder.getInt32(i));
2536 return Builder.CreateBitCast(BuildVector(Ops),
2539 return Builder.CreateExtractElement(Ops[0],
2544 Value *Tmp = Builder.CreateAlloca(Int32Ty, One);
2545 Builder.CreateStore(Ops[0], Tmp);
2546 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
2547 Builder.CreateBitCast(Tmp, PtrTy));
2552 Value *Tmp = Builder.CreateAlloca(Int32Ty, One);
2553 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
2554 Builder.CreateBitCast(Tmp, PtrTy));
2555 return Builder.CreateLoad(Tmp, "stmxcsr");
2563 Ops[1] = Builder.CreateBitCast(Ops[1], VecTy, "cast");
2568 Ops[1] = Builder.CreateExtractElement(Ops[1], Idx, "extract");
2571 Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
2572 return Builder.CreateStore(Ops[1], Ops[0]);
2585 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
2594 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
2599 return Builder.CreateCall(F, makeArrayRef(&Ops[0], 2), "palignr");
2616 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
2624 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
2629 return Builder.CreateCall(F, makeArrayRef(&Ops[0], 2), "palignr");
2654 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
2662 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
2667 return Builder.CreateCall(F, makeArrayRef(&Ops[0], 2), "palignr");
2681 Builder.getInt32(1));
2684 Value *BC = Builder.CreateBitCast(Ops[0],
2687 StoreInst *SI = Builder.CreateStore(Ops[1], BC);
2706 Ops[0] = Builder.CreateBitCast(Ops[0], MMXTy, "cast");
2708 return Builder.CreateCall(F, Ops, name);
2727 Value *Call = Builder.CreateCall(CGM.getIntrinsic(ID));
2728 Builder.CreateStore(Builder.CreateExtractValue(Call, 0), Ops[0]);
2729 return Builder.CreateExtractValue(Call, 1);
2756 Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
2758 Ops[0] = Builder.CreateGEP(Ops[1], Ops[0]);
2786 return Builder.CreateCall(F, Ops, "");
2796 Ops[2] = Builder.CreateBitCast(Ops[2], Int8PtrTy);
2797 Ops[1] = Builder.CreateGEP(Ops[2], Ops[1]);
2819 return Builder.CreateCall(F, Ops, "");
