Lines Matching refs:cgf
61 CodeGenFunction &CGF;
67 ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false)
68 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
69 VMContext(cgf.getLLVMContext()) {
82 llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); }
83 LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
85 return CGF.EmitCheckedLValue(E, TCK);
91 return CGF.EmitLoadOfLValue(LV).getScalarVal();
166 S->dump(CGF.getContext().getSourceManager());
206 llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel());
215 return CGF.EmitPseudoObjectRValue(E).getScalarVal();
220 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E));
223 return CGF.getOpaqueRValueMapping(E).getScalarVal();
228 if (CodeGenFunction::ConstantEmission result = CGF.tryEmitAsConstant(E)) {
230 return EmitLoadOfLValue(result.getReferenceLValue(CGF, E));
237 return CGF.EmitObjCSelectorExpr(E);
240 return CGF.EmitObjCProtocolExpr(E);
249 return CGF.EmitObjCMessageExpr(E).getScalarVal();
253 LValue LV = CGF.EmitObjCIsaExpr(E);
254 Value *V = CGF.EmitLoadOfLValue(LV).getScalarVal();
273 CGF.EmitVariablyModifiedType(E->getType());
282 return CGF.EmitCallExpr(E).getScalarVal();
316 return CGF.CGM.getMemberPointerConstant(E);
348 return CGF.LoadCXXThis();
352 CGF.enterFullExpression(E);
353 CodeGenFunction::RunCleanupsScope Scope(CGF);
357 return CGF.EmitCXXNewExpr(E);
360 CGF.EmitCXXDeleteExpr(E);
385 CGF.EmitScalarExpr(E->getBase());
394 CGF.EmitCXXThrowExpr(E);
405 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
409 if (!CGF.SanOpts->SignedIntegerOverflow)
417 if (Ops.Ty->isUnsignedIntegerType() && CGF.SanOpts->UnsignedIntegerOverflow)
507 return CGF.EmitObjCStringLiteral(E);
510 return CGF.EmitObjCBoxedExpr(E);
513 return CGF.EmitObjCArrayLiteral(E);
516 return CGF.EmitObjCDictionaryLiteral(E);
536 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT);
566 APFloat::getLargest(CGF.getContext().getFloatTypeSemantics(DstType));
590 CGF.getContext().getFloatTypeSemantics(OrigSrcType);
595 unsigned Width = CGF.getContext().getIntWidth(DstType);
613 CGF.getContext().getFloatTypeSemantics(DstType);
631 CGF.getContext().getFloatTypeSemantics(SrcType);
646 CGF.EmitCheckTypeDescriptor(OrigSrcType),
647 CGF.EmitCheckTypeDescriptor(DstType)
649 CGF.EmitCheck(Check, "float_cast_overflow", StaticArgs, OrigSrc,
657 SrcType = CGF.getContext().getCanonicalType(SrcType);
658 DstType = CGF.getContext().getCanonicalType(DstType);
668 if (SrcType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
669 Src = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16), Src);
670 SrcType = CGF.getContext().FloatTy;
671 SrcTy = CGF.FloatTy;
695 llvm::Type *MiddleTy = CGF.IntPtrTy;
731 if (CGF.SanOpts->FloatCastOverflow &&
737 if (DstType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType)
738 DstTy = CGF.FloatTy;
765 Res = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16), Res);
796 return CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(Ty), Ty);
811 StaticData.push_back(CGF.EmitCheckSourceLocation(Info.E->getExprLoc()));
815 StaticData.push_back(CGF.EmitCheckTypeDescriptor(UO->getType()));
823 CGF.EmitCheckTypeDescriptor(BO->getLHS()->getType()));
825 CGF.EmitCheckTypeDescriptor(BO->getRHS()->getType()));
829 StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
838 StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
844 CGF.EmitCheck(Check, CheckName, StaticData, DynamicData,
853 CGF.ErrorUnsupported(E, "scalar expression");
856 CGF.ConvertType(E->getType()));
863 Value *LHS = CGF.EmitScalarExpr(E->getExpr(0));
864 Value *RHS = CGF.EmitScalarExpr(E->getExpr(1));
871 Mask = CGF.EmitScalarExpr(E->getExpr(2));
918 Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext");
934 Value* V1 = CGF.EmitScalarExpr(E->getExpr(0));
935 Value* V2 = CGF.EmitScalarExpr(E->getExpr(1));
941 unsigned Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2);
952 if (E->EvaluateAsInt(Value, CGF.getContext(), Expr::SE_AllowSideEffects)) {
954 CGF.EmitScalarExpr(E->getBase());
962 CGDebugInfo *DI = CGF.getDebugInfo();
964 CGF.CGM.getCodeGenOpts().getDebugInfo()
991 if (CGF.SanOpts->Bounds)
992 CGF.EmitBoundsCheck(E, E->getBase(), Idx, IdxTy, /*Accessed*/true);
995 Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast");
1014 CGF.ErrorUnsupported(E, "GNU array range designator extension");
1058 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1067 Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty));
1069 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1107 CGF.Int32Ty));
1113 Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty));
1114 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1128 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1138 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1207 ConvertType(CGF.getContext().getPointerType(DestTy)));
1208 return EmitLoadOfLValue(CGF.MakeNaturalAlignAddrLValue(V, DestTy));
1232 if (CGF.SanitizePerformTypeCheck)
1233 CGF.EmitTypeCheck(CodeGenFunction::TCK_DowncastPointer, CE->getExprLoc(),
1236 return CGF.GetAddressOfDerivedClass(V, DerivedClassDecl,
1246 return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl,
1253 return CGF.EmitDynamicCast(V, DCE);
1274 return CGF
1291 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
1305 return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
1309 return CGF.EmitARCRetainScalarExpr(E);
1311 return CGF.EmitObjCConsumeObject(E->getType(), Visit(E));
1314 value = CGF.EmitARCRetainAutoreleasedReturnValue(value);
1315 return CGF.EmitObjCConsumeObject(E->getType(), value);
1318 return CGF.EmitARCExtendBlockObject(E);
1321 return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->getType());
1334 assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy));
1343 llvm::Type *MiddleTy = CGF.IntPtrTy;
1355 CGF.EmitIgnoredExpr(E);
1383 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
1388 return CGF.EmitComplexExpr(E, false, true).first;
1392 CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E);
1409 CodeGenFunction::StmtExprEvaluation eval(CGF);
1410 return CGF.EmitCompoundStmt(*E->getSubStmt(), !E->getType()->isVoidType())
1422 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
1426 if (!CGF.SanOpts->SignedIntegerOverflow)
1456 llvm::Value *True = CGF.EmitToMemory(Builder.getTrue(), type);
1474 CGF.SanOpts->UnsignedIntegerOverflow) &&
1475 CGF.getLangOpts().getSignedOverflowBehavior() !=
1481 llvm::Value *amt = CGF.EmitToMemory(
1491 llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
1492 value = CGF.EmitToMemory(value, type);
1521 CGF.IntTy->getBitWidth() &&
1525 CGF.IntTy->getBitWidth() && type->isUnsignedIntegerType() &&
1526 CGF.SanOpts->UnsignedIntegerOverflow) {
1544 = CGF.getContext().getAsVariableArrayType(type)) {
1545 llvm::Value *numElts = CGF.getVLASize(vla).first;
1547 if (CGF.getLangOpts().isSignedOverflowDefined())
1556 value = CGF.EmitCastToVoidPtr(value);
1557 if (CGF.getLangOpts().isSignedOverflowDefined())
1566 if (CGF.getLangOpts().isSignedOverflowDefined())
1590 if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
1593 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16),
1606 F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero,
1612 if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType)
1614 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16),
1620 value = CGF.EmitCastToVoidPtr(value);
1622 CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType());
1625 llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity());
1627 if (CGF.getLangOpts().isSignedOverflowDefined())
1636 llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
1638 CGF.EmitToMemory(value, type), llvm::SequentiallyConsistent);
1648 CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, &value);
1650 CGF.EmitStoreThroughLValue(RValue::get(value), LV);
1696 Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());
1710 if (E->EvaluateAsInt(Value, CGF.getContext()))
1725 llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr);
1731 CGF.getContext().getAsArrayType(CurrentType)->getElementType();
1735 CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity());
1745 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
1760 CGF.getContext().getCharWidth();
1773 CGF.ErrorUnsupported(E, "virtual base in offsetof");
1778 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
1804 CGF.getContext().getAsVariableArrayType(TypeToSize)) {
1807 CGF.EmitVariablyModifiedType(TypeToSize);
1811 CGF.EmitIgnoredExpr(E->getArgumentExpr());
1816 llvm::tie(numElts, eltType) = CGF.getVLASize(VAT);
1821 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType);
1823 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts);
1831 return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
1841 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal();
1844 return CGF.EmitComplexExpr(Op, false, true).first;
1857 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal();
1860 return CGF.EmitComplexExpr(Op, true, false).second;
1866 CGF.EmitLValue(Op);
1868 CGF.EmitScalarExpr(Op, true);
1900 CGF.ErrorUnsupported(E, "complex compound assignment");
1901 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));
1920 CGF.SanOpts->UnsignedIntegerOverflow) &&
1921 CGF.getLangOpts().getSignedOverflowBehavior() !=
1950 llvm::Value *amt = CGF.EmitToMemory(EmitScalarConversion(OpInfo.RHS,
1960 llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
1962 OpInfo.LHS = CGF.EmitToMemory(OpInfo.LHS, type);
1983 llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
1985 CGF.EmitToMemory(Result, LHSTy), llvm::SequentiallyConsistent);
1998 CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, &Result);
2000 CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV);
2016 if (!CGF.getLangOpts().CPlusPlus)
2031 if (CGF.SanOpts->IntegerDivideByZero)
2034 if (CGF.SanOpts->SignedIntegerOverflow &&
2053 if ((CGF.SanOpts->IntegerDivideByZero ||
2054 CGF.SanOpts->SignedIntegerOverflow) &&
2058 } else if (CGF.SanOpts->FloatDivideByZero &&
2066 if (CGF.getLangOpts().OpenCL) {
2072 CGF.SetFPAccuracy(Val, 2.5);
2084 if (CGF.SanOpts->IntegerDivideByZero) {
2128 llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
2130 llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy);
2138 &CGF.getLangOpts().OverflowHandler;
2142 if (!isSigned || CGF.SanOpts->SignedIntegerOverflow)
2145 CGF.EmitTrapCheck(Builder.CreateNot(overflow));
2152 llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn,
2154 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn);
2163 llvm::Type *Int8Ty = CGF.Int8Ty;
2164 llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty };
2166 llvm::FunctionType::get(CGF.Int64Ty, argTypes, true);
2167 llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName);
2171 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
2172 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
2183 CGF.EmitNounwindRuntimeCall(handler, handlerArgs);
2198 static Value *emitPointerArithmetic(CodeGenFunction &CGF,
2217 if (width != CGF.PointerWidthInBits) {
2221 index = CGF.Builder.CreateIntCast(index, CGF.PtrDiffTy, isSigned,
2227 index = CGF.Builder.CreateNeg(index, "idx.neg");
2229 if (CGF.SanOpts->Bounds)
2230 CGF.EmitBoundsCheck(op.E, pointerOperand, index, indexOperand->getType(),
2240 = CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(objectType));
2242 index = CGF.Builder.CreateMul(index, objectSize);
2244 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
2245 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
2246 return CGF.Builder.CreateBitCast(result, pointer->getType());
2251 = CGF.getContext().getAsVariableArrayType(elementType)) {
2253 llvm::Value *numElements = CGF.getVLASize(vla).first;
2259 if (CGF.getLangOpts().isSignedOverflowDefined()) {
2260 index = CGF.Builder.CreateMul(index, numElements, "vla.index");
2261 pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
2263 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
2264 pointer = CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
2273 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
2274 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
2275 return CGF.Builder.CreateBitCast(result, pointer->getType());
2278 if (CGF.getLangOpts().isSignedOverflowDefined())
2279 return CGF.Builder.CreateGEP(pointer, index, "add.ptr");
2281 return CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
2290 const CodeGenFunction &CGF, CGBuilderTy &Builder,
2310 CGF.CGM.getIntrinsic(llvm::Intrinsic::fmuladd, Addend->getType()),
2324 const CodeGenFunction &CGF, CGBuilderTy &Builder,
2337 if (CGF.CGM.getCodeGenOpts().getFPContractMode() != CodeGenOptions::FPC_On)
2345 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub);
2352 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false);
2362 return emitPointerArithmetic(CGF, op, /*subtraction*/ false);
2365 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
2369 if (!CGF.SanOpts->SignedIntegerOverflow)
2377 if (op.Ty->isUnsignedIntegerType() && CGF.SanOpts->UnsignedIntegerOverflow)
2382 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder))
2395 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
2399 if (!CGF.SanOpts->SignedIntegerOverflow)
2407 if (op.Ty->isUnsignedIntegerType() && CGF.SanOpts->UnsignedIntegerOverflow)
2412 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder, true))
2423 return emitPointerArithmetic(CGF, op, /*subtraction*/ true);
2429 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
2431 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
2442 = CGF.getContext().getAsVariableArrayType(elementType)) {
2444 llvm::tie(numElements, elementType) = CGF.getVLASize(vla);
2449 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType);
2451 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
2463 elementSize = CGF.getContext().getTypeSizeInChars(elementType);
2469 divisor = CGF.CGM.getSize(elementSize);
2494 if (CGF.SanOpts->Shift && !CGF.getLangOpts().OpenCL &&
2501 llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
2502 llvm::BasicBlock *CheckBitsShifted = CGF.createBasicBlock("check");
2507 CGF.EmitBlock(CheckBitsShifted);
2513 if (CGF.getLangOpts().CPlusPlus) {
2523 CGF.EmitBlock(Cont);
2533 if (CGF.getLangOpts().OpenCL)
2546 if (CGF.SanOpts->Shift && !CGF.getLangOpts().OpenCL &&
2551 if (CGF.getLangOpts().OpenCL)
2601 Value *LHS = CGF.EmitScalarExpr(E->getLHS());
2602 Value *RHS = CGF.EmitScalarExpr(E->getRHS());
2603 Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison(
2604 CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE);
2669 llvm::Function *F = CGF.CGM.getIntrinsic(ID);
2671 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType());
2693 CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS());
2694 CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS());
2722 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType());
2733 llvm::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
2737 llvm::tie(LHS,RHS) = CGF.EmitARCStoreAutoreleasing(E);
2743 RHS = CGF.EmitARCStoreWeak(LHS.getAddress(), RHS, Ignore);
2759 CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS);
2761 CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS);
2769 if (!CGF.getLangOpts().CPlusPlus)
2802 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
2804 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2810 if (!CGF.ContainsLabel(E->getRHS()))
2814 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");
2815 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs");
2817 CodeGenFunction::ConditionalEvaluation eval(CGF);
2820 CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock);
2831 eval.begin(CGF);
2832 CGF.EmitBlock(RHSBlock);
2833 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2834 eval.end(CGF);
2841 if (CGF.getDebugInfo())
2844 CGF.EmitBlock(ContBlock);
2873 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
2875 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2881 if (!CGF.ContainsLabel(E->getRHS()))
2885 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end");
2886 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs");
2888 CodeGenFunction::ConditionalEvaluation eval(CGF);
2891 CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock);
2902 eval.begin(CGF);
2905 CGF.EmitBlock(RHSBlock);
2906 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2908 eval.end(CGF);
2915 CGF.EmitBlock(ContBlock);
2923 CGF.EmitIgnoredExpr(E->getLHS());
2924 CGF.EnsureInsertPoint();
2937 CodeGenFunction &CGF) {
2941 if (E->isConstantInitializer(CGF.getContext(), false))
2948 if (VD->hasLocalStorage() && !(CGF.getContext()
2962 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
2971 if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
2976 if (!CGF.ContainsLabel(dead)) {
2983 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));
2991 if (CGF.getLangOpts().OpenCL
2993 llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
3034 if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) &&
3035 isCheapEnoughToEvaluateUnconditionally(rhsExpr, CGF)) {
3036 llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr);
3047 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
3048 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
3049 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
3051 CodeGenFunction::ConditionalEvaluation eval(CGF);
3052 CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock);
3054 CGF.EmitBlock(LHSBlock);
3055 eval.begin(CGF);
3057 eval.end(CGF);
3062 CGF.EmitBlock(RHSBlock);
3063 eval.begin(CGF);
3065 eval.end(CGF);
3068 CGF.EmitBlock(ContBlock);
3084 return Visit(E->getChosenSubExpr(CGF.getContext()));
3088 llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
3089 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
3100 return CGF.EmitBlockLiteral(block);
3104 Value *Src = CGF.EmitScalarExpr(E->getSrcExpr());
3141 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
3153 return CGF.EmitAtomicExpr(E).getScalarVal();
