|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
tools/clang/lib/CodeGen/CGExprScalar.cpp 388 return Builder.CreateFCmpUNE(V, Zero, "tobool");
395 return Builder.CreateICmpNE(V, Zero, "tobool");
403 if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) {
414 return Builder.CreateIsNotNull(V, "tobool");
456 return Builder.getInt(E->getValue());
459 return Builder.getInt(E->getValue());
483 return Builder.CreateBitCast(V, ConvertType(E->getType()));
538 return llvm::ConstantInt::get(Builder.getInt1Ty(), 1);
677 return Builder.getInt1(E->isSatisfied());
681 return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
685 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
708 return Builder.getInt1(E->getValue());
716 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
719 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
723 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
734 Value *V = Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
737 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
755 return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
758 return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
761 return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
927 Builder.CreateFCmpOGT(Src, llvm::ConstantFP::get(VMContext, MinSrc));
929 Builder.CreateFCmpOLT(Src, llvm::ConstantFP::get(VMContext, MaxSrc));
930 Check = Builder.CreateAnd(GE, LE);
1012 EmitIntegerTruncationCheckHelper(Src, SrcType, Dst, DstType, Builder);
1022 llvm::ConstantInt::get(Builder.getInt8Ty(), Check.first)};
1143 Check = EmitIntegerSignChangeCheckHelper(Src, SrcType, Dst, DstType, Builder);
1153 EmitIntegerTruncationCheckHelper(Src, SrcType, Dst, DstType, Builder);
1162 llvm::ConstantInt::get(Builder.getInt8Ty(), CheckKind)};
1188 return Builder.CreateIsNotNull(Src, "tobool");
1227 return Builder.CreateCall(
1235 Src = Builder.CreateCall(
1240 Src = Builder.CreateFPExt(Src, CGF.CGM.FloatTy, "conv");
1262 return Builder.CreateBitCast(Src, DstTy, "conv");
1270 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
1272 return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
1278 return Builder.CreatePtrToInt(Src, DstTy, "conv");
1291 return Builder.CreateVectorSplat(NumElements, Src, "splat");
1299 return Builder.CreateBitCast(Src, DstTy, "conv");
1321 return Builder.CreateIntCast(Src, DstTy, false, "conv");
1325 return Builder.CreateFPTrunc(Src, DstTy, "conv");
1328 return Builder.CreateFPExt(Src, DstTy, "conv");
1352 return Builder.CreateCall(
1355 return Builder.CreateFPTrunc(Src, DstTy);
1366 Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
1368 Res = Builder.CreateSIToFP(Src, DstTy, "conv");
1370 Res = Builder.CreateUIToFP(Src, DstTy, "conv");
1374 Res = Builder.CreateFPToSI(Src, DstTy, "conv");
1376 Res = Builder.CreateFPToUI(Src, DstTy, "conv");
1381 Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
1383 Res = Builder.CreateFPExt(Src, DstTy, "conv");
1389 Res = Builder.CreateCall(
1393 Res = Builder.CreateFPTrunc(Res, ResTy, "conv");
1433 llvm::Type *DstIntTy = Builder.getIntNTy(DstWidth);
1445 Value *IsNegative = Builder.CreateICmpSLT(Result, Zero);
1448 Value *Rounded = Builder.CreateAdd(Result, LowBits);
1449 Result = Builder.CreateSelect(IsNegative, Rounded, Result);
1453 ? Builder.CreateAShr(Result, SrcScale - DstScale, "downscale")
1454 : Builder.CreateLShr(Result, SrcScale - DstScale, "downscale");
1459 Result = Builder.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
1463 Result = Builder.CreateShl(Result, DstScale - SrcScale, "upscale");
1469 llvm::Type *UpscaledTy = Builder.getIntNTy(ResultWidth);
1470 Result = Builder.CreateIntCast(Result, UpscaledTy, SrcIsSigned, "resize");
1471 Result = Builder.CreateShl(Result, DstScale - SrcScale, "upscale");
1480 Value *TooHigh = SrcIsSigned ? Builder.CreateICmpSGT(Result, Max)
1481 : Builder.CreateICmpUGT(Result, Max);
1482 Result = Builder.CreateSelect(TooHigh, Max, Result, "satmax");
1490 Value *TooLow = Builder.CreateICmpSLT(Result, Min);
1491 Result = Builder.CreateSelect(TooLow, Min, Result, "satmin");
1496 Result = Builder.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
1514 return Builder.CreateOr(Src.first, Src.second, "tobool");
1607 Mask = Builder.CreateAnd(Mask, MaskBits, "mask");
1620 Value *Indx = Builder.CreateExtractElement(Mask, IIndx, "shuf_idx");
1622 Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt");
1623 NewV = Builder.CreateInsertElement(NewV, VExt, IIndx, "shuf_ins");
1638 indices.push_back(Builder.getInt32(Idx.getZExtValue()));
1642 return Builder.CreateShuffleVector(V1, V2, SV, "shuffle");
1684 return Builder.CreateFCmpUNE(Src, Zero, "tobool");
1686 return Builder.CreateICmpNE(Src, Zero, "tobool");
1696 Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
1698 Res = Builder.CreateSIToFP(Src, DstTy, "conv");
1700 Res = Builder.CreateUIToFP(Src, DstTy, "conv");
1704 Res = Builder.CreateFPToSI(Src, DstTy, "conv");
1706 Res = Builder.CreateFPToUI(Src, DstTy, "conv");
1711 Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
1713 Res = Builder.CreateFPExt(Src, DstTy, "conv");
1728 return Builder.getInt(Value);
1754 return Builder.CreateExtractElement(Base, Idx, "vecext");
1837 Args.push_back(Builder.getInt32(ResElts + C->getZExtValue()));
1846 V = Builder.CreateShuffleVector(LHS, RHS, Mask);
1852 V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx),
1852 V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx),
1878 Args.push_back(Builder.getInt32(j));
1896 Args.push_back(Builder.getInt32(j));
1899 Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT),
1904 Args.push_back(Builder.getInt32(j));
1906 Args.push_back(Builder.getInt32(j+Offset));
1915 V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit");
1926 Value *Idx = Builder.getInt32(CurIdx);
1928 V = Builder.CreateInsertElement(V, Init, Idx, "vecinit");
1976 Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));
1983 Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(),
2017 Src = Builder.CreateLaunderInvariantGroup(Src);
2025 Src = Builder.CreateStripInvariantGroup(Src);
2035 return Builder.CreateBitCast(Src, DstTy);
2168 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
2170 auto *IntToPtr = Builder.CreateIntToPtr(IntResult, DestLLVMTy);
2176 IntToPtr = Builder.CreateLaunderInvariantGroup(IntToPtr);
2190 PtrExpr = Builder.CreateStripInvariantGroup(PtrExpr);
2193 return Builder.CreatePtrToInt(PtrExpr, ConvertType(DestTy));
2204 return Builder.CreateVectorSplat(NumElements, Elt, "splat");
2336 return Builder.CreateAdd(InVal, Amount, Name);
2339 return Builder.CreateNSWAdd(InVal, Amount, Name);
2343 return Builder.CreateNSWAdd(InVal, Amount, Name);
2364 llvm::Value *True = CGF.EmitToMemory(Builder.getTrue(), type);
2366 Builder.CreateStore(True, LV.getAddress(), LV.isVolatileQualified())
2368 return Builder.getTrue();
2372 return Builder.CreateAtomicRMW(
2390 llvm::Value *old = Builder.CreateAtomicRMW(aop,
2392 return isPre ? Builder.CreateBinOp(op, old, amt) : old;
2397 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
2400 Builder.CreateBr(opBB);
2401 Builder.SetInsertPoint(opBB);
2402 atomicPHI = Builder.CreatePHI(value->getType(), 2);
2418 value = Builder.getTrue();
2432 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
2443 if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize");
2445 value = Builder.CreateGEP(value, numElts, "vla.inc");
2453 llvm::Value *amt = Builder.getInt32(amount);
2457 value = Builder.CreateGEP(value, amt, "incdec.funcptr");
2462 value = Builder.CreateBitCast(value, input->getType());
2466 llvm::Value *amt = Builder.getInt32(amount);
2468 value = Builder.CreateGEP(value, amt, "incdec.ptr");
2480 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
2482 value = Builder.CreateFAdd(
2496 value = Builder.CreateCall(
2501 value = Builder.CreateFPExt(input, CGF.CGM.FloatTy, "incdec.conv");
2527 value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
2531 value = Builder.CreateCall(
2536 value = Builder.CreateFPTrunc(value, input->getType(), "incdec.conv");
2551 value = Builder.CreateGEP(value, sizeValue, "incdec.objptr");
2556 value = Builder.CreateBitCast(value, input->getType());
2560 llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
2567 Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
2568 Builder.SetInsertPoint(contBB);
2591 return Builder.CreateFNeg(Op, "fneg");
2607 return Builder.CreateNot(Op, "neg");
2617 Result = Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper, Zero, "cmp");
2619 Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero, "cmp");
2620 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
2629 BoolVal = Builder.CreateNot(BoolVal, "lnot");
2632 return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
2640 return Builder.getInt(Value);
2657 Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv");
2668 Offset = Builder.CreateMul(Idx, ElemSize);
2721 Result = Builder.CreateAdd(Result, Offset);
2765 return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
2883 Builder.CreateAtomicRMW(aop, LHSLV.getPointer(), amt,
2890 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
2894 Builder.CreateBr(opBB);
2895 Builder.SetInsertPoint(opBB);
2896 atomicPHI = Builder.CreatePHI(OpInfo.LHS->getType(), 2);
2916 llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
2923 Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
2924 Builder.SetInsertPoint(contBB);
2967 Checks.push_back(std::make_pair(Builder.CreateICmpNE(Ops.RHS, Zero),
2979 Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
2982 llvm::Value *LHSCmp = Builder.CreateICmpNE(Ops.LHS, IntMin);
2983 llvm::Value *RHSCmp = Builder.CreateICmpNE(Ops.RHS, NegOne);
2984 llvm::Value *NotOverflow = Builder.CreateOr(LHSCmp, RHSCmp, "or");
3006 llvm::Value *NonZero = Builder.CreateFCmpUNE(Ops.RHS, Zero);
3013 llvm::Value *Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
3030 return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
3032 return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
3047 return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
3049 return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
3088 Value *resultAndOverflow = Builder.CreateCall(intrinsic, {Ops.LHS, Ops.RHS});
3089 Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
3090 Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
3099 llvm::Value *NotOverflow = Builder.CreateNot(overflow);
3104 CGF.EmitTrapCheck(Builder.CreateNot(overflow));
3109 llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
3114 Builder.CreateCondBr(overflow, overflowBB, continueBB);
3118 Builder.SetInsertPoint(overflowBB);
3130 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
3131 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
3138 Builder.getInt8(OpID),
3139 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())
3145 handlerResult = Builder.CreateTrunc(handlerResult, opTy);
3146 Builder.CreateBr(continueBB);
3148 Builder.SetInsertPoint(continueBB);
3149 llvm::PHINode *phi = Builder.CreatePHI(opTy, 2);
3348 return Builder.CreateAdd(op.LHS, op.RHS, "add");
3351 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
3355 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
3367 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder))
3370 Value *V = Builder.CreateFAdd(op.LHS, op.RHS, "add");
3377 return Builder.CreateAdd(op.LHS, op.RHS, "add");
3417 Result = Builder.CreateBinaryIntrinsic(IID, FullLHS, FullRHS);
3419 Result = Builder.CreateAdd(FullLHS, FullRHS);
3428 Result = Builder.CreateBinaryIntrinsic(IID, FullLHS, FullRHS);
3430 Result = Builder.CreateSub(FullLHS, FullRHS);
3435 return CommonFixedSema.isSigned() ? Builder.CreateICmpSLT(FullLHS, FullRHS)
3436 : Builder.CreateICmpULT(FullLHS, FullRHS);
3438 return CommonFixedSema.isSigned() ? Builder.CreateICmpSGT(FullLHS, FullRHS)
3439 : Builder.CreateICmpUGT(FullLHS, FullRHS);
3441 return CommonFixedSema.isSigned() ? Builder.CreateICmpSLE(FullLHS, FullRHS)
3442 : Builder.CreateICmpULE(FullLHS, FullRHS);
3444 return CommonFixedSema.isSigned() ? Builder.CreateICmpSGE(FullLHS, FullRHS)
3445 : Builder.CreateICmpUGE(FullLHS, FullRHS);
3450 return Builder.CreateICmpEQ(FullLHS, FullRHS);
3452 return Builder.CreateICmpNE(FullLHS, FullRHS);
3493 return Builder.CreateSub(op.LHS, op.RHS, "sub");
3496 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
3500 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
3512 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder, true))
3514 Value *V = Builder.CreateFSub(op.LHS, op.RHS, "sub");
3521 return Builder.CreateSub(op.LHS, op.RHS, "sub");
3533 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
3535 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
3536 Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
3578 return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div");
3595 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
3605 Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shl.mask");
3611 llvm::Value *ValidExponent = Builder.CreateICmpULE(Ops.RHS, WidthMinusOne);
3622 llvm::BasicBlock *Orig = Builder.GetInsertBlock();
3625 Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);
3630 llvm::Value *BitsShiftedOff = Builder.CreateLShr(
3631 Ops.LHS, Builder.CreateSub(PromotedWidthMinusOne, RHS, "shl.zeros",
3640 BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One);
3643 llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff, Zero);
3645 llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2);
3646 BaseCheck->addIncoming(Builder.getTrue(), Orig);
3655 return Builder.CreateShl(Ops.LHS, RHS, "shl");
3663 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
3668 Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shr.mask");
3673 Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS));
3678 return Builder.CreateLShr(Ops.LHS, RHS, "shr");
3679 return Builder.CreateAShr(Ops.LHS, RHS, "shr");
3804 Value *CR6Param = Builder.getInt32(CR6);
3806 Result = Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg});
3816 Result = Builder.CreateTrunc(Result, Builder.getInt1Ty());
3816 Result = Builder.CreateTrunc(Result, Builder.getInt1Ty());
3824 Result = Builder.CreateFCmp(FCmpOpc, LHS, RHS, "cmp");
3826 Result = Builder.CreateICmp(SICmpOpc, LHS, RHS, "cmp");
3841 LHS = Builder.CreateStripInvariantGroup(LHS);
3843 RHS = Builder.CreateStripInvariantGroup(RHS);
3846 Result = Builder.CreateICmp(UICmpOpc, LHS, RHS, "cmp");
3852 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
3881 ResultR = Builder.CreateFCmp(FCmpOpc, LHS.first, RHS.first, "cmp.r");
3882 ResultI = Builder.CreateFCmp(FCmpOpc, LHS.second, RHS.second, "cmp.i");
3886 ResultR = Builder.CreateICmp(UICmpOpc, LHS.first, RHS.first, "cmp.r");
3887 ResultI = Builder.CreateICmp(UICmpOpc, LHS.second, RHS.second, "cmp.i");
3891 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
3895 Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
3971 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
3972 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
3974 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
3975 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
3977 Value *And = Builder.CreateAnd(LHS, RHS);
3978 return Builder.CreateSExt(And, ConvertType(E->getType()), "sext");
3992 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext");
4025 RHSBlock = Builder.GetInsertBlock();
4039 PN->setDebugLoc(Builder.getCurrentDebugLocation());
4043 return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext");
4055 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
4056 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
4058 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
4059 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
4061 Value *Or = Builder.CreateOr(LHS, RHS);
4062 return Builder.CreateSExt(Or, ConvertType(E->getType()), "sext");
4076 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext");
4113 RHSBlock = Builder.GetInsertBlock();
4121 return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext");
4203 llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec);
4204 llvm::Value *tmp = Builder.CreateSExt(TestMSB,
4208 llvm::Value *tmp2 = Builder.CreateNot(tmp);
4216 RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
4217 LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
4221 llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
4222 llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
4223 llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond");
4225 tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
4236 llvm::Value *StepV = Builder.CreateZExtOrBitCast(CondV, CGF.Int64Ty);
4247 return Builder.CreateSelect(CondV, LHS, RHS, "cond");
4264 LHSBlock = Builder.GetInsertBlock();
4265 Builder.CreateBr(ContBlock);
4272 RHSBlock = Builder.GetInsertBlock();
4282 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
4310 llvm::Value *Val = Builder.CreateLoad(ArgPtr);
4315 Val = Builder.CreateIntToPtr(Val, ArgTy);
4317 Val = Builder.CreateTrunc(Val, ArgTy);
4400 Src = ConvertVec3AndVec4(Builder, CGF, Src, 4);
4403 Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
4417 Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
4421 Src = ConvertVec3AndVec4(Builder, CGF, Src, 3);
4426 return createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(),