Lines Matching full: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");
242 Value *ZeroUndef = Builder.getInt1(Target.isCLZForZeroUndef());
243 Value *Result = Builder.CreateCall2(F, ArgValue, ZeroUndef);
245 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
259 Value *ZeroUndef = Builder.getInt1(Target.isCLZForZeroUndef());
260 Value *Result = Builder.CreateCall2(F, ArgValue, ZeroUndef);
262 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
276 Value *Tmp = Builder.CreateAdd(Builder.CreateCall2(F, ArgValue,
277 Builder.getTrue()),
280 Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
281 Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
283 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
297 Value *Tmp = Builder.CreateCall(F, ArgValue);
298 Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1));
300 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
313 Value *Result = Builder.CreateCall(F, ArgValue);
315 Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
326 Value *Result = Builder.CreateCall2(FnExpect, ArgValue, ExpectedValue,
335 return RValue::get(Builder.CreateCall(F, ArgValue));
348 CI = ConstantInt::get(Builder.getInt1Ty(), (val & 0x2) >> 1);
351 return RValue::get(Builder.CreateCall2(F,
364 return RValue::get(Builder.CreateCall4(F, Address, RW, Locality, Data));
368 return RValue::get(Builder.CreateCall(F));
374 Builder.CreateUnreachable();
389 return RValue::get(Builder.CreateCall2(F, Base, Exponent));
406 LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
409 LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
412 LHS = Builder
415 LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
418 LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
421 LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
425 return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType())));
429 V = Builder.CreateFCmpUNO(V, V, "cmp");
430 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
438 V = Builder.CreateFCmpOEQ(V, ConstantFP::getInfinity(V->getType()),"isinf");
439 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
448 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
452 Builder.CreateFCmpULT(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
456 Builder.CreateFCmpUGE(Abs, ConstantFP::get(V->getContext(), Smallest),
458 V = Builder.CreateAnd(Eq, IsLessThanInf, "and");
459 V = Builder.CreateAnd(V, IsNormal, "and");
460 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
466 Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
470 Builder.CreateFCmpUNE(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
472 V = Builder.CreateAnd(Eq, IsNotInf, "and");
473 return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
481 BasicBlock *Begin = Builder.GetInsertBlock();
483 Builder.SetInsertPoint(End);
485 Builder.CreatePHI(ConvertType(E->getArg(0)->getType()), 4,
489 Builder.SetInsertPoint(Begin);
490 Value *IsZero = Builder.CreateFCmpOEQ(V, Constant::getNullValue(Ty),
494 Builder.CreateCondBr(IsZero, End, NotZero);
498 Builder.SetInsertPoint(NotZero);
499 Value *IsNan = Builder.CreateFCmpUNO(V, V, "cmp");
502 Builder.CreateCondBr(IsNan, End, NotNan);
506 Builder.SetInsertPoint(NotNan);
509 Builder.CreateFCmpOEQ(VAbs, ConstantFP::getInfinity(V->getType()),
513 Builder.CreateCondBr(IsInf, End, NotInf);
517 Builder.SetInsertPoint(NotInf);
521 Builder.CreateFCmpUGE(VAbs, ConstantFP::get(V->getContext(), Smallest),
524 Builder.CreateSelect(IsNormal, EmitScalarExpr(E->getArg(2)),
526 Builder.CreateBr(End);
530 Builder.SetInsertPoint(End);
537 return RValue::get(Builder.CreateAlloca(Builder.getInt8Ty(), Size));
544 Builder.CreateMemSet(Address, Builder.getInt8(0), SizeVal, Align, false);
554 Builder.CreateMemCpy(Address, SrcAddr, SizeVal, Align, false);
568 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
571 Builder.CreateMemCpy(Dest, Src, SizeVal, Align, false);
594 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
597 Builder.CreateMemMove(Dest, Src, SizeVal, Align, false);
608 Builder.CreateMemMove(Address, SrcAddr, SizeVal, Align, false);
614 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
615 Builder.getInt8Ty());
618 Builder.CreateMemSet(Address, ByteVal, SizeVal, Align, false);
630 Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
631 Builder.getInt8Ty());
632 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
634 Builder.CreateMemSet(Address, ByteVal, SizeVal, Align, false);
650 return RValue::get(Builder.CreateCall(F,
655 Depth = Builder.CreateIntCast(Depth, Int32Ty, false);
657 return RValue::get(Builder.CreateCall(F, Depth));
661 Depth = Builder.CreateIntCast(Depth, Int32Ty, false);
663 return RValue::get(Builder.CreateCall(F, Depth));
701 Builder.CreateCall2(F, Int, Ptr);
702 Builder.CreateUnreachable();
711 return RValue::get(Builder.CreateCall(F));
726 Value *Result = Builder.CreatePtrToInt(Ptr, IntPtrTy, "extend.cast");
734 return RValue::get(Builder.CreateSExt(Result, Int64Ty, "extend.sext"));
736 return RValue::get(Builder.CreateZExt(Result, Int64Ty, "extend.zext"));
744 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::frameaddress),
746 Builder.CreateStore(FrameAddr, Buf);
750 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::stacksave));
752 Builder.CreateGEP(Buf, ConstantInt::get(Int32Ty, 2));
753 Builder.CreateStore(StackAddr, StackSaveSlot);
757 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
758 return RValue::get(Builder.CreateCall(F, Buf));
762 Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
765 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::eh_sjlj_longjmp), Buf);
768 Builder.CreateUnreachable();
884 Args[0] = Builder.CreateBitCast(DestPtr, IntPtrType);
890 Value *Result = Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2],
912 Args[0] = Builder.CreateBitCast(DestPtr, IntPtrType);
917 Value *PrevVal = Builder.CreateAtomicCmpXchg(Args[0], Args[1], Args[2],
919 Value *Result = Builder.CreateICmpEQ(PrevVal, OldVal);
921 Result = Builder.CreateZExt(Result, ConvertType(E->getType()));
949 Ptr = Builder.CreateBitCast(Ptr, ITy->getPointerTo());
951 Builder.CreateStore(llvm::Constant::getNullValue(ITy), Ptr);
965 Builder.CreateFence(llvm::SequentiallyConsistent);
1003 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
1004 Value *NewVal = Builder.getInt8(1);
1012 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1018 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1023 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1028 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1033 Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1039 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
1056 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1057 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
1059 Builder.SetInsertPoint(ContBB);
1060 PHINode *Result = Builder.CreatePHI(Int8Ty, 5, "was_set");
1063 Builder.SetInsertPoint(BBs[i]);
1064 AtomicRMWInst *RMW = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1068 Builder.CreateBr(ContBB);
1071 SI->addCase(Builder.getInt32(0), BBs[0]);
1072 SI->addCase(Builder.getInt32(1), BBs[1]);
1073 SI->addCase(Builder.getInt32(2), BBs[1]);
1074 SI->addCase(Builder.getInt32(3), BBs[2]);
1075 SI->addCase(Builder.getInt32(4), BBs[3]);
1076 SI->addCase(Builder.getInt32(5), BBs[4]);
1078 Builder.SetInsertPoint(ContBB);
1079 return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
1090 Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
1091 Value *NewVal = Builder.getInt8(0);
1095 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
1123 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1124 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
1127 Builder.SetInsertPoint(BBs[i]);
1128 StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
1131 Builder.CreateBr(ContBB);
1134 SI->addCase(Builder.getInt32(0), BBs[0]);
1135 SI->addCase(Builder.getInt32(3), BBs[1]);
1136 SI->addCase(Builder.getInt32(5), BBs[2]);
1138 Builder.SetInsertPoint(ContBB);
1161 Builder.CreateFence(llvm::Acquire, Scope);
1164 Builder.CreateFence(llvm::Release, Scope);
1167 Builder.CreateFence(llvm::AcquireRelease, Scope);
1170 Builder.CreateFence(llvm::SequentiallyConsistent, Scope);
1183 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
1184 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, ContBB);
1186 Builder.SetInsertPoint(AcquireBB);
1187 Builder.CreateFence(llvm::Acquire, Scope);
1188 Builder.CreateBr(ContBB);
1189 SI->addCase(Builder.getInt32(1), AcquireBB);
1190 SI->addCase(Builder.getInt32(2), AcquireBB);
1192 Builder.SetInsertPoint(ReleaseBB);
1193 Builder.CreateFence(llvm::Release, Scope);
1194 Builder.CreateBr(ContBB);
1195 SI->addCase(Builder.getInt32(3), ReleaseBB);
1197 Builder.SetInsertPoint(AcqRelBB);
1198 Builder.CreateFence(llvm::AcquireRelease, Scope);
1199 Builder.CreateBr(ContBB);
1200 SI->addCase(Builder.getInt32(4), AcqRelBB);
1202 Builder.SetInsertPoint(SeqCstBB);
1203 Builder
1204 Builder.CreateBr(ContBB);
1205 SI->addCase(Builder.getInt32(5), SeqCstBB);
1207 Builder.SetInsertPoint(ContBB);
1233 return RValue::get(Builder.CreateCall2(F, Base, Exponent));
1246 return RValue::get(Builder.CreateCall3(F, FirstArg,
1262 Value *BCArg = Builder.CreateBitCast(Arg, ArgIntTy);
1264 Value *Result = Builder.CreateICmpSLT(BCArg, ZeroCmp);
1265 return RValue::get(Builder.CreateZExt(Result, ConvertType(E->getType())));
1333 ArgValue = Builder.CreateBitCast(ArgValue, PTy);
1339 Value *V = Builder.CreateCall(F, Args);
1349 V = Builder.CreateBitCast(V, RetTy);
1410 return Builder.CreateShuffleVector(V, V, SV, "lane");
1422 Ops[j] = Builder.CreateBitCast(Ops[j], ai->getType(), name);
1424 return Builder.CreateCall(F, Ops, name);
1481 return Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name), Ops);
1488 Value *Val = Builder.CreateCall(F, LdPtr, "ldrexd");
1490 Value *Val0 = Builder.CreateExtractValue(Val, 1);
1491 Value *Val1 = Builder.CreateExtractValue(Val, 0);
1492 Val0 = Builder.CreateZExt(Val0, Int64Ty);
1493 Val1 = Builder.CreateZExt(Val1, Int64Ty);
1496 Val = Builder.CreateShl(Val0, ShiftCst, "shl", true /* nuw */);
1497 return Builder.CreateOr(Val, Val1);
1505 Value *Tmp = Builder.CreateAlloca(Int64Ty, One);
1507 Builder.CreateStore(Val, Tmp);
1509 Value *LdPtr = Builder.CreateBitCast(Tmp,llvm::PointerType::getUnqual(STy));
1510 Val = Builder.CreateLoad(LdPtr);
1512 Value *Arg0 = Builder.CreateExtractValue(Val, 0);
1513 Value *Arg1 = Builder.CreateExtractValue(Val, 1);
1515 return Builder.CreateCall3(F, Arg0, Arg1, StPtr, "strexd");
1536 return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
1549 return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
1573 return Builder.CreateCall(F, Ops, "vcvtr");
1654 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1656 return usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
1657 : Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
1664 Ops[0] = Builder.CreateBitCast(Ops[0], FloatTy);
1665 return usgn ? Builder.CreateFPToUI(Ops[0], Ty, "vcvt")
1666 : Builder.CreateFPToSI(Ops[0], Ty, "vcvt");
1697 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1698 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1700 return Builder.CreateShuffleVector(Ops[0], Ops[1], SV, "vext");
1717 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
1719 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1720 LoadInst *Ld = Builder.CreateLoad(Ops[0]);
1723 return Builder.CreateInsertElement(Ops[1], Ld, Ops[2], "vld1_lane");
1729 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1730 LoadInst *Ld = Builder.CreateLoad(Ops[0]);
1734 Ops[0] = Builder.CreateInsertElement(V, Ld, CI);
1741 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld2");
1743 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1744 return Builder.CreateStore(Ops[1], Ops[0]);
1750 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld3");
1752 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1753 return Builder.CreateStore(Ops[1], Ops[0]);
1759 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld4");
1761 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1762 return Builder.CreateStore(Ops[1], Ops[0]);
1767 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
1768 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
1770 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld2_lane");
1772 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1773 return Builder.CreateStore(Ops[1], Ops[0]);
1778 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
1779 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
1780 Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
1782 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane");
1784 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1785 return Builder.CreateStore(Ops[1], Ops[0]);
1790 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
1791 Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
1792 Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
1793 Ops[5] = Builder.CreateBitCast(Ops[5], Ty);
1795 Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane");
1797 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1798 return Builder.CreateStore(Ops[1], Ops[0]);
1819 Ops[1] = Builder.CreateCall2(F, Ops[1], Align, "vld_dup");
1821 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1822 return Builder.CreateStore(Ops[1], Ops[0]);
1847 Ops[1] = Builder.CreateCall(F, Args, "vld_dup");
1850 Value *Val = Builder.CreateExtractValue(Ops[1], i);
1851 Value *Elt = Builder.CreateBitCast(Val, Ty);
1853 Elt = Builder.CreateBitCast(Elt, Val->getType());
1854 Ops[1] = Builder.CreateInsertValue(Ops[1], Elt, i);
1857 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
1858 return Builder.CreateStore(Ops[1], Ops[0]);
1870 Ops[0] = Builder.CreateBitCast(Ops[0], DTy);
1872 return Builder.CreateZExt(Ops[0], Ty, "vmovl");
1873 return Builder.CreateSExt(Ops[0], Ty, "vmovl");
1877 Ops[0] = Builder.CreateBitCast(Ops[0], QTy);
1878 return Builder.CreateTrunc(Ops[0], Ty, "vmovn");
2027 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2028 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2031 Ops[1] = Builder.CreateCall2(CGM.getIntrinsic(Int, Ty), Ops[1], Ops[2]);
2032 return Builder.CreateAdd(Ops[0], Ops[1], "vrsra_n");
2046 return Builder.CreateShl(Builder.CreateBitCast(Ops[0],Ty), Ops[1], "vshl_n");
2052 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2055 return Builder.CreateLShr(Ops[0], Ops[1], "vshr_n");
2057 return Builder.CreateAShr(Ops[0], Ops[1], "vshr_n");
2068 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2069 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2072 Ops[1] = Builder.CreateLShr(Ops[1], Ops[2], "vsra_n");
2074 Ops[1] = Builder.CreateAShr(Ops[1], Ops[2], "vsra_n");
2075 return Builder.CreateAdd(Ops[0], Ops[1]);
2083 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2084 Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2]);
2086 StoreInst *St = Builder.CreateStore(Ops[1],
2087 Builder.CreateBitCast(Ops[0], Ty));
2151 Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
2152 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2153 Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
2154 Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
2156 return Builder.CreateSExt(Ops[0], Ty, "vtst");
2160 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
2161 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2162 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2168 Indices.push_back(Builder.getInt32(i+vi));
2169 Indices.push_back(Builder.getInt32(i+e+vi));
2171 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ops[0], vi);
2173 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vtrn");
2174 SV = Builder.CreateStore(SV, Addr);
2180 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
2181 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2182 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2190 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ops[0], vi);
2192 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vuzp");
2193 SV = Builder.CreateStore(SV, Addr);
2199 Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
2200 Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
2201 Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
2210 Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ops[0], vi);
2212 SV = Builder.CreateShuffleVector(Ops[1], Ops[2], SV, "vzip");
2213 SV = Builder.CreateStore(SV, Addr);
2241 Result = Builder.CreateInsertElement(Result, Ops[i], Builder.getInt32(i));
2276 return Builder.CreateBitCast(BuildVector(Ops),
2279 return Builder.CreateExtractElement(Ops[0],
2284 Value *Tmp = Builder.CreateAlloca(Int32Ty, One);
2285 Builder.CreateStore(Ops[0], Tmp);
2286 return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
2287 Builder.CreateBitCast(Tmp, PtrTy));
2292 Value *Tmp = Builder.CreateAlloca(Int32Ty, One);
2293 Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
2294 Builder.CreateBitCast(Tmp, PtrTy));
2295 return Builder.CreateLoad(Tmp, "stmxcsr");
2303 Ops[1] = Builder.CreateBitCast(Ops[1], VecTy, "cast");
2308 Ops[1] = Builder.CreateExtractElement(Ops[1], Idx, "extract");
2311 Ops[0] = Builder.CreateBitCast(Ops[0], PtrTy);
2312 return Builder.CreateStore(Ops[1], Ops[0]);
2325 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
2334 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
2339 return Builder.CreateCall(F, makeArrayRef(&Ops[0], 2), "palignr");
2356 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
2364 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
2369 return Builder.CreateCall(F, makeArrayRef(&Ops[0], 2), "palignr");
2394 return Builder.CreateShuffleVector(Ops[1], Ops[0], SV, "palignr");
2402 Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
2407 return Builder.CreateCall(F, makeArrayRef(&Ops[0], 2), "palignr");
2418 Builder.getInt32(1));
2421 Value *BC = Builder.CreateBitCast(Ops[0],
2424 StoreInst *SI = Builder.CreateStore(Ops[1], BC);
2443 Ops[0] = Builder.CreateBitCast(Ops[0], MMXTy, "cast");
2445 return Builder.CreateCall(F, Ops, name);
4434 return Builder.CreateCall(F, Ops, "");
4458 Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
4460 Ops[0] = Builder.CreateGEP(Ops[1], Ops[0]);
4488 return Builder.CreateCall(F, Ops, "");
4498 Ops[2] = Builder.CreateBitCast(Ops[2], Int8PtrTy);
4499 Ops[1] = Builder.CreateGEP(Ops[2], Ops[1]);
4521 return Builder.CreateCall(F, Ops, "");
