Lines Matching refs:Builder
60 return CGF.Builder.CreatePtrToInt(V, IntType);
71 return CGF.Builder.CreateIntToPtr(V, ResultType);
98 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
104 CGF.Builder.CreateAtomicRMW(Kind, Args[0], Args[1],
136 Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
139 CGF.Builder.CreateAtomicRMW(Kind, Args[0], Args[1],
141 Result = CGF.Builder.CreateBinOp(Op, Result, Args[1]);
165 return CGF.Builder.CreateCall(Fn, V, "abs");
199 ArgValue = Builder.CreateBitCast(ArgValue, DestType,
204 return RValue::get(Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue));
212 DstPtr = Builder.CreateBitCast(DstPtr, Type);
213 SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
214 return RValue::get(Builder.CreateCall2(CGM.getIntrinsic(Intrinsic::vacopy),
222 Value *NegOp = Builder.CreateNeg(ArgValue, "neg");
224 Builder.CreateICmpSGE(ArgValue,
228 Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
244 Imag = Builder.CreateFSub(Zero, Imag, "sub");
271 Value *ZeroUndef = Builder.getInt1(Target.isCLZForZeroUndef());
272 Value *Result = Builder.CreateCall2(F, ArgValue, ZeroUndef);
274 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
288 Value *ZeroUndef = Builder.getInt1(Target.isCLZForZeroUndef());
289 Value *Result = Builder.CreateCall2(F, ArgValue, ZeroUndef);
291 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
305 Value *Tmp = Builder.CreateAdd(Builder.CreateCall2(F, ArgValue,
306 Builder.getTrue()),
309 Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
310 Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
312 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
326 Value *Tmp = Builder.CreateCall(F, ArgValue);
327 Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1));
329 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
342 Value *Result = Builder.CreateCall(F, ArgValue);
344 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
355 Value *Result = Builder.CreateCall2(FnExpect, ArgValue, ExpectedValue,
364 return RValue::get(Builder.CreateCall(F, ArgValue));
381 CI = ConstantInt::get(Builder.getInt1Ty(), (val & 0x2) >> 1);
384 return RValue::get(Builder.CreateCall2(F, EmitScalarExpr(E->getArg(0)),CI));
395 return RValue::get(Builder.CreateCall4(F, Address, RW, Locality, Data));
399 return RValue::get(Builder.CreateCall(F));
403 return RValue::get(Builder.CreateCall(F));
407 EmitCheck(Builder.getFalse());
409 Builder.CreateUnreachable();
424 return RValue::get(Builder.CreateCall2(F, Base, Exponent));
441 LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
444 LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
447 LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
450 LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
453 LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
456 LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
460 return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType())));
464 V = Builder.CreateFCmpUNO(V, V, "cmp");
465 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
473 V = Builder.CreateFCmpOEQ(V, ConstantFP::getInfinity(V->getType()),"isinf");
474 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
483 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
487 Builder.CreateFCmpULT(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
491 Builder.CreateFCmpUGE(Abs, ConstantFP::get(V->getContext(), Smallest),
493 V = Builder.CreateAnd(Eq, IsLessThanInf, "and");
494 V = Builder.CreateAnd(V, IsNormal, "and");
495 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
501 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
505 Builder.CreateFCmpUNE(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
507 V = Builder.CreateAnd(Eq, IsNotInf, "and");
508 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
516 BasicBlock *Begin = Builder.GetInsertBlock();
518 Builder.SetInsertPoint(End);
520 Builder.CreatePHI(ConvertType(E->getArg(0)->getType()), 4,
524 Builder.SetInsertPoint(Begin);
525 Value *IsZero = Builder.CreateFCmpOEQ(V, Constant::getNullValue(Ty),
529 Builder.CreateCondBr(IsZero, End, NotZero);
533 Builder.SetInsertPoint(NotZero);
534 Value *IsNan = Builder.CreateFCmpUNO(V, V, "cmp");
537 Builder.CreateCondBr(IsNan, End, NotNan);
541 Builder.SetInsertPoint(NotNan);
544 Builder.CreateFCmpOEQ(VAbs, ConstantFP::getInfinity(V->getType()),
548 Builder.CreateCondBr(IsInf, End, NotInf);
552 Builder.SetInsertPoint(NotInf);
556 Builder.CreateFCmpUGE(VAbs, ConstantFP::get(V->getContext(), Smallest),
559 Builder.CreateSelect(IsNormal, EmitScalarExpr(E->getArg(2)),
561 Builder.CreateBr(End);
565 Builder.SetInsertPoint(End);
572 return RValue::get(Builder.CreateAlloca(Builder.getInt8Ty(), Size));
579 Builder.CreateMemSet(Dest.first, Builder.getInt8(0), SizeVal,
591 Builder.CreateMemCpy(Dest.first, Src.first, SizeVal, Align, false);
607 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
609 Builder.CreateMemCpy(Dest.first, Src.first, SizeVal, Align, false);
634 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
636 Builder.CreateMemMove(Dest.first, Src.first, SizeVal, Align, false);
648 Builder.CreateMemMove(Dest.first, Src.first, SizeVal, Align, false);
655 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
656 Builder.getInt8Ty());
658 Builder.CreateMemSet(Dest.first, ByteVal, SizeVal, Dest.second, false);
671 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
672 Builder.getInt8Ty());
673 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
674 Builder.CreateMemSet(Dest.first, ByteVal, SizeVal, Dest.second, false);
689 return RValue::get(Builder.CreateCall(F,
694 Depth = Builder.CreateIntCast(Depth, Int32Ty, false);
696 return RValue::get(Builder.CreateCall(F, Depth));
700 Depth = Builder.CreateIntCast(Depth, Int32Ty, false);
702 return RValue::get(Builder.CreateCall(F, Depth));
740 Builder.CreateCall2(F, Int, Ptr);
741 Builder.CreateUnreachable();
750 return RValue::get(Builder.CreateCall(F));
765 Value *Result = Builder.CreatePtrToInt(Ptr, IntPtrTy, "extend.cast");
773 return RValue::get(Builder.CreateSExt(Result, Int64Ty, "extend.sext"));
775 return RValue::get(Builder.CreateZExt(Result, Int64Ty, "extend.zext"));
783 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::frameaddress),
785 Builder.CreateStore(FrameAddr, Buf);
789 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::stacksave));
791 Builder.CreateGEP(Buf, ConstantInt::get(Int32Ty, 2));
792 Builder.CreateStore(StackAddr, StackSaveSlot);
796 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
797 return RValue::get(Builder.CreateCall(F, Buf));
801 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
804 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::eh_sjlj_longjmp), Buf);
807 Builder.CreateUnreachable();
923 Args[0] = Builder.CreateBitCast(DestPtr, IntPtrType);
929 Value *Result = Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2],
951 Args[0] = Builder.CreateBitCast(DestPtr, IntPtrType);
956 Value *PrevVal = Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2],
958 Value *Result = Builder.CreateICmpEQ(PrevVal, OldVal);
960 Result = Builder.CreateZExt(Result, ConvertType(E->getType()));
988 Ptr = Builder.CreateBitCast(Ptr, ITy->getPointerTo());
990 Builder.CreateStore(llvm::Constant::getNullValue(ITy), Ptr);
1004 Builder.CreateFence(llvm::SequentiallyConsistent);
1042 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
1043 Value *NewVal = Builder.getInt8(1);
1051 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1057 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1062 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1067 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1072 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1078 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
1095 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1096 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
1098 Builder.SetInsertPoint(ContBB);
1099 PHINode *Result = Builder.CreatePHI(Int8Ty, 5, "was_set");
1102 Builder.SetInsertPoint(BBs[i]);
1103 AtomicRMWInst *RMW = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1107 Builder.CreateBr(ContBB);
1110 SI->addCase(Builder.getInt32(0), BBs[0]);
1111 SI->addCase(Builder.getInt32(1), BBs[1]);
1112 SI->addCase(Builder.getInt32(2), BBs[1]);
1113 SI->addCase(Builder.getInt32(3), BBs[2]);
1114 SI->addCase(Builder.getInt32(4), BBs[3]);
1115 SI->addCase(Builder.getInt32(5), BBs[4]);
1117 Builder.SetInsertPoint(ContBB);
1118 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
1129 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
1130 Value *NewVal = Builder.getInt8(0);
1134 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
1162 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1163 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
1166 Builder.SetInsertPoint(BBs[i]);
1167 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
1170 Builder.CreateBr(ContBB);
1173 SI->addCase(Builder.getInt32(0), BBs[0]);
1174 SI->addCase(Builder.getInt32(3), BBs[1]);
1175 SI->addCase(Builder.getInt32(5), BBs[2]);
1177 Builder.SetInsertPoint(ContBB);
1200 Builder.CreateFence(llvm::Acquire, Scope);
1203 Builder.CreateFence(llvm::Release, Scope);
1206 Builder.CreateFence(llvm::AcquireRelease, Scope);
1209 Builder.CreateFence(llvm::SequentiallyConsistent, Scope);
1222 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1223 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, ContBB);
1225 Builder.SetInsertPoint(AcquireBB);
1226 Builder.CreateFence(llvm::Acquire, Scope);
1227 Builder.CreateBr(ContBB);
1228 SI->addCase(Builder.getInt32(1), AcquireBB);
1229 SI->addCase(Builder.getInt32(2), AcquireBB);
1231 Builder.SetInsertPoint(ReleaseBB);
1232 Builder.CreateFence(llvm::Release, Scope);
1233 Builder.CreateBr(ContBB);
1234 SI->addCase(Builder.getInt32(3), ReleaseBB);
1236 Builder.SetInsertPoint(AcqRelBB);
1237 Builder.CreateFence(llvm::AcquireRelease, Scope);
1238 Builder.CreateBr(ContBB);
1239 SI->addCase(Builder.getInt32(4), AcqRelBB);
1241 Builder.SetInsertPoint(SeqCstBB);
1242 Builder.CreateFence(llvm::SequentiallyConsistent, Scope);
1243 Builder.CreateBr(ContBB);
1244 SI->addCase(Builder.getInt32(5), SeqCstBB);
1246 Builder.SetInsertPoint(ContBB);
1272 return RValue::get(Builder.CreateCall2(F, Base, Exponent));
1285 return RValue::get(Builder.CreateCall3(F, FirstArg,
1301 Value *BCArg = Builder.CreateBitCast(Arg, ArgIntTy);
1303 Value *Result = Builder.CreateICmpSLT(BCArg, ZeroCmp);
1304 return RValue::get(Builder.CreateZExt(Result, ConvertType(E->getType())));
1372 ArgValue = Builder.CreateBitCast(ArgValue, PTy);
1378 Value *V = Builder.CreateCall(F, Args);
1388 V = Builder.CreateBitCast(V, RetTy);
1447 return Builder.CreateShuffleVector(V, V, SV, "lane");
1459 Ops[j] = Builder.CreateBitCast(Ops[j], ai->getType(), name);
1461 return Builder.CreateCall(F, Ops, name);
1485 Ptr.first = Builder.CreateBitCast(Ptr.first,
1540 return Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name), Ops);
1547 Value *Val = Builder.CreateCall(F, LdPtr, "ldrexd");
1549 Value *Val0 = Builder.CreateExtractValue(Val, 1);
1550 Value *Val1 = Builder.CreateExtractValue(Val, 0);
1551 Val0 = Builder.CreateZExt(Val0, Int64Ty);
1552 Val1 = Builder.CreateZExt(Val1, Int64Ty);
1555 Val = Builder.CreateShl(Val0, ShiftCst, "shl", true /* nuw */);
1556 return Builder.CreateOr(Val, Val1);
1564 Value *Tmp = Builder.CreateAlloca(Int64Ty, One);
1566 Builder.CreateStore(Val, Tmp);
1568 Value *LdPtr = Builder.CreateBitCast(Tmp,llvm::PointerType::getUnqual(STy));
1569 Val = Builder.CreateLoad(LdPtr);
1571 Value *Arg0 = Builder.CreateExtractValue(Val, 0);
1572 Value *Arg1 = Builder.CreateExtractValue(Val, 1);
1574 return Builder.CreateCall3(F, Arg0, Arg1, StPtr, "strexd");
1609 Align = Builder.getInt32(Src.second);
1635 Align = Builder.getInt32(Src.second);
1656 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
1669 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
1693 return Builder.CreateCall(F, Ops, "vcvtr");
1755 Ops.push_back(Builder.getInt1(Target.isCLZForZeroUndef()));
1778 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1780 return usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
1781 : Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
1788 Ops[0] = Builder.CreateBitCast(Ops[0], FloatTy);
1789 return usgn ? Builder.CreateFPToUI(Ops[0], Ty, "vcvt")
1790 : Builder.CreateFPToSI(Ops[0], Ty, "vcvt");
1821 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1822 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1824 return Builder.CreateShuffleVector(Ops[0], Ops[1], SV, "vext");
1844 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1847 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
1851 Value *Ld = Builder.CreateCall2(F, Ops[0], Align);
1857 return Builder.CreateShuffleVector(Ops[1], Ld, SV, "vld1q_lane");
1861 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1863 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1864 LoadInst *Ld = Builder.CreateLoad(Ops[0]);
1866 return Builder.CreateInsertElement(Ops[1], Ld, Ops[2], "vld1_lane");
1872 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1873 LoadInst *Ld = Builder.CreateLoad(Ops[0]);
1876 Ops[0] = Builder.CreateInsertElement(V, Ld, CI);
1882 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld2");
1884 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1885 return Builder.CreateStore(Ops[1], Ops[0]);
1890 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld3");
1892 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1893 return Builder.CreateStore(Ops[1], Ops[0]);
1898 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld4");
1900 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1901 return Builder.CreateStore(Ops[1], Ops[0]);
1906 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
1907 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
1909 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld2_lane");
1911 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1912 return Builder.CreateStore(Ops[1], Ops[0]);
1917 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
1918 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
1919 Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
1921 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane");
1923 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1924 return Builder.CreateStore(Ops[1], Ops[0]);
1929 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
1930 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
1931 Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
1932 Ops[5] = Builder.CreateBitCast(Ops[5], Ty);
1934 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane");
1936 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1937 return Builder.CreateStore(Ops[1], Ops[0]);
1957 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld_dup");
1959 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1960 return Builder.CreateStore(Ops[1], Ops[0]);
1985 Ops[1] = Builder.CreateCall(F, Args, "vld_dup");
1988 Value *Val = Builder.CreateExtractValue(Ops[1], i);
1989 Value *Elt = Builder.CreateBitCast(Val, Ty);
1991 Elt = Builder.CreateBitCast(Elt, Val->getType());
1992 Ops[1] = Builder.CreateInsertValue(Ops[1], Elt, i);
1995 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1996 return Builder.CreateStore(Ops[1], Ops[0]);
2008 Ops[0] = Builder.CreateBitCast(Ops[0], DTy);
2010 return Builder.CreateZExt(Ops[0], Ty, "vmovl");
2011 return Builder.CreateSExt(Ops[0], Ty, "vmovl");
2015 Ops[0] = Builder.CreateBitCast(Ops[0], QTy);
2016 return Builder.CreateTrunc(Ops[0], Ty, "vmovn");
2165 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2166 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2169 Ops[1] = Builder.CreateCall2(CGM.getIntrinsic(Int, Ty), Ops[1], Ops[2]);
2170 return Builder.CreateAdd(Ops[0], Ops[1], "vrsra_n");
2184 return Builder.CreateShl(Builder.CreateBitCast(Ops[0],Ty), Ops[1], "vshl_n");
2190 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2193 return Builder.CreateLShr(Ops[0], Ops[1], "vshr_n");
2195 return Builder.CreateAShr(Ops[0], Ops[1], "vshr_n");
2206 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2207 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2210 Ops[1] = Builder.CreateLShr(Ops[1], Ops[2], "vsra_n");
2212 Ops[1] = Builder.CreateAShr(Ops[1], Ops[2], "vsra_n");
2213 return Builder.CreateAdd(Ops[0], Ops[1]);
2223 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2225 Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
2227 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_neon_vst1,
2232 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2233 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2]);
2235 StoreInst *St = Builder.CreateStore(Ops[1],
2236 Builder.CreateBitCast(Ops[0], Ty));
2299 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2300 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2301 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
2302 Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
2304 return Builder.CreateSExt(Ops[0], Ty, "vtst");
2308 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
2309 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2310 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2316 Indices.push_back(Builder.getInt32(i+vi));
2317 Indices.push_back(Builder.getInt32(i+e+vi));
2319 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ops[0], vi);
2321 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vtrn");
2322 SV = Builder.CreateStore(SV, Addr);
2328 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
2329 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2330 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2338 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ops[0], vi);
2340 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vuzp");
2341 SV = Builder.CreateStore(SV, Addr);
2347 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
2348 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2349 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2358 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ops[0], vi);
2360 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vzip");
2361 SV = Builder.CreateStore(SV, Addr);
2389 Result = Builder.CreateInsertElement(Result, Ops[i], Builder.getInt32(i));
2424 return Builder.CreateBitCast(BuildVector(Ops),
2427 return Builder.CreateExtractElement(Ops[0],
2432 Value *Tmp = Builder.CreateAlloca(Int32Ty, One);
2433 Builder.CreateStore(Ops[0], Tmp);
2434 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
2435 Builder.CreateBitCast(Tmp, PtrTy));
2440 Value *Tmp = Builder.CreateAlloca(Int32Ty, One);
2441 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
2442 Builder.CreateBitCast(Tmp, PtrTy));
2443 return Builder.CreateLoad(Tmp, "stmxcsr");
2451 Ops[1] = Builder.CreateBitCast(Ops[1], VecTy, "cast");
2456 Ops[1] = Builder.CreateExtractElement(Ops[1], Idx, "extract");
2459 Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
2460 return Builder.CreateStore(Ops[1], Ops[0]);
2473 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
2482 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
2487 return Builder.CreateCall(F, makeArrayRef(&Ops[0], 2), "palignr");
2504 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
2512 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
2517 return Builder.CreateCall(F, makeArrayRef(&Ops[0], 2), "palignr");
2542 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
2550 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
2555 return Builder.CreateCall(F, makeArrayRef(&Ops[0], 2), "palignr");
2569 Builder.getInt32(1));
2572 Value *BC = Builder.CreateBitCast(Ops[0],
2575 StoreInst *SI = Builder.CreateStore(Ops[1], BC);
2594 Ops[0] = Builder.CreateBitCast(Ops[0], MMXTy, "cast");
2596 return Builder.CreateCall(F, Ops, name);
2615 Value *Call = Builder.CreateCall(CGM.getIntrinsic(ID));
2616 Builder.CreateStore(Builder.CreateExtractValue(Call, 0), Ops[0]);
2617 return Builder.CreateExtractValue(Call, 1);
2644 Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
2646 Ops[0] = Builder.CreateGEP(Ops[1], Ops[0]);
2674 return Builder.CreateCall(F, Ops, "");
2684 Ops[2] = Builder.CreateBitCast(Ops[2], Int8PtrTy);
2685 Ops[1] = Builder.CreateGEP(Ops[2], Ops[1]);
2707 return Builder.CreateCall(F, Ops, "");