Lines Matching refs:CGF
60 CodeGenFunction &CGF;
66 ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false)
67 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
68 VMContext(cgf.getLLVMContext()) {
81 llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); }
82 LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
83 LValue EmitCheckedLValue(const Expr *E) { return CGF.EmitCheckedLValue(E); }
86 return CGF.EmitLoadOfLValue(LV).getScalarVal();
155 S->dump(CGF.getContext().getSourceManager());
195 llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel());
204 return CGF.EmitPseudoObjectRValue(E).getScalarVal();
209 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E));
212 return CGF.getOpaqueRValueMapping(E).getScalarVal();
217 if (CodeGenFunction::ConstantEmission result = CGF.tryEmitAsConstant(E)) {
219 return EmitLoadOfLValue(result.getReferenceLValue(CGF, E));
226 return CGF.EmitObjCSelectorExpr(E);
229 return CGF.EmitObjCProtocolExpr(E);
238 return CGF.EmitObjCMessageExpr(E).getScalarVal();
242 LValue LV = CGF.EmitObjCIsaExpr(E);
243 Value *V = CGF.EmitLoadOfLValue(LV).getScalarVal();
258 return CGF.CGM.EmitNullConstant(E->getType());
262 CGF.EmitVariablyModifiedType(E->getType());
271 return CGF.EmitCallExpr(E).getScalarVal();
305 return CGF.CGM.getMemberPointerConstant(E);
337 return CGF.LoadCXXThis();
341 CGF.enterFullExpression(E);
342 CodeGenFunction::RunCleanupsScope Scope(CGF);
346 return CGF.EmitCXXNewExpr(E);
349 CGF.EmitCXXDeleteExpr(E);
374 CGF.EmitScalarExpr(E->getBase());
383 CGF.EmitCXXThrowExpr(E);
394 switch (CGF.getContext().getLangOpts().getSignedOverflowBehavior()) {
409 return CGF.getContext().getLangOpts().getSignedOverflowBehavior()
418 llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap);
499 return CGF.EmitObjCStringLiteral(E);
502 return CGF.EmitObjCBoxedExpr(E);
505 return CGF.EmitObjCArrayLiteral(E);
508 return CGF.EmitObjCDictionaryLiteral(E);
528 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT);
544 SrcType = CGF.getContext().getCanonicalType(SrcType);
545 DstType = CGF.getContext().getCanonicalType(DstType);
555 Src = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16), Src);
556 SrcType = CGF.getContext().FloatTy;
557 SrcTy = CGF.FloatTy;
581 llvm::Type *MiddleTy = CGF.IntPtrTy;
625 DstTy = CGF.FloatTy;
652 Res = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16), Res);
684 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
694 CGF.ErrorUnsupported(E, "scalar expression");
697 return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
704 Value *LHS = CGF.EmitScalarExpr(E->getExpr(0));
705 Value *RHS = CGF.EmitScalarExpr(E->getExpr(1));
712 Mask = CGF.EmitScalarExpr(E->getExpr(2));
759 Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext");
775 Value* V1 = CGF.EmitScalarExpr(E->getExpr(0));
776 Value* V2 = CGF.EmitScalarExpr(E->getExpr(1));
782 unsigned Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2);
793 if (E->EvaluateAsInt(Value, CGF.getContext(), Expr::SE_AllowSideEffects)) {
795 CGF.EmitScalarExpr(E->getBase());
803 CGDebugInfo *DI = CGF.getDebugInfo();
804 if (DI && CGF.CGM.getCodeGenOpts().LimitDebugInfo) {
829 Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast");
848 CGF.ErrorUnsupported(E, "GNU array range designator extension");
892 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
901 Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty));
903 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
941 CGF.Int32Ty));
947 Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty));
948 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
962 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
972 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1039 ConvertType(CGF.getContext().getPointerType(DestTy)));
1040 return EmitLoadOfLValue(CGF.MakeNaturalAlignAddrLValue(V, DestTy));
1060 return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl,
1071 return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl,
1078 return CGF.EmitDynamicCast(V, DCE);
1099 return CGF.Builder.CreateBitCast(V, ConvertType(CE->getType()));
1116 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
1130 return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
1134 return CGF.EmitARCRetainScalarExpr(E);
1136 return CGF.EmitObjCConsumeObject(E->getType(), Visit(E));
1139 value = CGF.EmitARCRetainAutoreleasedReturnValue(value);
1140 return CGF.EmitObjCConsumeObject(E->getType(), value);
1143 return CGF.EmitARCExtendBlockObject(E);
1146 return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->getType());
1159 assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy));
1168 llvm::Type *MiddleTy = CGF.IntPtrTy;
1180 CGF.EmitIgnoredExpr(E);
1216 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
1221 return CGF.EmitComplexExpr(E, false, true).first;
1225 CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E);
1237 CodeGenFunction::StmtExprEvaluation eval(CGF);
1238 return CGF.EmitCompoundStmt(*E->getSubStmt(), !E->getType()->isVoidType())
1250 switch (CGF.getContext().getLangOpts().getSignedOverflowBehavior()) {
1280 llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
1308 CGF.IntTy->getBitWidth())
1319 = CGF.getContext().getAsVariableArrayType(type)) {
1320 llvm::Value *numElts = CGF.getVLASize(vla).first;
1322 if (CGF.getContext().getLangOpts().isSignedOverflowDefined())
1331 value = CGF.EmitCastToVoidPtr(value);
1332 if (CGF.getContext().getLangOpts().isSignedOverflowDefined())
1341 if (CGF.getContext().getLangOpts().isSignedOverflowDefined())
1368 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16),
1381 F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero,
1389 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16),
1395 value = CGF.EmitCastToVoidPtr(value);
1397 CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType());
1400 llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity());
1402 if (CGF.getContext().getLangOpts().isSignedOverflowDefined())
1411 llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
1423 CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, &value);
1425 CGF.EmitStoreThroughLValue(RValue::get(value), LV);
1467 Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());
1481 if (E->EvaluateAsInt(Value, CGF.getContext()))
1496 llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr);
1502 CGF.getContext().getAsArrayType(CurrentType)->getElementType();
1506 CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity());
1516 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
1531 CGF.getContext().getCharWidth();
1544 CGF.ErrorUnsupported(E, "virtual base in offsetof");
1549 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
1558 CGF.getContext().getCharWidth();
1576 CGF.getContext().getAsVariableArrayType(TypeToSize)) {
1579 CGF.EmitVariablyModifiedType(TypeToSize);
1583 CGF.EmitIgnoredExpr(E->getArgumentExpr());
1588 llvm::tie(numElts, eltType) = CGF.getVLASize(VAT);
1593 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType);
1595 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts);
1603 return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
1613 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal();
1616 return CGF.EmitComplexExpr(Op, false, true).first;
1629 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal();
1632 return CGF.EmitComplexExpr(Op, true, false).second;
1638 CGF.EmitLValue(Op);
1640 CGF.EmitScalarExpr(Op, true);
1671 CGF.ErrorUnsupported(E, "complex compound assignment");
1672 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));
1693 llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
1710 llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
1725 CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, &Result);
1727 CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV);
1743 if (!CGF.getContext().getLangOpts().CPlusPlus)
1759 CGF.createBasicBlock(isDiv ? "div.cont" : "rem.cont", CGF.CurFn,
1761 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn);
1777 CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero),
1792 llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn,
1794 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow",
1795 CGF.CurFn);
1796 CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero),
1804 if (CGF.getContext().getLangOpts().OpenCL) {
1810 CGF.SetFPAccuracy(Val, 2.5);
1861 llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
1863 llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy);
1872 llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn,
1874 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn);
1880 &CGF.getContext().getLangOpts().OverflowHandler;
1892 llvm::Type *Int8Ty = CGF.Int8Ty;
1893 llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty };
1895 llvm::FunctionType::get(CGF.Int64Ty, argTypes, true);
1896 llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName);
1900 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
1901 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
1922 static Value *emitPointerArithmetic(CodeGenFunction &CGF,
1941 if (width != CGF.PointerWidthInBits) {
1945 index = CGF.Builder.CreateIntCast(index, CGF.PtrDiffTy, isSigned,
1951 index = CGF.Builder.CreateNeg(index, "idx.neg");
1960 = CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(objectType));
1962 index = CGF.Builder.CreateMul(index, objectSize);
1964 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
1965 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
1966 return CGF.Builder.CreateBitCast(result, pointer->getType());
1971 = CGF.getContext().getAsVariableArrayType(elementType)) {
1973 llvm::Value *numElements = CGF.getVLASize(vla).first;
1979 if (CGF.getLangOpts().isSignedOverflowDefined()) {
1980 index = CGF.Builder.CreateMul(index, numElements, "vla.index");
1981 pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
1983 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
1984 pointer = CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
1993 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
1994 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
1995 return CGF.Builder.CreateBitCast(result, pointer->getType());
1998 if (CGF.getLangOpts().isSignedOverflowDefined())
1999 return CGF.Builder.CreateGEP(pointer, index, "add.ptr");
2001 return CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
2007 return emitPointerArithmetic(CGF, op, /*subtraction*/ false);
2010 switch (CGF.getContext().getLangOpts().getSignedOverflowBehavior()) {
2030 switch (CGF.getContext().getLangOpts().getSignedOverflowBehavior()) {
2049 return emitPointerArithmetic(CGF, op, /*subtraction*/ true);
2055 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
2057 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
2068 = CGF.getContext().getAsVariableArrayType(elementType)) {
2070 llvm::tie(numElements, elementType) = CGF.getVLASize(vla);
2075 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType);
2077 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
2089 elementSize = CGF.getContext().getTypeSizeInChars(elementType);
2095 divisor = CGF.CGM.getSize(elementSize);
2111 if (CGF.CatchUndefined
2114 llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
2115 CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS,
2117 Cont, CGF.getTrapBB());
2118 CGF.EmitBlock(Cont);
2131 if (CGF.CatchUndefined
2134 llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
2135 CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS,
2137 Cont, CGF.getTrapBB());
2138 CGF.EmitBlock(Cont);
2188 Value *LHS = CGF.EmitScalarExpr(E->getLHS());
2189 Value *RHS = CGF.EmitScalarExpr(E->getRHS());
2190 Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison(
2191 CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE);
2256 llvm::Function *F = CGF.CGM.getIntrinsic(ID);
2258 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType());
2280 CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS());
2281 CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS());
2309 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType());
2320 llvm::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
2324 llvm::tie(LHS,RHS) = CGF.EmitARCStoreAutoreleasing(E);
2330 RHS = CGF.EmitARCStoreWeak(LHS.getAddress(), RHS, Ignore);
2346 CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS);
2348 CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS);
2356 if (!CGF.getContext().getLangOpts().CPlusPlus)
2385 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
2387 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2393 if (!CGF.ContainsLabel(E->getRHS()))
2397 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");
2398 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs");
2400 CodeGenFunction::ConditionalEvaluation eval(CGF);
2403 CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock);
2414 eval.begin(CGF);
2415 CGF.EmitBlock(RHSBlock);
2416 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2417 eval.end(CGF);
2424 if (CGF.getDebugInfo())
2427 CGF.EmitBlock(ContBlock);
2452 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
2454 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2460 if (!CGF.ContainsLabel(E->getRHS()))
2464 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end");
2465 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs");
2467 CodeGenFunction::ConditionalEvaluation eval(CGF);
2470 CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock);
2481 eval.begin(CGF);
2484 CGF.EmitBlock(RHSBlock);
2485 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2487 eval.end(CGF);
2494 CGF.EmitBlock(ContBlock);
2502 CGF.EmitIgnoredExpr(E->getLHS());
2503 CGF.EnsureInsertPoint();
2516 CodeGenFunction &CGF) {
2520 if (E->isConstantInitializer(CGF.getContext(), false))
2527 if (VD->hasLocalStorage() && !(CGF.getContext()
2541 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
2550 if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
2555 if (!CGF.ContainsLabel(dead)) {
2562 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));
2570 if (CGF.getContext().getLangOpts().OpenCL
2572 llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
2613 if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) &&
2614 isCheapEnoughToEvaluateUnconditionally(rhsExpr, CGF)) {
2615 llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr);
2626 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
2627 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
2628 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
2630 CodeGenFunction::ConditionalEvaluation eval(CGF);
2631 CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock);
2633 CGF.EmitBlock(LHSBlock);
2634 eval.begin(CGF);
2636 eval.end(CGF);
2641 CGF.EmitBlock(RHSBlock);
2642 eval.begin(CGF);
2644 eval.end(CGF);
2647 CGF.EmitBlock(ContBlock);
2663 return Visit(E->getChosenSubExpr(CGF.getContext()));
2667 llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
2668 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
2679 return CGF.EmitBlockLiteral(block);
2683 Value *Src = CGF.EmitScalarExpr(E->getSrcExpr());
2720 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
2732 return CGF.EmitAtomicExpr(E).getScalarVal();
