26 #include "llvm/IR/CFG.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/GlobalVariable.h"
31 #include "llvm/IR/Intrinsics.h"
32 #include "llvm/IR/Module.h"
35 using namespace clang;
36 using namespace CodeGen;
53 static bool MustVisitNullValue(
const Expr *E) {
60 class ScalarExprEmitter
64 bool IgnoreResultAssign;
65 llvm::LLVMContext &VMContext;
70 VMContext(cgf.getLLVMContext()) {
77 bool TestAndClearIgnoreResultAssign() {
78 bool I = IgnoreResultAssign;
79 IgnoreResultAssign =
false;
83 llvm::Type *ConvertType(
QualType T) {
return CGF.ConvertType(T); }
84 LValue EmitLValue(
const Expr *E) {
return CGF.EmitLValue(E); }
86 return CGF.EmitCheckedLValue(E, TCK);
89 void EmitBinOpCheck(
ArrayRef<std::pair<Value *, SanitizerMask>> Checks,
90 const BinOpInfo &Info);
93 return CGF.EmitLoadOfLValue(LV, Loc).getScalarVal();
96 void EmitLValueAlignmentAssumption(
const Expr *E,
Value *V) {
97 const AlignValueAttr *AVAttr =
nullptr;
98 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
102 if (
const auto *TTy =
104 AVAttr = TTy->getDecl()->
getAttr<AlignValueAttr>();
108 if (isa<ParmVarDecl>(VD))
111 AVAttr = VD->
getAttr<AlignValueAttr>();
116 if (
const auto *TTy =
117 dyn_cast<TypedefType>(E->
getType()))
118 AVAttr = TTy->getDecl()->getAttr<AlignValueAttr>();
123 Value *AlignmentValue = CGF.EmitScalarExpr(AVAttr->getAlignment());
124 llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(AlignmentValue);
125 CGF.EmitAlignmentAssumption(V, AlignmentCI->getZExtValue());
135 EmitLValueAlignmentAssumption(E, V);
145 void EmitFloatConversionCheck(
Value *OrigSrc,
QualType OrigSrcType,
147 QualType DstType, llvm::Type *DstTy);
165 llvm::Value *Zero = llvm::Constant::getNullValue(V->getType());
166 return Builder.CreateFCmpUNE(V, Zero,
"tobool");
170 Value *EmitPointerToBoolConversion(
Value *V) {
171 Value *Zero = llvm::ConstantPointerNull::get(
172 cast<llvm::PointerType>(V->getType()));
173 return Builder.CreateICmpNE(V, Zero,
"tobool");
180 if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(V)) {
181 if (ZI->getOperand(0)->getType() ==
Builder.getInt1Ty()) {
187 ZI->eraseFromParent();
192 return Builder.CreateIsNotNull(V,
"tobool");
205 S->dump(CGF.getContext().getSourceManager());
206 llvm_unreachable(
"Stmt can't have complex result type!");
225 return llvm::ConstantFP::get(VMContext, E->
getValue());
228 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
231 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
234 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
237 return EmitNullValue(E->
getType());
240 return EmitNullValue(E->
getType());
254 return CGF.EmitPseudoObjectRValue(E).getScalarVal();
259 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E), E->
getExprLoc());
262 return CGF.getOpaqueRValueMapping(E).getScalarVal();
268 if (result.isReference())
269 return EmitLoadOfLValue(result.getReferenceLValue(CGF, E),
271 return result.getValue();
273 return EmitLoadOfLValue(E);
277 return CGF.EmitObjCSelectorExpr(E);
280 return CGF.EmitObjCProtocolExpr(E);
283 return EmitLoadOfLValue(E);
288 return EmitLoadOfLValue(E);
289 return CGF.EmitObjCMessageExpr(E).getScalarVal();
293 LValue LV = CGF.EmitObjCIsaExpr(E);
302 Value *VisitExtVectorElementExpr(
Expr *E) {
return EmitLoadOfLValue(E); }
304 return EmitLoadOfLValue(E);
310 return EmitNullValue(E->
getType());
314 CGF.EmitVariablyModifiedType(E->
getType());
317 DI->EmitExplicitCastType(E->
getType());
319 return VisitCastExpr(E);
325 return EmitLoadOfLValue(E);
327 Value *V = CGF.EmitCallExpr(E).getScalarVal();
329 EmitLValueAlignmentAssumption(E, V);
338 return EmitScalarPrePostIncDec(E, LV,
false,
false);
342 return EmitScalarPrePostIncDec(E, LV,
true,
false);
346 return EmitScalarPrePostIncDec(E, LV,
false,
true);
350 return EmitScalarPrePostIncDec(E, LV,
true,
true);
358 bool isInc,
bool isPre);
362 if (isa<MemberPointerType>(E->
getType()))
363 return CGF.CGM.getMemberPointerConstant(E);
365 return EmitLValue(E->
getSubExpr()).getAddress();
370 return EmitLoadOfLValue(E);
374 TestAndClearIgnoreResultAssign();
388 return EmitLoadOfLValue(E);
399 return CGF.LoadCXXThis();
403 CGF.enterFullExpression(E);
408 return CGF.EmitCXXNewExpr(E);
411 CGF.EmitCXXDeleteExpr(E);
416 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
433 CGF.EmitScalarExpr(E->
getBase());
438 return EmitNullValue(E->
getType());
442 CGF.EmitCXXThrowExpr(E);
451 Value *EmitMul(
const BinOpInfo &Ops) {
452 if (Ops.Ty->isSignedIntegerOrEnumerationType()) {
453 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
455 return Builder.CreateMul(Ops.LHS, Ops.RHS,
"mul");
457 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
458 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS,
"mul");
461 return EmitOverflowCheckedBinOp(Ops);
465 if (Ops.Ty->isUnsignedIntegerType() &&
466 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow))
467 return EmitOverflowCheckedBinOp(Ops);
469 if (Ops.LHS->getType()->isFPOrFPVectorTy())
470 return Builder.CreateFMul(Ops.LHS, Ops.RHS,
"mul");
471 return Builder.CreateMul(Ops.LHS, Ops.RHS,
"mul");
475 Value *EmitOverflowCheckedBinOp(
const BinOpInfo &Ops);
478 void EmitUndefinedBehaviorIntegerDivAndRemCheck(
const BinOpInfo &Ops,
482 Value *EmitDiv(
const BinOpInfo &Ops);
483 Value *EmitRem(
const BinOpInfo &Ops);
484 Value *EmitAdd(
const BinOpInfo &Ops);
485 Value *EmitSub(
const BinOpInfo &Ops);
486 Value *EmitShl(
const BinOpInfo &Ops);
487 Value *EmitShr(
const BinOpInfo &Ops);
488 Value *EmitAnd(
const BinOpInfo &Ops) {
489 return Builder.CreateAnd(Ops.LHS, Ops.RHS,
"and");
491 Value *EmitXor(
const BinOpInfo &Ops) {
492 return Builder.CreateXor(Ops.LHS, Ops.RHS,
"xor");
494 Value *EmitOr (
const BinOpInfo &Ops) {
495 return Builder.CreateOr(Ops.LHS, Ops.RHS,
"or");
500 Value *(ScalarExprEmitter::*F)(
const BinOpInfo &),
504 Value *(ScalarExprEmitter::*F)(
const BinOpInfo &));
507 #define HANDLEBINOP(OP) \
508 Value *VisitBin ## OP(const BinaryOperator *E) { \
509 return Emit ## OP(EmitBinOps(E)); \
511 Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \
512 return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \
528 unsigned SICmpOpc,
unsigned FCmpOpc);
529 #define VISITCOMP(CODE, UI, SI, FP) \
530 Value *VisitBin##CODE(const BinaryOperator *E) { \
531 return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \
532 llvm::FCmpInst::FP); }
533 VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT)
534 VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT)
535 VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE)
536 VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE)
537 VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ)
538 VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE)
547 Value *VisitBinPtrMemD(
const Expr *E) {
return EmitLoadOfLValue(E); }
548 Value *VisitBinPtrMemI(
const Expr *E) {
return EmitLoadOfLValue(E); }
556 return CGF.EmitObjCStringLiteral(E);
559 return CGF.EmitObjCBoxedExpr(E);
562 return CGF.EmitObjCArrayLiteral(E);
565 return CGF.EmitObjCDictionaryLiteral(E);
579 assert(SrcType.
isCanonical() &&
"EmitScalarConversion strips typedefs");
582 return EmitFloatToBoolConversion(Src);
585 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT);
587 assert((SrcType->
isIntegerType() || isa<llvm::PointerType>(Src->getType())) &&
588 "Unknown scalar type to convert");
590 if (isa<llvm::IntegerType>(Src->getType()))
591 return EmitIntToBoolConversion(Src);
593 assert(isa<llvm::PointerType>(Src->getType()));
594 return EmitPointerToBoolConversion(Src);
597 void ScalarExprEmitter::EmitFloatConversionCheck(
Value *OrigSrc,
606 llvm::Type *SrcTy = Src->getType();
609 if (llvm::IntegerType *IntTy = dyn_cast<llvm::IntegerType>(SrcTy)) {
615 APFloat LargestFloat =
616 APFloat::getLargest(CGF.getContext().getFloatTypeSemantics(DstType));
617 APSInt LargestInt(IntTy->getBitWidth(), SrcIsUnsigned);
620 if (LargestFloat.convertToInteger(LargestInt, APFloat::rmTowardZero,
621 &IsExact) != APFloat::opOK)
626 llvm::Value *Max = llvm::ConstantInt::get(VMContext, LargestInt);
628 Check =
Builder.CreateICmpULE(Src, Max);
630 llvm::Value *Min = llvm::ConstantInt::get(VMContext, -LargestInt);
633 Check =
Builder.CreateAnd(GE, LE);
636 const llvm::fltSemantics &SrcSema =
637 CGF.getContext().getFloatTypeSemantics(OrigSrcType);
638 if (isa<llvm::IntegerType>(DstTy)) {
642 unsigned Width = CGF.getContext().getIntWidth(DstType);
645 APSInt Min = APSInt::getMinValue(Width, Unsigned);
646 APFloat MinSrc(SrcSema, APFloat::uninitialized);
647 if (MinSrc.convertFromAPInt(Min, !Unsigned, APFloat::rmTowardZero) &
651 MinSrc = APFloat::getInf(SrcSema,
true);
655 MinSrc.subtract(APFloat(SrcSema, 1), APFloat::rmTowardNegative);
657 APSInt Max = APSInt::getMaxValue(Width, Unsigned);
658 APFloat MaxSrc(SrcSema, APFloat::uninitialized);
659 if (MaxSrc.convertFromAPInt(Max, !Unsigned, APFloat::rmTowardZero) &
663 MaxSrc = APFloat::getInf(SrcSema,
false);
667 MaxSrc.add(APFloat(SrcSema, 1), APFloat::rmTowardPositive);
672 const llvm::fltSemantics &
Sema =
673 CGF.getContext().getFloatTypeSemantics(SrcType);
675 MinSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
676 MaxSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
680 Builder.CreateFCmpOGT(Src, llvm::ConstantFP::get(VMContext, MinSrc));
682 Builder.CreateFCmpOLT(Src, llvm::ConstantFP::get(VMContext, MaxSrc));
683 Check =
Builder.CreateAnd(GE, LE);
700 if (CGF.getContext().getFloatingTypeOrder(OrigSrcType, DstType) != 1)
704 "should not check conversion from __half, it has the lowest rank");
706 const llvm::fltSemantics &DstSema =
707 CGF.getContext().getFloatTypeSemantics(DstType);
708 APFloat MinBad = APFloat::getLargest(DstSema,
false);
709 APFloat MaxBad = APFloat::getInf(DstSema,
false);
712 MinBad.convert(SrcSema, APFloat::rmTowardZero, &IsInexact);
713 MaxBad.convert(SrcSema, APFloat::rmTowardZero, &IsInexact);
715 Value *AbsSrc = CGF.EmitNounwindRuntimeCall(
718 Builder.CreateFCmpOGT(AbsSrc, llvm::ConstantFP::get(VMContext, MinBad));
720 Builder.CreateFCmpOLT(AbsSrc, llvm::ConstantFP::get(VMContext, MaxBad));
726 llvm::Constant *StaticArgs[] = {
727 CGF.EmitCheckTypeDescriptor(OrigSrcType),
728 CGF.EmitCheckTypeDescriptor(DstType)
730 CGF.EmitCheck(std::make_pair(Check, SanitizerKind::FloatCastOverflow),
731 "float_cast_overflow", StaticArgs, OrigSrc);
740 if (SrcType == DstType)
return Src;
746 llvm::Type *SrcTy = Src->getType();
750 return EmitConversionToBool(Src, SrcType);
752 llvm::Type *DstTy = ConvertType(DstType);
755 if (SrcType->
isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
757 if (DstTy->isFloatingPointTy()) {
758 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns)
760 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16, DstTy),
766 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
768 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
772 Src =
Builder.CreateFPExt(Src, CGF.CGM.FloatTy,
"conv");
774 SrcType = CGF.getContext().FloatTy;
786 if (isa<llvm::PointerType>(DstTy)) {
788 if (isa<llvm::PointerType>(SrcTy))
789 return Builder.CreateBitCast(Src, DstTy,
"conv");
791 assert(SrcType->
isIntegerType() &&
"Not ptr->ptr or int->ptr conversion?");
794 llvm::Type *MiddleTy = CGF.IntPtrTy;
797 Builder.CreateIntCast(Src, MiddleTy, InputSigned,
"conv");
799 return Builder.CreateIntToPtr(IntResult, DstTy,
"conv");
802 if (isa<llvm::PointerType>(SrcTy)) {
804 assert(isa<llvm::IntegerType>(DstTy) &&
"not ptr->int?");
805 return Builder.CreatePtrToInt(Src, DstTy,
"conv");
812 llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy);
815 unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements();
816 return Builder.CreateVectorSplat(NumElements, Elt,
"splat");
820 if (isa<llvm::VectorType>(SrcTy) ||
821 isa<llvm::VectorType>(DstTy))
822 return Builder.CreateBitCast(Src, DstTy,
"conv");
825 Value *Res =
nullptr;
826 llvm::Type *ResTy = DstTy;
830 if (CGF.SanOpts.has(SanitizerKind::FloatCastOverflow) &&
832 EmitFloatConversionCheck(OrigSrc, OrigSrcType, Src, SrcType, DstType,
836 if (DstType->
isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
838 if (SrcTy->isFloatingPointTy()) {
841 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns)
843 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, SrcTy), Src);
845 return Builder.CreateFPTrunc(Src, DstTy);
850 if (isa<llvm::IntegerType>(SrcTy)) {
852 if (isa<llvm::IntegerType>(DstTy))
853 Res =
Builder.CreateIntCast(Src, DstTy, InputSigned,
"conv");
854 else if (InputSigned)
855 Res =
Builder.CreateSIToFP(Src, DstTy,
"conv");
857 Res =
Builder.CreateUIToFP(Src, DstTy,
"conv");
858 }
else if (isa<llvm::IntegerType>(DstTy)) {
859 assert(SrcTy->isFloatingPointTy() &&
"Unknown real conversion");
861 Res =
Builder.CreateFPToSI(Src, DstTy,
"conv");
863 Res =
Builder.CreateFPToUI(Src, DstTy,
"conv");
865 assert(SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy() &&
866 "Unknown real conversion");
867 if (DstTy->getTypeID() < SrcTy->getTypeID())
868 Res =
Builder.CreateFPTrunc(Src, DstTy,
"conv");
870 Res =
Builder.CreateFPExt(Src, DstTy,
"conv");
873 if (DstTy != ResTy) {
874 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
875 assert(ResTy->isIntegerTy(16) &&
"Only half FP requires extra conversion");
877 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, CGF.CGM.FloatTy),
880 Res =
Builder.CreateFPTrunc(Res, ResTy,
"conv");
890 Value *ScalarExprEmitter::
899 Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy);
900 Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy);
901 return Builder.CreateOr(Src.first, Src.second,
"tobool");
908 return EmitScalarConversion(Src.first, SrcTy, DstTy);
912 return CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(Ty), Ty);
919 void ScalarExprEmitter::EmitBinOpCheck(
920 ArrayRef<std::pair<Value *, SanitizerMask>> Checks,
const BinOpInfo &Info) {
921 assert(CGF.IsSanitizerScope);
930 StaticData.push_back(CGF.EmitCheckSourceLocation(Info.E->getExprLoc()));
933 CheckName =
"negate_overflow";
934 StaticData.push_back(CGF.EmitCheckTypeDescriptor(UO->
getType()));
935 DynamicData.push_back(Info.RHS);
939 CheckName =
"shift_out_of_bounds";
941 StaticData.push_back(
943 StaticData.push_back(
947 CheckName =
"divrem_overflow";
948 StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
952 case BO_Add: CheckName =
"add_overflow";
break;
953 case BO_Sub: CheckName =
"sub_overflow";
break;
954 case BO_Mul: CheckName =
"mul_overflow";
break;
955 default: llvm_unreachable(
"unexpected opcode for bin op check");
957 StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
959 DynamicData.push_back(Info.LHS);
960 DynamicData.push_back(Info.RHS);
963 CGF.EmitCheck(Checks, CheckName, StaticData, DynamicData);
970 Value *ScalarExprEmitter::VisitExpr(
Expr *E) {
971 CGF.ErrorUnsupported(E,
"scalar expression");
974 return llvm::UndefValue::get(CGF.ConvertType(E->
getType()));
985 llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType());
986 unsigned LHSElts = LTy->getNumElements();
989 Mask = CGF.EmitScalarExpr(E->
getExpr(2));
993 for (
unsigned i = 0; i != LHSElts; ++i) {
994 concat.push_back(
Builder.getInt32(2*i));
995 concat.push_back(
Builder.getInt32(2*i+1));
998 Value* CV = llvm::ConstantVector::get(concat);
999 LHS =
Builder.CreateShuffleVector(LHS, RHS, CV,
"concat");
1005 llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType());
1006 llvm::Constant* EltMask;
1008 EltMask = llvm::ConstantInt::get(MTy->getElementType(),
1009 llvm::NextPowerOf2(LHSElts-1)-1);
1012 Value *MaskBits = llvm::ConstantVector::getSplat(MTy->getNumElements(),
1014 Mask =
Builder.CreateAnd(Mask, MaskBits,
"mask");
1022 llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(),
1023 MTy->getNumElements());
1024 Value* NewV = llvm::UndefValue::get(RTy);
1025 for (
unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) {
1026 Value *IIndx = llvm::ConstantInt::get(CGF.SizeTy, i);
1027 Value *Indx =
Builder.CreateExtractElement(Mask, IIndx,
"shuf_idx");
1029 Value *VExt =
Builder.CreateExtractElement(LHS, Indx,
"shuf_elt");
1030 NewV =
Builder.CreateInsertElement(NewV, VExt, IIndx,
"shuf_ins");
1042 if (Idx.isSigned() && Idx.isAllOnesValue())
1043 indices.push_back(llvm::UndefValue::get(CGF.Int32Ty));
1045 indices.push_back(
Builder.getInt32(Idx.getZExtValue()));
1048 Value *SV = llvm::ConstantVector::get(indices);
1049 return Builder.CreateShuffleVector(V1, V2, SV,
"shuffle");
1060 if (SrcType == DstType)
return Src;
1063 "ConvertVector source type must be a vector");
1065 "ConvertVector destination type must be a vector");
1067 llvm::Type *SrcTy = Src->getType();
1068 llvm::Type *DstTy = ConvertType(DstType);
1077 assert(SrcTy->isVectorTy() &&
1078 "ConvertVector source IR type must be a vector");
1079 assert(DstTy->isVectorTy() &&
1080 "ConvertVector destination IR type must be a vector");
1082 llvm::Type *SrcEltTy = SrcTy->getVectorElementType(),
1083 *DstEltTy = DstTy->getVectorElementType();
1085 if (DstEltType->isBooleanType()) {
1086 assert((SrcEltTy->isFloatingPointTy() ||
1087 isa<llvm::IntegerType>(SrcEltTy)) &&
"Unknown boolean conversion");
1089 llvm::Value *Zero = llvm::Constant::getNullValue(SrcTy);
1090 if (SrcEltTy->isFloatingPointTy()) {
1091 return Builder.CreateFCmpUNE(Src, Zero,
"tobool");
1093 return Builder.CreateICmpNE(Src, Zero,
"tobool");
1098 Value *Res =
nullptr;
1100 if (isa<llvm::IntegerType>(SrcEltTy)) {
1102 if (isa<llvm::IntegerType>(DstEltTy))
1103 Res =
Builder.CreateIntCast(Src, DstTy, InputSigned,
"conv");
1104 else if (InputSigned)
1105 Res =
Builder.CreateSIToFP(Src, DstTy,
"conv");
1107 Res =
Builder.CreateUIToFP(Src, DstTy,
"conv");
1108 }
else if (isa<llvm::IntegerType>(DstEltTy)) {
1109 assert(SrcEltTy->isFloatingPointTy() &&
"Unknown real conversion");
1110 if (DstEltType->isSignedIntegerOrEnumerationType())
1111 Res =
Builder.CreateFPToSI(Src, DstTy,
"conv");
1113 Res =
Builder.CreateFPToUI(Src, DstTy,
"conv");
1115 assert(SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() &&
1116 "Unknown real conversion");
1117 if (DstEltTy->getTypeID() < SrcEltTy->getTypeID())
1118 Res =
Builder.CreateFPTrunc(Src, DstTy,
"conv");
1120 Res =
Builder.CreateFPExt(Src, DstTy,
"conv");
1130 CGF.EmitScalarExpr(E->
getBase());
1136 return EmitLoadOfLValue(E);
1140 TestAndClearIgnoreResultAssign();
1147 return EmitLoadOfLValue(E);
1152 Value *Idx = Visit(E->
getIdx());
1155 if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
1156 CGF.EmitBoundsCheck(E, E->
getBase(), Idx, IdxTy,
true);
1158 return Builder.CreateExtractElement(Base, Idx,
"vecext");
1161 static llvm::Constant *
getMaskElt(llvm::ShuffleVectorInst *SVI,
unsigned Idx,
1162 unsigned Off, llvm::Type *I32Ty) {
1163 int MV = SVI->getMaskValue(Idx);
1165 return llvm::UndefValue::get(I32Ty);
1166 return llvm::ConstantInt::get(I32Ty, Off+MV);
1169 static llvm::Constant *
getAsInt32(llvm::ConstantInt *
C, llvm::Type *I32Ty) {
1170 if (C->getBitWidth() != 32) {
1171 assert(llvm::ConstantInt::isValueValidForType(I32Ty,
1172 C->getZExtValue()) &&
1173 "Index operand too large for shufflevector mask!");
1174 return llvm::ConstantInt::get(I32Ty, C->getZExtValue());
1179 Value *ScalarExprEmitter::VisitInitListExpr(
InitListExpr *E) {
1180 bool Ignore = TestAndClearIgnoreResultAssign();
1182 assert (Ignore ==
false &&
"init list ignored");
1186 CGF.ErrorUnsupported(E,
"GNU array range designator extension");
1188 llvm::VectorType *VType =
1189 dyn_cast<llvm::VectorType>(ConvertType(E->
getType()));
1192 if (NumInitElements == 0) {
1194 return EmitNullValue(E->
getType());
1200 unsigned ResElts = VType->getNumElements();
1207 unsigned CurIdx = 0;
1208 bool VIsUndefShuffle =
false;
1210 for (
unsigned i = 0; i != NumInitElements; ++i) {
1212 Value *Init = Visit(IE);
1215 llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType());
1221 if (isa<ExtVectorElementExpr>(IE)) {
1222 llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init);
1224 if (EI->getVectorOperandType()->getNumElements() == ResElts) {
1225 llvm::ConstantInt *
C = cast<llvm::ConstantInt>(EI->getIndexOperand());
1226 Value *LHS =
nullptr, *RHS =
nullptr;
1231 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1233 LHS = EI->getVectorOperand();
1235 VIsUndefShuffle =
true;
1236 }
else if (VIsUndefShuffle) {
1238 llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V);
1239 for (
unsigned j = 0; j != CurIdx; ++j)
1240 Args.push_back(
getMaskElt(SVV, j, 0, CGF.Int32Ty));
1241 Args.push_back(
Builder.getInt32(ResElts + C->getZExtValue()));
1242 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1244 LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
1245 RHS = EI->getVectorOperand();
1246 VIsUndefShuffle =
false;
1248 if (!Args.empty()) {
1249 llvm::Constant *Mask = llvm::ConstantVector::get(Args);
1250 V =
Builder.CreateShuffleVector(LHS, RHS, Mask);
1256 V =
Builder.CreateInsertElement(V, Init,
Builder.getInt32(CurIdx),
1258 VIsUndefShuffle =
false;
1263 unsigned InitElts = VVT->getNumElements();
1268 unsigned Offset = (CurIdx == 0) ? 0 : ResElts;
1269 if (isa<ExtVectorElementExpr>(IE)) {
1270 llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init);
1271 Value *SVOp = SVI->getOperand(0);
1272 llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType());
1274 if (OpTy->getNumElements() == ResElts) {
1275 for (
unsigned j = 0; j != CurIdx; ++j) {
1278 if (VIsUndefShuffle) {
1279 Args.push_back(
getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0,
1282 Args.push_back(
Builder.getInt32(j));
1285 for (
unsigned j = 0, je = InitElts; j != je; ++j)
1286 Args.push_back(
getMaskElt(SVI, j, Offset, CGF.Int32Ty));
1287 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1289 if (VIsUndefShuffle)
1290 V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
1299 for (
unsigned j = 0; j != InitElts; ++j)
1300 Args.push_back(
Builder.getInt32(j));
1301 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1302 llvm::Constant *Mask = llvm::ConstantVector::get(Args);
1303 Init =
Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT),
1307 for (
unsigned j = 0; j != CurIdx; ++j)
1308 Args.push_back(
Builder.getInt32(j));
1309 for (
unsigned j = 0; j != InitElts; ++j)
1310 Args.push_back(
Builder.getInt32(j+Offset));
1311 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1318 llvm::Constant *Mask = llvm::ConstantVector::get(Args);
1319 V =
Builder.CreateShuffleVector(V, Init, Mask,
"vecinit");
1320 VIsUndefShuffle = isa<llvm::UndefValue>(Init);
1326 llvm::Type *EltTy = VType->getElementType();
1329 for (; CurIdx < ResElts; ++CurIdx) {
1330 Value *Idx =
Builder.getInt32(CurIdx);
1331 llvm::Value *Init = llvm::Constant::getNullValue(EltTy);
1332 V =
Builder.CreateInsertElement(V, Init, Idx,
"vecinit");
1343 if (isa<CXXThisExpr>(E)) {
1360 Value *ScalarExprEmitter::VisitCastExpr(
CastExpr *CE) {
1366 TestAndClearIgnoreResultAssign();
1372 case CK_Dependent: llvm_unreachable(
"dependent cast kind in IR gen!");
1374 llvm_unreachable(
"builtin functions are handled elsewhere");
1378 Value *V = EmitLValue(E).getAddress();
1380 ConvertType(CGF.getContext().getPointerType(DestTy)));
1381 return EmitLoadOfLValue(CGF.MakeNaturalAlignAddrLValue(V, DestTy),
1389 Value *Src = Visit(const_cast<Expr*>(E));
1390 llvm::Type *SrcTy = Src->getType();
1391 llvm::Type *DstTy = ConvertType(DestTy);
1392 if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() &&
1393 SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) {
1394 llvm_unreachable(
"wrong cast for pointers in different address spaces"
1395 "(must be an address space cast)!");
1398 if (CGF.SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
1400 CGF.EmitVTablePtrCheckForCast(PT->getPointeeType(), Src,
1406 return Builder.CreateBitCast(Src, DstTy);
1409 Value *Src = Visit(const_cast<Expr*>(E));
1410 return Builder.CreateAddrSpaceCast(Src, ConvertType(DestTy));
1416 return Visit(const_cast<Expr*>(E));
1420 assert(DerivedClassDecl &&
"BaseToDerived arg isn't a C++ object pointer!");
1425 CGF.GetAddressOfDerivedClass(V, DerivedClassDecl,
1431 if (CGF.sanitizePerformTypeCheck())
1435 if (CGF.SanOpts.has(SanitizerKind::CFIDerivedCast))
1447 assert(DerivedClassDecl &&
"DerivedToBase arg isn't a C++ object pointer!");
1449 return CGF.GetAddressOfBaseClass(
1454 Value *V = Visit(const_cast<Expr*>(E));
1456 return CGF.EmitDynamicCast(V, DCE);
1461 "Array to pointer decay must have array source type!");
1463 Value *V = EmitLValue(E).getAddress();
1468 assert(isa<llvm::PointerType>(V->getType()) &&
"Expected pointer");
1469 llvm::Type *NewTy = ConvertType(E->
getType());
1470 V = CGF.Builder.CreatePointerCast(
1471 V, NewTy->getPointerTo(V->getType()->getPointerAddressSpace()));
1473 assert(isa<llvm::ArrayType>(V->getType()->getPointerElementType()) &&
1474 "Expected pointer to array");
1475 V =
Builder.CreateStructGEP(NewTy, V, 0,
"arraydecay");
1480 return CGF.Builder.CreatePointerCast(V, ConvertType(CE->
getType()));
1483 return EmitLValue(E).getAddress();
1486 if (MustVisitNullValue(E))
1489 return llvm::ConstantPointerNull::get(
1490 cast<llvm::PointerType>(ConvertType(DestTy)));
1493 if (MustVisitNullValue(E))
1497 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
1503 Value *Src = Visit(E);
1511 return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
1515 return CGF.EmitARCRetainScalarExpr(E);
1517 return CGF.EmitObjCConsumeObject(E->
getType(), Visit(E));
1520 value = CGF.EmitARCRetainAutoreleasedReturnValue(value);
1521 return CGF.EmitObjCConsumeObject(E->
getType(), value);
1524 return CGF.EmitARCExtendBlockObject(E);
1527 return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->
getType());
1537 llvm_unreachable(
"scalar cast to non-scalar value");
1540 assert(CGF.getContext().hasSameUnqualifiedType(E->
getType(), DestTy));
1541 assert(E->
isGLValue() &&
"lvalue-to-rvalue applied to r-value!");
1542 return Visit(const_cast<Expr*>(E));
1545 Value *Src = Visit(const_cast<Expr*>(E));
1549 llvm::Type *MiddleTy = CGF.IntPtrTy;
1552 Builder.CreateIntCast(Src, MiddleTy, InputSigned,
"conv");
1554 return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy));
1557 assert(!DestTy->
isBooleanType() &&
"bool should use PointerToBool");
1558 return Builder.CreatePtrToInt(Visit(E), ConvertType(DestTy));
1561 CGF.EmitIgnoredExpr(E);
1565 llvm::Type *DstTy = ConvertType(DestTy);
1566 Value *Elt = Visit(const_cast<Expr*>(E));
1567 Elt = EmitScalarConversion(Elt, E->
getType(),
1571 unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements();
1572 return Builder.CreateVectorSplat(NumElements, Elt,
"splat");
1579 return EmitScalarConversion(Visit(E), E->
getType(), DestTy);
1581 return EmitIntToBoolConversion(Visit(E));
1583 return EmitPointerToBoolConversion(Visit(E));
1585 return EmitFloatToBoolConversion(Visit(E));
1589 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
1594 return CGF.EmitComplexExpr(E,
false,
true).first;
1601 return EmitComplexToScalarConversion(V, E->
getType(), DestTy);
1605 assert(DestTy->
isEventT() &&
"CK_ZeroToOCLEvent cast on non-event type");
1606 return llvm::Constant::getNullValue(ConvertType(DestTy));
1611 llvm_unreachable(
"unknown scalar cast");
1614 Value *ScalarExprEmitter::VisitStmtExpr(
const StmtExpr *E) {
1620 return CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(RetAlloca, E->
getType()),
1632 BinOp.RHS = llvm::ConstantInt::get(InVal->getType(), 1,
false);
1635 BinOp.FPContractable =
false;
1640 llvm::Value *ScalarExprEmitter::EmitIncDecConsiderOverflowBehavior(
1643 llvm::ConstantInt::get(InVal->getType(), IsInc ? 1 : -1,
true);
1644 StringRef Name = IsInc ?
"inc" :
"dec";
1645 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
1647 return Builder.CreateAdd(InVal, Amount, Name);
1649 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
1650 return Builder.CreateNSWAdd(InVal, Amount, Name);
1655 llvm_unreachable(
"Unknown SignedOverflowBehaviorTy");
1660 bool isInc,
bool isPre) {
1663 llvm::PHINode *atomicPHI =
nullptr;
1667 int amount = (isInc ? 1 : -1);
1670 type = atomicTy->getValueType();
1674 Builder.Insert(
new llvm::StoreInst(True,
1677 llvm::SequentiallyConsistent));
1682 return Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1683 LV.
getAddress(), True, llvm::SequentiallyConsistent);
1690 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
1691 CGF.getLangOpts().getSignedOverflowBehavior() !=
1693 llvm::AtomicRMWInst::BinOp aop = isInc ? llvm::AtomicRMWInst::Add :
1694 llvm::AtomicRMWInst::Sub;
1695 llvm::Instruction::BinaryOps op = isInc ? llvm::Instruction::Add :
1696 llvm::Instruction::Sub;
1698 llvm::ConstantInt::get(ConvertType(type), 1,
true), type);
1700 LV.
getAddress(), amt, llvm::SequentiallyConsistent);
1701 return isPre ?
Builder.CreateBinOp(op, old, amt) : old;
1703 value = EmitLoadOfLValue(LV, E->
getExprLoc());
1706 llvm::BasicBlock *startBB =
Builder.GetInsertBlock();
1707 llvm::BasicBlock *opBB = CGF.createBasicBlock(
"atomic_op", CGF.CurFn);
1708 value = CGF.EmitToMemory(value, type);
1711 atomicPHI =
Builder.CreatePHI(value->getType(), 2);
1712 atomicPHI->addIncoming(value, startBB);
1715 value = EmitLoadOfLValue(LV, E->
getExprLoc());
1733 bool CanOverflow = value->getType()->getIntegerBitWidth() >=
1734 CGF.IntTy->getIntegerBitWidth();
1736 value = EmitIncDecConsiderOverflowBehavior(E, value, isInc);
1738 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) {
1742 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount,
true);
1743 value =
Builder.CreateAdd(value, amt, isInc ?
"inc" :
"dec");
1752 = CGF.getContext().getAsVariableArrayType(type)) {
1754 if (!isInc) numElts =
Builder.CreateNSWNeg(numElts,
"vla.negsize");
1755 if (CGF.getLangOpts().isSignedOverflowDefined())
1756 value =
Builder.CreateGEP(value, numElts,
"vla.inc");
1758 value =
Builder.CreateInBoundsGEP(value, numElts,
"vla.inc");
1764 value = CGF.EmitCastToVoidPtr(value);
1765 if (CGF.getLangOpts().isSignedOverflowDefined())
1766 value =
Builder.CreateGEP(value, amt,
"incdec.funcptr");
1768 value =
Builder.CreateInBoundsGEP(value, amt,
"incdec.funcptr");
1769 value =
Builder.CreateBitCast(value, input->getType());
1774 if (CGF.getLangOpts().isSignedOverflowDefined())
1775 value =
Builder.CreateGEP(value, amt,
"incdec.ptr");
1777 value =
Builder.CreateInBoundsGEP(value, amt,
"incdec.ptr");
1783 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount);
1785 value =
Builder.CreateAdd(value, amt, isInc ?
"inc" :
"dec");
1789 llvm::ConstantFP::get(value->getType(), amount),
1790 isInc ?
"inc" :
"dec");
1798 if (type->
isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
1800 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
1802 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
1804 input,
"incdec.conv");
1806 value =
Builder.CreateFPExt(input, CGF.CGM.FloatTy,
"incdec.conv");
1810 if (value->getType()->isFloatTy())
1811 amt = llvm::ConstantFP::get(VMContext,
1812 llvm::APFloat(static_cast<float>(amount)));
1813 else if (value->getType()->isDoubleTy())
1814 amt = llvm::ConstantFP::get(VMContext,
1815 llvm::APFloat(static_cast<double>(amount)));
1818 llvm::APFloat F(static_cast<float>(amount));
1822 F.convert(value->getType()->isHalfTy()
1823 ? CGF.getTarget().getHalfFormat()
1824 : CGF.getTarget().getLongDoubleFormat(),
1825 llvm::APFloat::rmTowardZero, &ignored);
1826 amt = llvm::ConstantFP::get(VMContext, F);
1828 value =
Builder.CreateFAdd(value, amt, isInc ?
"inc" :
"dec");
1830 if (type->
isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
1831 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
1833 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16,
1835 value,
"incdec.conv");
1837 value =
Builder.CreateFPTrunc(value, input->getType(),
"incdec.conv");
1844 value = CGF.EmitCastToVoidPtr(value);
1847 if (!isInc) size = -size;
1849 llvm::ConstantInt::get(CGF.SizeTy, size.
getQuantity());
1851 if (CGF.getLangOpts().isSignedOverflowDefined())
1852 value =
Builder.CreateGEP(value, sizeValue,
"incdec.objptr");
1854 value =
Builder.CreateInBoundsGEP(value, sizeValue,
"incdec.objptr");
1855 value =
Builder.CreateBitCast(value, input->getType());
1859 llvm::BasicBlock *opBB =
Builder.GetInsertBlock();
1860 llvm::BasicBlock *contBB = CGF.createBasicBlock(
"atomic_cont", CGF.CurFn);
1861 auto Pair = CGF.EmitAtomicCompareExchange(
1865 atomicPHI->addIncoming(old, opBB);
1866 Builder.CreateCondBr(success, contBB, opBB);
1867 Builder.SetInsertPoint(contBB);
1868 return isPre ? value : input;
1873 CGF.EmitStoreThroughBitfieldLValue(
RValue::get(value), LV, &value);
1875 CGF.EmitStoreThroughLValue(
RValue::get(value), LV);
1879 return isPre ? value : input;
1884 Value *ScalarExprEmitter::VisitUnaryMinus(
const UnaryOperator *E) {
1885 TestAndClearIgnoreResultAssign();
1890 if (BinOp.RHS->getType()->isFPOrFPVectorTy())
1891 BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType());
1893 BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType());
1896 BinOp.FPContractable =
false;
1898 return EmitSub(BinOp);
1901 Value *ScalarExprEmitter::VisitUnaryNot(
const UnaryOperator *E) {
1902 TestAndClearIgnoreResultAssign();
1904 return Builder.CreateNot(Op,
"neg");
1907 Value *ScalarExprEmitter::VisitUnaryLNot(
const UnaryOperator *E) {
1911 Value *Zero = llvm::Constant::getNullValue(Oper->getType());
1913 if (Oper->getType()->isFPOrFPVectorTy())
1914 Result =
Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper, Zero,
"cmp");
1916 Result =
Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero,
"cmp");
1917 return Builder.CreateSExt(Result, ConvertType(E->
getType()),
"sext");
1921 Value *BoolVal = CGF.EvaluateExprAsBool(E->
getSubExpr());
1926 BoolVal =
Builder.CreateNot(BoolVal,
"lnot");
1929 return Builder.CreateZExt(BoolVal, ConvertType(E->
getType()),
"lnot.ext");
1932 Value *ScalarExprEmitter::VisitOffsetOfExpr(
OffsetOfExpr *E) {
1940 llvm::Type* ResultType = ConvertType(E->
getType());
1941 llvm::Value* Result = llvm::Constant::getNullValue(ResultType);
1943 for (
unsigned i = 0; i != n; ++i) {
1952 Idx =
Builder.CreateIntCast(Idx, ResultType, IdxSigned,
"conv");
1956 CGF.getContext().getAsArrayType(CurrentType)->getElementType();
1959 llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType,
1960 CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity());
1963 Offset =
Builder.CreateMul(Idx, ElemSize);
1977 Field != FieldEnd; ++Field, ++i) {
1978 if (*Field == MemberDecl)
1981 assert(i < RL.
getFieldCount() &&
"offsetof field in wrong type");
1985 CGF.getContext().getCharWidth();
1986 Offset = llvm::ConstantInt::get(ResultType, OffsetInt);
1989 CurrentType = MemberDecl->
getType();
1994 llvm_unreachable(
"dependent __builtin_offsetof");
1998 CGF.ErrorUnsupported(E,
"virtual base in offsetof");
2012 Offset = llvm::ConstantInt::get(ResultType, OffsetInt.getQuantity());
2016 Result =
Builder.CreateAdd(Result, Offset);
2024 ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr(
2029 CGF.getContext().getAsVariableArrayType(TypeToSize)) {
2032 CGF.EmitVariablyModifiedType(TypeToSize);
2041 std::tie(numElts, eltType) = CGF.getVLASize(VAT);
2046 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType);
2047 if (!eltSize.
isOne())
2048 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts);
2055 .toCharUnitsFromBits(CGF.getContext().getOpenMPDefaultSimdAlign(
2058 return llvm::ConstantInt::get(CGF.SizeTy, Alignment);
2066 Value *ScalarExprEmitter::VisitUnaryReal(
const UnaryOperator *E) {
2073 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
2077 return CGF.EmitComplexExpr(Op,
false,
true).first;
2083 Value *ScalarExprEmitter::VisitUnaryImag(
const UnaryOperator *E) {
2090 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
2094 return CGF.EmitComplexExpr(Op,
true,
false).second;
2102 CGF.EmitScalarExpr(Op,
true);
2103 return llvm::Constant::getNullValue(ConvertType(E->
getType()));
2110 BinOpInfo ScalarExprEmitter::EmitBinOps(
const BinaryOperator *E) {
2111 TestAndClearIgnoreResultAssign();
2113 Result.LHS = Visit(E->
getLHS());
2114 Result.RHS = Visit(E->
getRHS());
2122 LValue ScalarExprEmitter::EmitCompoundAssignLValue(
2124 Value *(ScalarExprEmitter::*Func)(
const BinOpInfo &),
2130 return CGF.EmitScalarCompoundAssignWithComplex(E, Result);
2134 OpInfo.RHS = Visit(E->
getRHS());
2137 OpInfo.FPContractable =
false;
2142 llvm::PHINode *atomicPHI =
nullptr;
2144 QualType type = atomicTy->getValueType();
2147 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
2148 CGF.getLangOpts().getSignedOverflowBehavior() !=
2150 llvm::AtomicRMWInst::BinOp aop = llvm::AtomicRMWInst::BAD_BINOP;
2151 switch (OpInfo.Opcode) {
2159 aop = llvm::AtomicRMWInst::Add;
2162 aop = llvm::AtomicRMWInst::Sub;
2168 aop = llvm::AtomicRMWInst::Xor;
2171 aop = llvm::AtomicRMWInst::Or;
2174 llvm_unreachable(
"Invalid compound assignment type");
2176 if (aop != llvm::AtomicRMWInst::BAD_BINOP) {
2177 llvm::Value *amt = CGF.EmitToMemory(EmitScalarConversion(OpInfo.RHS,
2180 llvm::SequentiallyConsistent);
2186 llvm::BasicBlock *startBB =
Builder.GetInsertBlock();
2187 llvm::BasicBlock *opBB = CGF.createBasicBlock(
"atomic_op", CGF.CurFn);
2188 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->
getExprLoc());
2189 OpInfo.LHS = CGF.EmitToMemory(OpInfo.LHS, type);
2192 atomicPHI =
Builder.CreatePHI(OpInfo.LHS->getType(), 2);
2193 atomicPHI->addIncoming(OpInfo.LHS, startBB);
2194 OpInfo.LHS = atomicPHI;
2197 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->
getExprLoc());
2199 OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy,
2203 Result = (this->*Func)(OpInfo);
2209 llvm::BasicBlock *opBB =
Builder.GetInsertBlock();
2210 llvm::BasicBlock *contBB = CGF.createBasicBlock(
"atomic_cont", CGF.CurFn);
2211 auto Pair = CGF.EmitAtomicCompareExchange(
2213 llvm::Value *old = CGF.EmitToMemory(Pair.first.getScalarVal(), LHSTy);
2215 atomicPHI->addIncoming(old, opBB);
2216 Builder.CreateCondBr(success, contBB, opBB);
2217 Builder.SetInsertPoint(contBB);
2226 CGF.EmitStoreThroughBitfieldLValue(
RValue::get(Result), LHSLV, &Result);
2228 CGF.EmitStoreThroughLValue(
RValue::get(Result), LHSLV);
2234 Value *(ScalarExprEmitter::*Func)(
const BinOpInfo &)) {
2235 bool Ignore = TestAndClearIgnoreResultAssign();
2237 LValue LHS = EmitCompoundAssignLValue(E, Func, RHS);
2244 if (!CGF.getLangOpts().CPlusPlus)
2252 return EmitLoadOfLValue(LHS, E->
getExprLoc());
2255 void ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck(
2256 const BinOpInfo &Ops,
llvm::Value *Zero,
bool isDiv) {
2259 if (CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero)) {
2260 Checks.push_back(std::make_pair(
Builder.CreateICmpNE(Ops.RHS, Zero),
2261 SanitizerKind::IntegerDivideByZero));
2264 if (CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow) &&
2265 Ops.Ty->hasSignedIntegerRepresentation()) {
2266 llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType());
2269 Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
2270 llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL);
2276 std::make_pair(NotOverflow, SanitizerKind::SignedIntegerOverflow));
2279 if (Checks.size() > 0)
2280 EmitBinOpCheck(Checks, Ops);
2283 Value *ScalarExprEmitter::EmitDiv(
const BinOpInfo &Ops) {
2286 if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
2287 CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
2288 Ops.Ty->isIntegerType()) {
2289 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
2290 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero,
true);
2291 }
else if (CGF.SanOpts.has(SanitizerKind::FloatDivideByZero) &&
2292 Ops.Ty->isRealFloatingType()) {
2293 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
2295 EmitBinOpCheck(std::make_pair(NonZero, SanitizerKind::FloatDivideByZero),
2300 if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
2302 if (CGF.getLangOpts().OpenCL) {
2304 llvm::Type *ValTy = Val->getType();
2305 if (ValTy->isFloatTy() ||
2306 (isa<llvm::VectorType>(ValTy) &&
2307 cast<llvm::VectorType>(ValTy)->getElementType()->isFloatTy()))
2308 CGF.SetFPAccuracy(Val, 2.5);
2312 else if (Ops.Ty->hasUnsignedIntegerRepresentation())
2313 return Builder.CreateUDiv(Ops.LHS, Ops.RHS,
"div");
2315 return Builder.CreateSDiv(Ops.LHS, Ops.RHS,
"div");
2318 Value *ScalarExprEmitter::EmitRem(
const BinOpInfo &Ops) {
2320 if (CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero)) {
2322 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
2324 if (Ops.Ty->isIntegerType())
2325 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero,
false);
2328 if (Ops.Ty->hasUnsignedIntegerRepresentation())
2329 return Builder.CreateURem(Ops.LHS, Ops.RHS,
"rem");
2331 return Builder.CreateSRem(Ops.LHS, Ops.RHS,
"rem");
2334 Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(
const BinOpInfo &Ops) {
2338 bool isSigned = Ops.Ty->isSignedIntegerOrEnumerationType();
2339 switch (Ops.Opcode) {
2343 IID = isSigned ? llvm::Intrinsic::sadd_with_overflow :
2344 llvm::Intrinsic::uadd_with_overflow;
2349 IID = isSigned ? llvm::Intrinsic::ssub_with_overflow :
2350 llvm::Intrinsic::usub_with_overflow;
2355 IID = isSigned ? llvm::Intrinsic::smul_with_overflow :
2356 llvm::Intrinsic::umul_with_overflow;
2359 llvm_unreachable(
"Unsupported operation for overflow detection");
2365 llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
2367 llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy);
2369 Value *resultAndOverflow =
Builder.CreateCall(intrinsic, {Ops.LHS, Ops.RHS});
2370 Value *result =
Builder.CreateExtractValue(resultAndOverflow, 0);
2371 Value *overflow =
Builder.CreateExtractValue(resultAndOverflow, 1);
2374 const std::string *handlerName =
2375 &CGF.getLangOpts().OverflowHandler;
2376 if (handlerName->empty()) {
2379 if (!isSigned || CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) {
2382 SanitizerMask Kind = isSigned ? SanitizerKind::SignedIntegerOverflow
2383 : SanitizerKind::UnsignedIntegerOverflow;
2384 EmitBinOpCheck(std::make_pair(NotOverflow, Kind), Ops);
2386 CGF.EmitTrapCheck(
Builder.CreateNot(overflow));
2391 llvm::BasicBlock *initialBB =
Builder.GetInsertBlock();
2392 llvm::Function::iterator insertPt = initialBB;
2393 llvm::BasicBlock *continueBB = CGF.createBasicBlock(
"nooverflow", CGF.CurFn,
2394 std::next(insertPt));
2395 llvm::BasicBlock *overflowBB = CGF.createBasicBlock(
"overflow", CGF.CurFn);
2397 Builder.CreateCondBr(overflow, overflowBB, continueBB);
2401 Builder.SetInsertPoint(overflowBB);
2404 llvm::Type *Int8Ty = CGF.Int8Ty;
2405 llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty };
2406 llvm::FunctionType *handlerTy =
2407 llvm::FunctionType::get(CGF.Int64Ty, argTypes,
true);
2408 llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName);
2421 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())
2424 CGF.EmitNounwindRuntimeCall(handler, handlerArgs);
2427 handlerResult =
Builder.CreateTrunc(handlerResult, opTy);
2430 Builder.SetInsertPoint(continueBB);
2431 llvm::PHINode *phi =
Builder.CreatePHI(opTy, 2);
2432 phi->addIncoming(result, initialBB);
2433 phi->addIncoming(handlerResult, overflowBB);
2440 const BinOpInfo &op,
2441 bool isSubtraction) {
2446 Value *pointer = op.LHS;
2448 Value *index = op.RHS;
2452 if (!isSubtraction && !pointer->getType()->isPointerTy()) {
2453 std::swap(pointer, index);
2454 std::swap(pointerOperand, indexOperand);
2457 unsigned width = cast<llvm::IntegerType>(index->getType())->getBitWidth();
2468 index = CGF.
Builder.CreateNeg(index,
"idx.neg");
2470 if (CGF.
SanOpts.
has(SanitizerKind::ArrayBounds))
2483 index = CGF.
Builder.CreateMul(index, objectSize);
2486 result = CGF.
Builder.CreateGEP(result, index,
"add.ptr");
2487 return CGF.
Builder.CreateBitCast(result, pointer->getType());
2501 index = CGF.
Builder.CreateMul(index, numElements,
"vla.index");
2502 pointer = CGF.
Builder.CreateGEP(pointer, index,
"add.ptr");
2504 index = CGF.
Builder.CreateNSWMul(index, numElements,
"vla.index");
2505 pointer = CGF.
Builder.CreateInBoundsGEP(pointer, index,
"add.ptr");
2515 result = CGF.
Builder.CreateGEP(result, index,
"add.ptr");
2516 return CGF.
Builder.CreateBitCast(result, pointer->getType());
2520 return CGF.
Builder.CreateGEP(pointer, index,
"add.ptr");
2522 return CGF.
Builder.CreateInBoundsGEP(pointer, index,
"add.ptr");
2532 bool negMul,
bool negAdd) {
2533 assert(!(negMul && negAdd) &&
"Only one of negMul and negAdd should be set.");
2535 Value *MulOp0 = MulOp->getOperand(0);
2536 Value *MulOp1 = MulOp->getOperand(1);
2540 llvm::ConstantFP::getZeroValueForNegation(MulOp0->getType()), MulOp0,
2542 }
else if (negAdd) {
2545 llvm::ConstantFP::getZeroValueForNegation(Addend->getType()), Addend,
2549 Value *FMulAdd = Builder.CreateCall(
2551 {MulOp0, MulOp1, Addend});
2552 MulOp->eraseFromParent();
2569 "Only fadd/fsub can be the root of an fmuladd.");
2572 if (!op.FPContractable)
2581 if (llvm::BinaryOperator* LHSBinOp = dyn_cast<llvm::BinaryOperator>(op.LHS)) {
2582 if (LHSBinOp->getOpcode() == llvm::Instruction::FMul) {
2583 assert(LHSBinOp->getNumUses() == 0 &&
2584 "Operations with multiple uses shouldn't be contracted.");
2585 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder,
false, isSub);
2587 }
else if (llvm::BinaryOperator* RHSBinOp =
2588 dyn_cast<llvm::BinaryOperator>(op.RHS)) {
2589 if (RHSBinOp->getOpcode() == llvm::Instruction::FMul) {
2590 assert(RHSBinOp->getNumUses() == 0 &&
2591 "Operations with multiple uses shouldn't be contracted.");
2592 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub,
false);
2599 Value *ScalarExprEmitter::EmitAdd(
const BinOpInfo &op) {
2600 if (op.LHS->getType()->isPointerTy() ||
2601 op.RHS->getType()->isPointerTy())
2604 if (op.Ty->isSignedIntegerOrEnumerationType()) {
2605 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
2607 return Builder.CreateAdd(op.LHS, op.RHS,
"add");
2609 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
2610 return Builder.CreateNSWAdd(op.LHS, op.RHS,
"add");
2613 return EmitOverflowCheckedBinOp(op);
2617 if (op.Ty->isUnsignedIntegerType() &&
2618 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow))
2619 return EmitOverflowCheckedBinOp(op);
2621 if (op.LHS->getType()->isFPOrFPVectorTy()) {
2626 return Builder.CreateFAdd(op.LHS, op.RHS,
"add");
2629 return Builder.CreateAdd(op.LHS, op.RHS,
"add");
2632 Value *ScalarExprEmitter::EmitSub(
const BinOpInfo &op) {
2634 if (!op.LHS->getType()->isPointerTy()) {
2635 if (op.Ty->isSignedIntegerOrEnumerationType()) {
2636 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
2638 return Builder.CreateSub(op.LHS, op.RHS,
"sub");
2640 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
2641 return Builder.CreateNSWSub(op.LHS, op.RHS,
"sub");
2644 return EmitOverflowCheckedBinOp(op);
2648 if (op.Ty->isUnsignedIntegerType() &&
2649 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow))
2650 return EmitOverflowCheckedBinOp(op);
2652 if (op.LHS->getType()->isFPOrFPVectorTy()) {
2656 return Builder.CreateFSub(op.LHS, op.RHS,
"sub");
2659 return Builder.CreateSub(op.LHS, op.RHS,
"sub");
2664 if (!op.RHS->getType()->isPointerTy())
2671 =
Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy,
"sub.ptr.lhs.cast");
2673 =
Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy,
"sub.ptr.rhs.cast");
2674 Value *diffInChars =
Builder.CreateSub(LHS, RHS,
"sub.ptr.sub");
2684 = CGF.getContext().getAsVariableArrayType(elementType)) {
2686 std::tie(numElements, elementType) = CGF.getVLASize(vla);
2688 divisor = numElements;
2691 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType);
2692 if (!eltSize.
isOne())
2693 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
2702 if (elementType->isVoidType() || elementType->isFunctionType())
2705 elementSize = CGF.getContext().getTypeSizeInChars(elementType);
2708 if (elementSize.
isOne())
2711 divisor = CGF.CGM.getSize(elementSize);
2717 return Builder.CreateExactSDiv(diffInChars, divisor,
"sub.ptr.div");
2720 Value *ScalarExprEmitter::GetWidthMinusOneValue(Value* LHS,Value* RHS) {
2721 llvm::IntegerType *Ty;
2722 if (llvm::VectorType *VT = dyn_cast<llvm::VectorType>(LHS->getType()))
2723 Ty = cast<llvm::IntegerType>(VT->getElementType());
2725 Ty = cast<llvm::IntegerType>(LHS->getType());
2726 return llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth() - 1);
2729 Value *ScalarExprEmitter::EmitShl(
const BinOpInfo &Ops) {
2732 Value *RHS = Ops.RHS;
2733 if (Ops.LHS->getType() != RHS->getType())
2734 RHS =
Builder.CreateIntCast(RHS, Ops.LHS->getType(),
false,
"sh_prom");
2736 bool SanitizeBase = CGF.SanOpts.has(SanitizerKind::ShiftBase) &&
2737 Ops.Ty->hasSignedIntegerRepresentation();
2738 bool SanitizeExponent = CGF.SanOpts.has(SanitizerKind::ShiftExponent);
2740 if (CGF.getLangOpts().OpenCL)
2742 Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS),
"shl.mask");
2743 else if ((SanitizeBase || SanitizeExponent) &&
2744 isa<llvm::IntegerType>(Ops.LHS->getType())) {
2747 llvm::Value *WidthMinusOne = GetWidthMinusOneValue(Ops.LHS, RHS);
2750 if (SanitizeExponent) {
2752 std::make_pair(ValidExponent, SanitizerKind::ShiftExponent));
2759 llvm::BasicBlock *Orig =
Builder.GetInsertBlock();
2760 llvm::BasicBlock *Cont = CGF.createBasicBlock(
"cont");
2761 llvm::BasicBlock *CheckShiftBase = CGF.createBasicBlock(
"check");
2762 Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);
2763 CGF.EmitBlock(CheckShiftBase);
2766 Builder.CreateSub(WidthMinusOne, RHS,
"shl.zeros",
2769 if (CGF.getLangOpts().CPlusPlus) {
2774 llvm::Value *One = llvm::ConstantInt::get(BitsShiftedOff->getType(), 1);
2775 BitsShiftedOff =
Builder.CreateLShr(BitsShiftedOff, One);
2777 llvm::Value *Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0);
2779 CGF.EmitBlock(Cont);
2780 llvm::PHINode *BaseCheck =
Builder.CreatePHI(ValidBase->getType(), 2);
2781 BaseCheck->addIncoming(
Builder.getTrue(), Orig);
2782 BaseCheck->addIncoming(ValidBase, CheckShiftBase);
2783 Checks.push_back(std::make_pair(BaseCheck, SanitizerKind::ShiftBase));
2786 assert(!Checks.empty());
2787 EmitBinOpCheck(Checks, Ops);
2790 return Builder.CreateShl(Ops.LHS, RHS,
"shl");
2793 Value *ScalarExprEmitter::EmitShr(
const BinOpInfo &Ops) {
2796 Value *RHS = Ops.RHS;
2797 if (Ops.LHS->getType() != RHS->getType())
2798 RHS =
Builder.CreateIntCast(RHS, Ops.LHS->getType(),
false,
"sh_prom");
2801 if (CGF.getLangOpts().OpenCL)
2803 Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS),
"shr.mask");
2804 else if (CGF.SanOpts.has(SanitizerKind::ShiftExponent) &&
2805 isa<llvm::IntegerType>(Ops.LHS->getType())) {
2808 Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS));
2809 EmitBinOpCheck(std::make_pair(Valid, SanitizerKind::ShiftExponent), Ops);
2812 if (Ops.Ty->hasUnsignedIntegerRepresentation())
2813 return Builder.CreateLShr(Ops.LHS, RHS,
"shr");
2814 return Builder.CreateAShr(Ops.LHS, RHS,
"shr");
2822 default: llvm_unreachable(
"unexpected element type");
2823 case BuiltinType::Char_U:
2824 case BuiltinType::UChar:
2825 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
2826 llvm::Intrinsic::ppc_altivec_vcmpgtub_p;
2827 case BuiltinType::Char_S:
2828 case BuiltinType::SChar:
2829 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
2830 llvm::Intrinsic::ppc_altivec_vcmpgtsb_p;
2831 case BuiltinType::UShort:
2832 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
2833 llvm::Intrinsic::ppc_altivec_vcmpgtuh_p;
2834 case BuiltinType::Short:
2835 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
2836 llvm::Intrinsic::ppc_altivec_vcmpgtsh_p;
2837 case BuiltinType::UInt:
2838 case BuiltinType::ULong:
2839 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
2840 llvm::Intrinsic::ppc_altivec_vcmpgtuw_p;
2841 case BuiltinType::Int:
2842 case BuiltinType::Long:
2843 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
2844 llvm::Intrinsic::ppc_altivec_vcmpgtsw_p;
2845 case BuiltinType::Float:
2846 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p :
2847 llvm::Intrinsic::ppc_altivec_vcmpgtfp_p;
2851 Value *ScalarExprEmitter::EmitCompare(
const BinaryOperator *E,
unsigned UICmpOpc,
2852 unsigned SICmpOpc,
unsigned FCmpOpc) {
2853 TestAndClearIgnoreResultAssign();
2860 Value *LHS = CGF.EmitScalarExpr(E->
getLHS());
2861 Value *RHS = CGF.EmitScalarExpr(E->
getRHS());
2862 Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison(
2865 Value *LHS = Visit(E->
getLHS());
2866 Value *RHS = Visit(E->
getRHS());
2872 enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6;
2877 Value *FirstVecArg = LHS,
2878 *SecondVecArg = RHS;
2885 default: llvm_unreachable(
"is not a comparison operation");
2897 std::swap(FirstVecArg, SecondVecArg);
2904 if (ElementKind == BuiltinType::Float) {
2906 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
2907 std::swap(FirstVecArg, SecondVecArg);
2915 if (ElementKind == BuiltinType::Float) {
2917 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
2922 std::swap(FirstVecArg, SecondVecArg);
2927 Value *CR6Param =
Builder.getInt32(CR6);
2928 llvm::Function *F = CGF.CGM.getIntrinsic(ID);
2929 Result =
Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg});
2930 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->
getType());
2933 if (LHS->getType()->isFPOrFPVectorTy()) {
2934 Result =
Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc,
2937 Result =
Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc,
2941 Result =
Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
2948 return Builder.CreateSExt(Result, ConvertType(E->
getType()),
"sext");
2955 LHS = CGF.EmitComplexExpr(E->
getLHS());
2956 CETy = CTy->getElementType();
2958 LHS.first = Visit(E->
getLHS());
2959 LHS.second = llvm::Constant::getNullValue(LHS.first->getType());
2963 RHS = CGF.EmitComplexExpr(E->
getRHS());
2964 assert(CGF.getContext().hasSameUnqualifiedType(CETy,
2965 CTy->getElementType()) &&
2966 "The element types must always match.");
2969 RHS.first = Visit(E->
getRHS());
2970 RHS.second = llvm::Constant::getNullValue(RHS.first->getType());
2971 assert(CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) &&
2972 "The element types must always match.");
2975 Value *ResultR, *ResultI;
2977 ResultR =
Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
2978 LHS.first, RHS.first,
"cmp.r");
2979 ResultI =
Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
2980 LHS.second, RHS.second,
"cmp.i");
2984 ResultR =
Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
2985 LHS.first, RHS.first,
"cmp.r");
2986 ResultI =
Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
2987 LHS.second, RHS.second,
"cmp.i");
2991 Result =
Builder.CreateAnd(ResultR, ResultI,
"and.ri");
2994 "Complex comparison other than == or != ?");
2995 Result =
Builder.CreateOr(ResultR, ResultI,
"or.ri");
2999 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->
getType());
3002 Value *ScalarExprEmitter::VisitBinAssign(
const BinaryOperator *E) {
3003 bool Ignore = TestAndClearIgnoreResultAssign();
3010 std::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
3014 std::tie(LHS, RHS) = CGF.EmitARCStoreAutoreleasing(E);
3018 RHS = Visit(E->
getRHS());
3020 RHS = CGF.EmitARCStoreWeak(LHS.getAddress(), RHS, Ignore);
3028 RHS = Visit(E->
getRHS());
3035 if (LHS.isBitField())
3036 CGF.EmitStoreThroughBitfieldLValue(
RValue::get(RHS), LHS, &RHS);
3038 CGF.EmitStoreThroughLValue(
RValue::get(RHS), LHS);
3046 if (!CGF.getLangOpts().CPlusPlus)
3050 if (!LHS.isVolatileQualified())
3054 return EmitLoadOfLValue(LHS, E->
getExprLoc());
3057 Value *ScalarExprEmitter::VisitBinLAnd(
const BinaryOperator *E) {
3060 CGF.incrementProfileCounter(E);
3062 Value *LHS = Visit(E->
getLHS());
3063 Value *RHS = Visit(E->
getRHS());
3064 Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
3065 if (LHS->getType()->isFPOrFPVectorTy()) {
3066 LHS =
Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero,
"cmp");
3067 RHS =
Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero,
"cmp");
3069 LHS =
Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero,
"cmp");
3070 RHS =
Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero,
"cmp");
3073 return Builder.CreateSExt(And, ConvertType(E->
getType()),
"sext");
3076 llvm::Type *ResTy = ConvertType(E->
getType());
3081 if (CGF.ConstantFoldsToSimpleInteger(E->
getLHS(), LHSCondVal)) {
3083 CGF.incrementProfileCounter(E);
3085 Value *RHSCond = CGF.EvaluateExprAsBool(E->
getRHS());
3087 return Builder.CreateZExtOrBitCast(RHSCond, ResTy,
"land.ext");
3091 if (!CGF.ContainsLabel(E->
getRHS()))
3092 return llvm::Constant::getNullValue(ResTy);
3095 llvm::BasicBlock *ContBlock = CGF.createBasicBlock(
"land.end");
3096 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock(
"land.rhs");
3101 CGF.EmitBranchOnBoolExpr(E->
getLHS(), RHSBlock, ContBlock,
3102 CGF.getProfileCount(E->
getRHS()));
3109 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
3111 PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI);
3114 CGF.EmitBlock(RHSBlock);
3115 CGF.incrementProfileCounter(E);
3116 Value *RHSCond = CGF.EvaluateExprAsBool(E->
getRHS());
3120 RHSBlock =
Builder.GetInsertBlock();
3126 CGF.EmitBlock(ContBlock);
3129 PN->addIncoming(RHSCond, RHSBlock);
3132 return Builder.CreateZExtOrBitCast(PN, ResTy,
"land.ext");
3138 CGF.incrementProfileCounter(E);
3140 Value *LHS = Visit(E->
getLHS());
3141 Value *RHS = Visit(E->
getRHS());
3142 Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
3143 if (LHS->getType()->isFPOrFPVectorTy()) {
3144 LHS =
Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero,
"cmp");
3145 RHS =
Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero,
"cmp");
3147 LHS =
Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero,
"cmp");
3148 RHS =
Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero,
"cmp");
3150 Value *Or =
Builder.CreateOr(LHS, RHS);
3151 return Builder.CreateSExt(Or, ConvertType(E->
getType()),
"sext");
3154 llvm::Type *ResTy = ConvertType(E->
getType());
3159 if (CGF.ConstantFoldsToSimpleInteger(E->
getLHS(), LHSCondVal)) {
3161 CGF.incrementProfileCounter(E);
3163 Value *RHSCond = CGF.EvaluateExprAsBool(E->
getRHS());
3165 return Builder.CreateZExtOrBitCast(RHSCond, ResTy,
"lor.ext");
3169 if (!CGF.ContainsLabel(E->
getRHS()))
3170 return llvm::ConstantInt::get(ResTy, 1);
3173 llvm::BasicBlock *ContBlock = CGF.createBasicBlock(
"lor.end");
3174 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock(
"lor.rhs");
3179 CGF.EmitBranchOnBoolExpr(E->
getLHS(), ContBlock, RHSBlock,
3180 CGF.getCurrentProfileCount() -
3181 CGF.getProfileCount(E->
getRHS()));
3188 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
3190 PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI);
3195 CGF.EmitBlock(RHSBlock);
3196 CGF.incrementProfileCounter(E);
3197 Value *RHSCond = CGF.EvaluateExprAsBool(E->
getRHS());
3202 RHSBlock =
Builder.GetInsertBlock();
3206 CGF.EmitBlock(ContBlock);
3207 PN->addIncoming(RHSCond, RHSBlock);
3210 return Builder.CreateZExtOrBitCast(PN, ResTy,
"lor.ext");
3213 Value *ScalarExprEmitter::VisitBinComma(
const BinaryOperator *E) {
3214 CGF.EmitIgnoredExpr(E->
getLHS());
3215 CGF.EnsureInsertPoint();
3216 return Visit(E->
getRHS());
3241 Value *ScalarExprEmitter::
3243 TestAndClearIgnoreResultAssign();
3255 if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
3256 Expr *live = lhsExpr, *dead = rhsExpr;
3257 if (!CondExprBool) std::swap(live, dead);
3260 if (!CGF.ContainsLabel(dead)) {
3262 CGF.incrementProfileCounter(E);
3263 Value *Result = Visit(live);
3269 Result = llvm::UndefValue::get(CGF.ConvertType(E->
getType()));
3277 if (CGF.getLangOpts().OpenCL
3279 CGF.incrementProfileCounter(E);
3281 llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
3285 llvm::Type *condType = ConvertType(condExpr->
getType());
3286 llvm::VectorType *vecTy = cast<llvm::VectorType>(condType);
3288 unsigned numElem = vecTy->getNumElements();
3289 llvm::Type *elemType = vecTy->getElementType();
3291 llvm::Value *zeroVec = llvm::Constant::getNullValue(vecTy);
3294 llvm::VectorType::get(elemType,
3302 bool wasCast =
false;
3303 llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType());
3304 if (rhsVTy->getElementType()->isFloatingPointTy()) {
3305 RHSTmp =
Builder.CreateBitCast(RHS, tmp2->getType());
3306 LHSTmp =
Builder.CreateBitCast(LHS, tmp->getType());
3314 tmp5 =
Builder.CreateBitCast(tmp5, RHS->getType());
3324 CGF.incrementProfileCounter(E);
3326 llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr);
3331 assert(!RHS &&
"LHS and RHS types must match");
3334 return Builder.CreateSelect(CondV, LHS, RHS,
"cond");
3337 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock(
"cond.true");
3338 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock(
"cond.false");
3339 llvm::BasicBlock *ContBlock = CGF.createBasicBlock(
"cond.end");
3342 CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock,
3343 CGF.getProfileCount(lhsExpr));
3345 CGF.EmitBlock(LHSBlock);
3346 CGF.incrementProfileCounter(E);
3348 Value *LHS = Visit(lhsExpr);
3351 LHSBlock =
Builder.GetInsertBlock();
3354 CGF.EmitBlock(RHSBlock);
3356 Value *RHS = Visit(rhsExpr);
3359 RHSBlock =
Builder.GetInsertBlock();
3360 CGF.EmitBlock(ContBlock);
3369 llvm::PHINode *PN =
Builder.CreatePHI(LHS->getType(), 2,
"cond");
3370 PN->addIncoming(LHS, LHSBlock);
3371 PN->addIncoming(RHS, RHSBlock);
3375 Value *ScalarExprEmitter::VisitChooseExpr(
ChooseExpr *E) {
3379 Value *ScalarExprEmitter::VisitVAArgExpr(
VAArgExpr *VE) {
3383 CGF.EmitVariablyModifiedType(Ty);
3387 llvm::Type *ArgTy = ConvertType(VE->
getType());
3391 return Builder.CreateVAArg(ArgValue, ArgTy);
3397 if (ArgTy != Val->getType()) {
3398 if (ArgTy->isPointerTy() && !Val->getType()->isPointerTy())
3399 Val =
Builder.CreateIntToPtr(Val, ArgTy);
3401 Val =
Builder.CreateTrunc(Val, ArgTy);
3407 Value *ScalarExprEmitter::VisitBlockExpr(
const BlockExpr *block) {
3408 return CGF.EmitBlockLiteral(block);
3411 Value *ScalarExprEmitter::VisitAsTypeExpr(
AsTypeExpr *E) {
3412 Value *Src = CGF.EmitScalarExpr(E->
getSrcExpr());
3413 llvm::Type *DstTy = ConvertType(E->
getType());
3417 llvm::Type *SrcTy = Src->getType();
3418 if (isa<llvm::VectorType>(DstTy) && isa<llvm::VectorType>(SrcTy)) {
3419 unsigned numElementsDst = cast<llvm::VectorType>(DstTy)->getNumElements();
3420 unsigned numElementsSrc = cast<llvm::VectorType>(SrcTy)->getNumElements();
3421 if ((numElementsDst == 3 && numElementsSrc == 4)
3422 || (numElementsDst == 4 && numElementsSrc == 3)) {
3427 llvm::Type *srcElemTy =
3429 llvm::Type *dstElemTy =
3432 if ((srcElemTy->isIntegerTy() && dstElemTy->isFloatTy())
3433 || (srcElemTy->isFloatTy() && dstElemTy->isIntegerTy())) {
3435 llvm::VectorType *newSrcTy = llvm::VectorType::get(dstElemTy,
3438 Src =
Builder.CreateBitCast(Src, newSrcTy,
"astypeCast");
3441 llvm::Value *UnV = llvm::UndefValue::get(Src->getType());
3444 Args.push_back(
Builder.getInt32(0));
3445 Args.push_back(
Builder.getInt32(1));
3446 Args.push_back(
Builder.getInt32(2));
3448 if (numElementsDst == 4)
3449 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty));
3451 llvm::Constant *Mask = llvm::ConstantVector::get(Args);
3453 return Builder.CreateShuffleVector(Src, UnV, Mask,
"astype");
3457 return Builder.CreateBitCast(Src, DstTy,
"astype");
3460 Value *ScalarExprEmitter::VisitAtomicExpr(
AtomicExpr *E) {
3461 return CGF.EmitAtomicExpr(E).getScalarVal();
3472 "Invalid scalar expression to emit");
3474 return ScalarExprEmitter(*
this, IgnoreResultAssign)
3475 .Visit(const_cast<Expr *>(E));
3483 "Invalid scalar expression to emit");
3484 return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy);
3494 "Invalid complex -> scalar conversion");
3495 return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy,
3502 bool isInc,
bool isPre) {
3503 return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre);
3514 if (BaseExpr->isRValue()) {
3518 V = ScalarExprEmitter(*this).EmitLoadOfLValue(
3522 V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr);
3528 ClassPtrTy = ClassPtrTy->getPointerTo();
3529 V =
Builder.CreateBitCast(V, ClassPtrTy);
3536 ScalarExprEmitter Scalar(*
this);
3537 Value *Result =
nullptr;
3539 #define COMPOUND_OP(Op) \
3540 case BO_##Op##Assign: \
3541 return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \
3577 llvm_unreachable(
"Not valid compound assignment operators");
3580 llvm_unreachable(
"Unhandled compound assignment operator");
Defines the clang::ASTContext interface.
unsigned getNumInits() const
CastKind getCastKind() const
The null pointer literal (C++11 [lex.nullptr])
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
static BinOpInfo createBinOpInfoFromIncDec(const UnaryOperator *E, llvm::Value *InVal, bool IsInc)
bool isNullPtrType() const
bool isSignedOverflowDefined() const
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
bool isEvaluatable(const ASTContext &Ctx) const
unsigned getFieldCount() const
getFieldCount - Get the number of fields in the layout.
static Opcode getOpForCompoundAssignment(Opcode Opc)
QualType getType() const
Retrieves the type of the base class.
Expr * getExpr(unsigned Index)
getExpr - Return the Expr at the specified index.
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
CompoundStmt * getSubStmt()
LValue EmitObjCIsaExpr(const ObjCIsaExpr *E)
bool isOne() const
isOne - Test whether the quantity equals one.
static llvm::Constant * getAsInt32(llvm::ConstantInt *C, llvm::Type *I32Ty)
bool isArgumentType() const
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
TypeSourceInfo * getTypeSourceInfo() const
unsigned getPackLength() const
Retrieve the length of the parameter pack.
const Expr * getResultExpr() const
const ObjCObjectType * getObjectType() const
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
bool isBooleanType() const
const LangOptions & getLangOpts() const
[ARC] Consumes a retainable object pointer that has just been produced, e.g. as the return value of a...
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
static Value * buildFMulAdd(llvm::BinaryOperator *MulOp, Value *Addend, const CodeGenFunction &CGF, CGBuilderTy &Builder, bool negMul, bool negAdd)
llvm::Value * getAddress() const
Expr * getIndexExpr(unsigned Idx)
bool hadArrayRangeDesignator() const
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
field_iterator field_begin() const
CK_Dynamic - A C++ dynamic_cast.
UnaryExprOrTypeTrait getKind() const
An implicit indirection through a C++ base class, when the field found is in a base class...
unsigned getValue() const
A C++ throw-expression (C++ [except.throw]).
void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index, QualType IndexType, bool Accessed)
Emit a check that Base points into an array object, which we can access at index Index. Accessed should be false if we this expression is used as an lvalue, for instance in "&Arr[Idx]".
An object to manage conditionally-evaluated expressions.
llvm::Value * EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
bool isVolatileQualified() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Converts between different integral complex types. _Complex char -> _Complex long long _Complex unsig...
bool isReferenceType() const
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
Converting between two Objective-C object types, which can occur when performing reference binding to...
const CXXRecordDecl * getPointeeCXXRecordDecl() const
[ARC] Causes a value of block type to be copied to the heap, if it is not already there...
llvm::APSInt getShuffleMaskIdx(const ASTContext &Ctx, unsigned N) const
llvm::Value * EmitScalarConversion(llvm::Value *Src, QualType SrcTy, QualType DstTy)
bool isFPContractable() const
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Converts a floating point complex to bool by comparing against 0+0i.
Describes an C or C++ initializer list.
Expr * getChosenSubExpr() const
static bool hasScalarEvaluationKind(QualType T)
CharUnits getAlignment() const
Expr * getTrueExpr() const
path_iterator path_begin()
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
llvm::PointerType * VoidPtrTy
const Expr * getSubExpr() const
A builtin binary operation expression such as "x + y" or "x <= y".
RecordDecl * getDecl() const
bool isUnsignedIntegerType() const
static Value * tryEmitFMulAdd(const BinOpInfo &op, const CodeGenFunction &CGF, CGBuilderTy &Builder, bool isSub=false)
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep)
Creates clause with a list of variables VL and a linear step Step.
static llvm::Constant * getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, unsigned Off, llvm::Type *I32Ty)
uint64_t getFieldOffset(unsigned FieldNo) const
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
bool isExtVectorType() const
A default argument (C++ [dcl.fct.default]).
Checking the operand of a load. Must be suitably sized and aligned.
Represents the this expression in C++.
field_iterator field_end() const
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
Sema - This implements semantic analysis and AST building for C.
static CharUnits One()
One - Construct a CharUnits quantity of one.
llvm::APInt getValue() const
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
Qualifiers::ObjCLifetime getObjCLifetime() const
getObjCLifetime - Returns lifetime attribute of this type.
Causes a block literal to by copied to the heap and then autoreleased.
CastKind
CastKind - The kind of operation required for a conversion.
A field in a dependent type, known only by its name.
const Expr * getExpr() const
Get the initialization expression that will be used.
VAArgExpr, used for the builtin function __builtin_va_arg.
ID
Defines the set of possible language-specific address spaces.
QualType getPointeeType() const
Converts between different floating point complex types. _Complex float -> _Complex double...
bool isRealFloatingType() const
Floating point categories.
const ObjCMethodDecl * getMethodDecl() const
bool isSignedIntegerOrEnumerationType() const
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
Converts an integral complex to an integral real of the source's element type by discarding the imagi...
bool isAnyComplexType() const
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
SourceLocation getExprLoc() const LLVM_READONLY
bool isVariableArrayType() const
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
bool isFloatingType() const
ObjCSelectorExpr used for @selector in Objective-C.
Represents an expression that computes the length of a parameter pack.
Expr * getSubExpr() const
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T)
An expression that sends a message to the given Objective-C object or class.
unsigned getNumComponents() const
Converts from an integral complex to a floating complex. _Complex unsigned -> _Complex float...
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=None)
Represents a reference to a non-type template parameter that has been substituted with a template arg...
QualType getComputationLHSType() const
The result type of a method or function.
bool isUnsignedIntegerOrEnumerationType() const
llvm::IRBuilder< PreserveNames, llvm::ConstantFolder, CGBuilderInserterTy > CGBuilderTy
QualType getComputationResultType() const
unsigned getNumSubExprs() const
There is no lifetime qualification on this type.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
ASTContext & getContext() const
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
SourceLocation getExprLoc() const LLVM_READONLY
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
bool isCompoundAssignmentOp() const
SanitizerSet SanOpts
Sanitizers enabled for this function.
const CodeGenOptions & getCodeGenOpts() const
TypeCheckKind
Situations in which we might emit a check for the suitability of a pointer or glvalue.
Converts from an integral real to an integral complex whose element type matches the source...
llvm::AllocaInst * CreateMemTemp(QualType T, const Twine &Name="tmp")
QualType getReturnType() const
bool isVectorType() const
An expression trait intrinsic.
uint64_t getValue() const
Assigning into this object requires a lifetime extension.
QualType getType() const
Return the type wrapped by this type source info.
const OffsetOfNode & getComponent(unsigned Idx) const
SourceLocation getExprLoc() const LLVM_READONLY
QualType getPointeeType() const
Represents a C11 generic selection.
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
QualType getCallReturnType(const ASTContext &Ctx) const
AddrLabelExpr - The GNU address of label extension, representing &&label.
Converts a floating point complex to floating point real of the source's element type. Just discards the imaginary component. _Complex long double -> long double.
Expr * getReplacement() const
SourceLocation getExprLoc() const LLVM_READONLY
static const Type * getElementType(const Expr *BaseExpr)
const Expr * getExpr() const
Represents a delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray"...
Converts an integral complex to bool by comparing against 0+0i.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
static llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT, BuiltinType::Kind ElemKind)
static Value * emitPointerArithmetic(CodeGenFunction &CGF, const BinOpInfo &op, bool isSubtraction)
Emit pointer + index arithmetic.
Kind getKind() const
Determine what kind of offsetof node this is.
Checking the destination of a store. Must be suitably sized and aligned.
A conversion of a floating point real to a floating point complex of the original type...
llvm::APFloat getValue() const
[ARC] Reclaim a retainable object pointer object that may have been produced and autoreleased as part...
const VariableArrayType * getAsVariableArrayType(QualType T) const
FieldDecl * getField() const
For a field offsetof node, returns the field.
QualType getNonReferenceType() const
#define VISITCOMP(CODE, UI, SI, FP)
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
llvm::Value * EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, QualType DstTy)
Expr * getFalseExpr() const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
QualType getTypeOfArgument() const
QualType getCanonicalType() const
[ARC] Produces a retainable object pointer so that it may be consumed, e.g. by being passed to a cons...
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
bool isFunctionType() const
Converts from T to _Atomic(T).
Converts from a floating complex to an integral complex. _Complex float -> _Complex int...
SourceLocation getExprLoc() const LLVM_READONLY
LabelDecl * getLabel() const
ObjCIvarRefExpr - A reference to an ObjC instance variable.
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
A use of a default initializer in a constructor or in aggregate initialization.
llvm::IntegerType * PtrDiffTy
Reading or writing from this object requires a barrier call.
const Expr * getSubExpr() const
Represents a C++ struct/union/class.
BoundNodesTreeBuilder *const Builder
llvm::Type * ConvertType(QualType T)
LValue EmitLValue(const Expr *E)
static bool ShouldNullCheckClassCastValue(const CastExpr *CE)
Converts from _Atomic(T) to T.
std::pair< llvm::Value *, QualType > getVLASize(const VariableArrayType *vla)
Defines the clang::TargetInfo interface.
LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E)
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
static RValue get(llvm::Value *V)
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
const Expr * getInit(unsigned Init) const
A boolean literal, per ([C++ lex.bool] Boolean literals).
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g., it is an signed integer type or a vector.
static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, CodeGenFunction &CGF)
Represents an implicitly-generated value initialization of an object of a given type.
bool isIntegerType() const
Expr * IgnoreParens() LLVM_READONLY