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());
192 llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel());
202 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E));
205 return CGF.getOpaqueRValueMapping(E).getScalarVal();
211 if (!E->Evaluate(Result, CGF.getContext()))
226 if (!CGF.getContext().DeclMustBeEmitted(VD))
227 CGF.EmitDeclRefExprDbgValue(E, C);
229 CGF.EmitDeclRefExprDbgValue(E, C);
235 return CGF.EmitObjCSelectorExpr(E);
238 return CGF.EmitObjCProtocolExpr(E);
252 return CGF.EmitObjCMessageExpr(E).getScalarVal();
256 LValue LV = CGF.EmitObjCIsaExpr(E);
257 Value *V = CGF.EmitLoadOfLValue(LV).getScalarVal();
272 return CGF.CGM.EmitNullConstant(E->getType());
276 CGF.EmitVariablyModifiedType(E->getType());
285 return CGF.EmitCallExpr(E).getScalarVal();
321 return CGF.CGM.getMemberPointerConstant(E);
353 return CGF.LoadCXXThis();
357 return CGF.EmitExprWithCleanups(E).getScalarVal();
360 return CGF.EmitCXXNewExpr(E);
363 CGF.EmitCXXDeleteExpr(E);
388 CGF.EmitScalarExpr(E->getBase());
397 CGF.EmitCXXThrowExpr(E);
408 switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) {
423 return CGF.getContext().getLangOptions().getSignedOverflowBehavior()
432 llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap);
513 return CGF.EmitObjCStringLiteral(E);
533 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT);
549 SrcType = CGF.getContext().getCanonicalType(SrcType);
550 DstType = CGF.getContext().getCanonicalType(DstType);
560 Src = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16), Src);
561 SrcType = CGF.getContext().FloatTy;
586 llvm::Type *MiddleTy = CGF.IntPtrTy;
660 Res = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16), Res);
692 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
702 CGF.ErrorUnsupported(E, "scalar expression");
705 return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
712 Value *LHS = CGF.EmitScalarExpr(E->getExpr(0));
713 Value *RHS = CGF.EmitScalarExpr(E->getExpr(1));
720 Mask = CGF.EmitScalarExpr(E->getExpr(2));
770 Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext");
786 Value* V1 = CGF.EmitScalarExpr(E->getExpr(0));
787 Value* V2 = CGF.EmitScalarExpr(E->getExpr(1));
793 unsigned Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2);
804 if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) {
806 CGF.EmitScalarExpr(E->getBase());
814 CGDebugInfo *DI = CGF.getDebugInfo();
815 if (DI && CGF.CGM.getCodeGenOpts().LimitDebugInfo) {
840 Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast");
859 CGF.ErrorUnsupported(E, "GNU array range designator extension");
904 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
913 Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty));
916 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
954 CGF.Int32Ty));
960 Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty));
962 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
977 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
988 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
1055 ConvertType(CGF.getContext().getPointerType(DestTy)));
1056 return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy));
1074 return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl,
1085 return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl,
1092 return CGF.EmitDynamicCast(V, DCE);
1113 return CGF.Builder.CreateBitCast(V, ConvertType(CE->getType()));
1130 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
1143 return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
1147 return CGF.EmitARCRetainScalarExpr(E);
1149 return CGF.EmitObjCConsumeObject(E->getType(), Visit(E));
1152 value = CGF.EmitARCRetainAutoreleasedReturnValue(value);
1153 return CGF.EmitObjCConsumeObject(E->getType(), value);
1156 return CGF.EmitARCExtendBlockObject(E);
1170 assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy));
1173 RValue RV = CGF.EmitLoadOfLValue(CGF.EmitLValue(E));
1178 assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy));
1187 llvm::Type *MiddleTy = CGF.IntPtrTy;
1199 CGF.EmitIgnoredExpr(E);
1237 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
1242 return CGF.EmitComplexExpr(E, false, true).first;
1246 CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E);
1259 CodeGenFunction::StmtExprEvaluation eval(CGF);
1260 return CGF.EmitCompoundStmt(*E->getSubStmt(), !E->getType()->isVoidType())
1265 LValue LV = CGF.EmitBlockDeclRefLValue(E);
1266 return CGF.EmitLoadOfLValue(LV).getScalarVal();
1277 switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) {
1325 CGF.IntTy->getBitWidth())
1336 = CGF.getContext().getAsVariableArrayType(type)) {
1337 llvm::Value *numElts = CGF.getVLASize(vla).first;
1339 if (CGF.getContext().getLangOptions().isSignedOverflowDefined())
1348 value = CGF.EmitCastToVoidPtr(value);
1349 if (CGF.getContext().getLangOptions().isSignedOverflowDefined())
1358 if (CGF.getContext().getLangOptions().isSignedOverflowDefined())
1385 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16),
1398 F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero,
1406 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16),
1412 value = CGF.EmitCastToVoidPtr(value);
1414 CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType());
1417 llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity());
1419 if (CGF.getContext().getLangOptions().isSignedOverflowDefined())
1428 CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, &value);
1430 CGF.EmitStoreThroughLValue(RValue::get(value), LV);
1463 Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());
1477 if (E->Evaluate(EvalResult, CGF.getContext()))
1492 llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr);
1498 CGF.getContext().getAsArrayType(CurrentType)->getElementType();
1502 CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity());
1512 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
1527 CGF.getContext().getCharWidth();
1540 CGF.ErrorUnsupported(E, "virtual base in offsetof");
1545 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
1554 CGF.getContext().getCharWidth();
1572 CGF.getContext().getAsVariableArrayType(TypeToSize)) {
1575 CGF.EmitVariablyModifiedType(TypeToSize);
1579 CGF.EmitIgnoredExpr(E->getArgumentExpr());
1584 llvm::tie(numElts, eltType) = CGF.getVLASize(VAT);
1589 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType);
1591 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts);
1600 E->Evaluate(Result, CGF.getContext());
1611 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal();
1614 return CGF.EmitComplexExpr(Op, false, true).first;
1627 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal();
1630 return CGF.EmitComplexExpr(Op, true, false).second;
1635 CGF.EmitScalarExpr(Op, true);
1666 CGF.ErrorUnsupported(E, "complex compound assignment");
1667 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));
1694 CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, &Result);
1696 CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV);
1712 if (!CGF.getContext().getLangOptions().CPlusPlus)
1732 CGF.createBasicBlock(isDiv ? "div.cont" : "rem.cont", CGF.CurFn,
1734 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn);
1750 CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero),
1765 llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn,
1767 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow",
1768 CGF.CurFn);
1769 CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero),
1825 llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
1827 llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy);
1836 llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn,
1838 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn);
1844 &CGF.getContext().getLangOptions().OverflowHandler;
1857 llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty };
1859 llvm::FunctionType::get(CGF.Int64Ty, argTypes, true);
1860 llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName);
1864 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
1865 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
1886 static Value *emitPointerArithmetic(CodeGenFunction &CGF,
1905 if (width != CGF.PointerWidthInBits) {
1909 index = CGF.Builder.CreateIntCast(index, CGF.PtrDiffTy, isSigned,
1915 index = CGF.Builder.CreateNeg(index, "idx.neg");
1924 = CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(objectType));
1926 index = CGF.Builder.CreateMul(index, objectSize);
1928 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
1929 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
1930 return CGF.Builder.CreateBitCast(result, pointer->getType());
1935 = CGF.getContext().getAsVariableArrayType(elementType)) {
1937 llvm::Value *numElements = CGF.getVLASize(vla).first;
1943 if (CGF.getLangOptions().isSignedOverflowDefined()) {
1944 index = CGF.Builder.CreateMul(index, numElements, "vla.index");
1945 pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
1947 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
1948 pointer = CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
1957 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
1958 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
1959 return CGF.Builder.CreateBitCast(result, pointer->getType());
1962 if (CGF.getLangOptions().isSignedOverflowDefined())
1963 return CGF.Builder.CreateGEP(pointer, index, "add.ptr");
1965 return CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
1971 return emitPointerArithmetic(CGF, op, /*subtraction*/ false);
1974 switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) {
1994 switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) {
2013 return emitPointerArithmetic(CGF, op, /*subtraction*/ true);
2019 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
2021 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
2032 = CGF.getContext().getAsVariableArrayType(elementType)) {
2034 llvm::tie(numElements, elementType) = CGF.getVLASize(vla);
2039 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType);
2041 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
2053 elementSize = CGF.getContext().getTypeSizeInChars(elementType);
2059 divisor = CGF.CGM.getSize(elementSize);
2075 if (CGF.CatchUndefined
2078 llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
2079 CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS,
2081 Cont, CGF.getTrapBB());
2082 CGF.EmitBlock(Cont);
2095 if (CGF.CatchUndefined
2098 llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
2099 CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS,
2101 Cont, CGF.getTrapBB());
2102 CGF.EmitBlock(Cont);
2160 Value *LHS = CGF.EmitScalarExpr(E->getLHS());
2161 Value *RHS = CGF.EmitScalarExpr(E->getRHS());
2162 Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison(
2163 CGF
2228 llvm::Function *F = CGF.CGM.getIntrinsic(ID);
2230 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType());
2252 CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS());
2253 CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS());
2281 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType());
2292 llvm::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
2296 llvm::tie(LHS,RHS) = CGF.EmitARCStoreAutoreleasing(E);
2302 RHS = CGF.EmitARCStoreWeak(LHS.getAddress(), RHS, Ignore);
2318 CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS);
2320 CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS);
2328 if (!CGF.getContext().getLangOptions().CPlusPlus)
2349 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
2351 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2357 if (!CGF.ContainsLabel(E->getRHS()))
2361 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");
2362 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs");
2364 CodeGenFunction::ConditionalEvaluation eval(CGF);
2367 CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock);
2378 eval.begin(CGF);
2379 CGF.EmitBlock(RHSBlock);
2380 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2381 eval.end(CGF);
2388 if (CGF.getDebugInfo())
2391 CGF.EmitBlock(ContBlock);
2404 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
2406 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2412 if (!CGF.ContainsLabel(E->getRHS()))
2416 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end");
2417 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs");
2419 CodeGenFunction::ConditionalEvaluation eval(CGF);
2422 CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock);
2433 eval.begin(CGF);
2436 CGF.EmitBlock(RHSBlock);
2437 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
2439 eval.end(CGF);
2446 CGF.EmitBlock(ContBlock);
2454 CGF.EmitIgnoredExpr(E->getLHS());
2455 CGF.EnsureInsertPoint();
2468 CodeGenFunction &CGF) {
2472 if (E->isConstantInitializer(CGF.getContext(), false))
2479 if (VD->hasLocalStorage() && !(CGF.getContext()
2493 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
2502 if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
2507 if (!CGF.ContainsLabel(dead)) {
2514 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));
2522 if (CGF.getContext().getLangOptions().OpenCL
2524 llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
2569 if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) &&
2570 isCheapEnoughToEvaluateUnconditionally(rhsExpr, CGF)) {
2571 llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr);
2577 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
2578 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
2579 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
2581 CodeGenFunction::ConditionalEvaluation eval(CGF);
2582 CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock);
2584 CGF.EmitBlock(LHSBlock);
2585 eval.begin(CGF);
2587 eval.end(CGF);
2592 CGF.EmitBlock(RHSBlock);
2593 eval.begin(CGF);
2595 eval.end(CGF);
2598 CGF
2614 return Visit(E->getChosenSubExpr(CGF.getContext()));
2618 llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
2619 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
2630 return CGF.EmitBlockLiteral(block);
2634 Value *Src = CGF.EmitScalarExpr(E->getSrcExpr());
2672 llvm::Type::getInt32Ty(CGF.getLLVMContext())));
2684 return CGF.EmitAtomicExpr(E).getScalarVal();
