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;
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,
169 llvm::Value *Zero = llvm::Constant::getNullValue(V->getType());
170 return Builder.CreateFCmpUNE(V, Zero,
"tobool");
174 Value *EmitPointerToBoolConversion(
Value *V) {
175 Value *Zero = llvm::ConstantPointerNull::get(
176 cast<llvm::PointerType>(V->getType()));
177 return Builder.CreateICmpNE(V, Zero,
"tobool");
184 if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(V)) {
185 if (ZI->getOperand(0)->getType() ==
Builder.getInt1Ty()) {
191 ZI->eraseFromParent();
196 return Builder.CreateIsNotNull(V,
"tobool");
209 S->dump(CGF.getContext().getSourceManager());
210 llvm_unreachable(
"Stmt can't have complex result type!");
229 return llvm::ConstantFP::get(VMContext, E->
getValue());
232 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
235 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
238 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
241 return EmitNullValue(E->
getType());
244 return EmitNullValue(E->
getType());
258 return CGF.EmitPseudoObjectRValue(E).getScalarVal();
263 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E), E->
getExprLoc());
266 return CGF.getOpaqueRValueMapping(E).getScalarVal();
272 if (result.isReference())
273 return EmitLoadOfLValue(result.getReferenceLValue(CGF, E),
275 return result.getValue();
277 return EmitLoadOfLValue(E);
281 return CGF.EmitObjCSelectorExpr(E);
284 return CGF.EmitObjCProtocolExpr(E);
287 return EmitLoadOfLValue(E);
292 return EmitLoadOfLValue(E);
293 return CGF.EmitObjCMessageExpr(E).getScalarVal();
297 LValue LV = CGF.EmitObjCIsaExpr(E);
306 Value *VisitExtVectorElementExpr(
Expr *E) {
return EmitLoadOfLValue(E); }
308 return EmitLoadOfLValue(E);
314 return EmitNullValue(E->
getType());
317 CGF.CGM.EmitExplicitCastExprType(E, &CGF);
318 return VisitCastExpr(E);
324 return EmitLoadOfLValue(E);
326 Value *V = CGF.EmitCallExpr(E).getScalarVal();
328 EmitLValueAlignmentAssumption(E, V);
337 return EmitScalarPrePostIncDec(E, LV,
false,
false);
341 return EmitScalarPrePostIncDec(E, LV,
true,
false);
345 return EmitScalarPrePostIncDec(E, LV,
false,
true);
349 return EmitScalarPrePostIncDec(E, LV,
true,
true);
357 bool isInc,
bool isPre);
361 if (isa<MemberPointerType>(E->
getType()))
362 return CGF.CGM.getMemberPointerConstant(E);
364 return EmitLValue(E->
getSubExpr()).getPointer();
369 return EmitLoadOfLValue(E);
373 TestAndClearIgnoreResultAssign();
387 return EmitLoadOfLValue(E);
398 return CGF.LoadCXXThis();
402 CGF.enterFullExpression(E);
407 return CGF.EmitCXXNewExpr(E);
410 CGF.EmitCXXDeleteExpr(E);
415 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
432 CGF.EmitScalarExpr(E->
getBase());
437 return EmitNullValue(E->
getType());
441 CGF.EmitCXXThrowExpr(E);
450 Value *EmitMul(
const BinOpInfo &Ops) {
451 if (Ops.Ty->isSignedIntegerOrEnumerationType()) {
452 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
454 return Builder.CreateMul(Ops.LHS, Ops.RHS,
"mul");
456 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
457 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS,
"mul");
460 return EmitOverflowCheckedBinOp(Ops);
464 if (Ops.Ty->isUnsignedIntegerType() &&
465 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow))
466 return EmitOverflowCheckedBinOp(Ops);
468 if (Ops.LHS->getType()->isFPOrFPVectorTy())
469 return Builder.CreateFMul(Ops.LHS, Ops.RHS,
"mul");
470 return Builder.CreateMul(Ops.LHS, Ops.RHS,
"mul");
474 Value *EmitOverflowCheckedBinOp(
const BinOpInfo &Ops);
477 void EmitUndefinedBehaviorIntegerDivAndRemCheck(
const BinOpInfo &Ops,
481 Value *EmitDiv(
const BinOpInfo &Ops);
482 Value *EmitRem(
const BinOpInfo &Ops);
483 Value *EmitAdd(
const BinOpInfo &Ops);
484 Value *EmitSub(
const BinOpInfo &Ops);
485 Value *EmitShl(
const BinOpInfo &Ops);
486 Value *EmitShr(
const BinOpInfo &Ops);
487 Value *EmitAnd(
const BinOpInfo &Ops) {
488 return Builder.CreateAnd(Ops.LHS, Ops.RHS,
"and");
490 Value *EmitXor(
const BinOpInfo &Ops) {
491 return Builder.CreateXor(Ops.LHS, Ops.RHS,
"xor");
493 Value *EmitOr (
const BinOpInfo &Ops) {
494 return Builder.CreateOr(Ops.LHS, Ops.RHS,
"or");
499 Value *(ScalarExprEmitter::*F)(
const BinOpInfo &),
503 Value *(ScalarExprEmitter::*F)(
const BinOpInfo &));
506 #define HANDLEBINOP(OP) \
507 Value *VisitBin ## OP(const BinaryOperator *E) { \
508 return Emit ## OP(EmitBinOps(E)); \
510 Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \
511 return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \
527 llvm::CmpInst::Predicate SICmpOpc,
528 llvm::CmpInst::Predicate 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(
607 if (llvm::IntegerType *IntTy = dyn_cast<llvm::IntegerType>(SrcTy)) {
613 APFloat LargestFloat =
614 APFloat::getLargest(CGF.getContext().getFloatTypeSemantics(DstType));
615 APSInt LargestInt(IntTy->getBitWidth(), SrcIsUnsigned);
618 if (LargestFloat.convertToInteger(LargestInt, APFloat::rmTowardZero,
619 &IsExact) != APFloat::opOK)
624 llvm::Value *Max = llvm::ConstantInt::get(VMContext, LargestInt);
626 Check =
Builder.CreateICmpULE(Src, Max);
628 llvm::Value *Min = llvm::ConstantInt::get(VMContext, -LargestInt);
631 Check =
Builder.CreateAnd(GE, LE);
634 const llvm::fltSemantics &SrcSema =
635 CGF.getContext().getFloatTypeSemantics(OrigSrcType);
636 if (isa<llvm::IntegerType>(DstTy)) {
640 unsigned Width = CGF.getContext().getIntWidth(DstType);
643 APSInt Min = APSInt::getMinValue(Width, Unsigned);
644 APFloat MinSrc(SrcSema, APFloat::uninitialized);
645 if (MinSrc.convertFromAPInt(Min, !Unsigned, APFloat::rmTowardZero) &
649 MinSrc = APFloat::getInf(SrcSema,
true);
653 MinSrc.subtract(APFloat(SrcSema, 1), APFloat::rmTowardNegative);
655 APSInt Max = APSInt::getMaxValue(Width, Unsigned);
656 APFloat MaxSrc(SrcSema, APFloat::uninitialized);
657 if (MaxSrc.convertFromAPInt(Max, !Unsigned, APFloat::rmTowardZero) &
661 MaxSrc = APFloat::getInf(SrcSema,
false);
665 MaxSrc.add(APFloat(SrcSema, 1), APFloat::rmTowardPositive);
670 const llvm::fltSemantics &
Sema =
671 CGF.getContext().getFloatTypeSemantics(SrcType);
673 MinSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
674 MaxSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
678 Builder.CreateFCmpOGT(Src, llvm::ConstantFP::get(VMContext, MinSrc));
680 Builder.CreateFCmpOLT(Src, llvm::ConstantFP::get(VMContext, MaxSrc));
681 Check =
Builder.CreateAnd(GE, LE);
698 if (CGF.getContext().getFloatingTypeOrder(OrigSrcType, DstType) != 1)
702 "should not check conversion from __half, it has the lowest rank");
704 const llvm::fltSemantics &DstSema =
705 CGF.getContext().getFloatTypeSemantics(DstType);
706 APFloat MinBad = APFloat::getLargest(DstSema,
false);
707 APFloat MaxBad = APFloat::getInf(DstSema,
false);
710 MinBad.convert(SrcSema, APFloat::rmTowardZero, &IsInexact);
711 MaxBad.convert(SrcSema, APFloat::rmTowardZero, &IsInexact);
713 Value *AbsSrc = CGF.EmitNounwindRuntimeCall(
716 Builder.CreateFCmpOGT(AbsSrc, llvm::ConstantFP::get(VMContext, MinBad));
718 Builder.CreateFCmpOLT(AbsSrc, llvm::ConstantFP::get(VMContext, MaxBad));
723 llvm::Constant *StaticArgs[] = {CGF.EmitCheckSourceLocation(Loc),
724 CGF.EmitCheckTypeDescriptor(OrigSrcType),
725 CGF.EmitCheckTypeDescriptor(DstType)};
726 CGF.EmitCheck(std::make_pair(Check, SanitizerKind::FloatCastOverflow),
727 "float_cast_overflow", StaticArgs, OrigSrc);
735 return EmitScalarConversion(Src, SrcType, DstType, Loc,
false);
741 bool TreatBooleanAsSigned) {
744 if (SrcType == DstType)
return Src;
754 return EmitConversionToBool(Src, SrcType);
759 if (SrcType->
isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
761 if (DstTy->isFloatingPointTy()) {
762 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns)
764 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16, DstTy),
770 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
772 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
776 Src =
Builder.CreateFPExt(Src, CGF.CGM.FloatTy,
"conv");
778 SrcType = CGF.getContext().FloatTy;
790 if (isa<llvm::PointerType>(DstTy)) {
792 if (isa<llvm::PointerType>(SrcTy))
793 return Builder.CreateBitCast(Src, DstTy,
"conv");
795 assert(SrcType->
isIntegerType() &&
"Not ptr->ptr or int->ptr conversion?");
801 Builder.CreateIntCast(Src, MiddleTy, InputSigned,
"conv");
803 return Builder.CreateIntToPtr(IntResult, DstTy,
"conv");
806 if (isa<llvm::PointerType>(SrcTy)) {
808 assert(isa<llvm::IntegerType>(DstTy) &&
"not ptr->int?");
809 return Builder.CreatePtrToInt(Src, DstTy,
"conv");
818 "Splatted expr doesn't match with vector element type?");
821 unsigned NumElements = DstTy->getVectorNumElements();
822 return Builder.CreateVectorSplat(NumElements, Src,
"splat");
826 if (isa<llvm::VectorType>(SrcTy) ||
827 isa<llvm::VectorType>(DstTy))
828 return Builder.CreateBitCast(Src, DstTy,
"conv");
831 Value *Res =
nullptr;
836 if (CGF.SanOpts.has(SanitizerKind::FloatCastOverflow) &&
838 EmitFloatConversionCheck(OrigSrc, OrigSrcType, Src, SrcType, DstType, DstTy,
842 if (DstType->
isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
844 if (SrcTy->isFloatingPointTy()) {
847 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns)
849 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, SrcTy), Src);
851 return Builder.CreateFPTrunc(Src, DstTy);
856 if (isa<llvm::IntegerType>(SrcTy)) {
861 if (isa<llvm::IntegerType>(DstTy))
862 Res =
Builder.CreateIntCast(Src, DstTy, InputSigned,
"conv");
863 else if (InputSigned)
864 Res =
Builder.CreateSIToFP(Src, DstTy,
"conv");
866 Res =
Builder.CreateUIToFP(Src, DstTy,
"conv");
867 }
else if (isa<llvm::IntegerType>(DstTy)) {
868 assert(SrcTy->isFloatingPointTy() &&
"Unknown real conversion");
870 Res =
Builder.CreateFPToSI(Src, DstTy,
"conv");
872 Res =
Builder.CreateFPToUI(Src, DstTy,
"conv");
874 assert(SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy() &&
875 "Unknown real conversion");
876 if (DstTy->getTypeID() < SrcTy->getTypeID())
877 Res =
Builder.CreateFPTrunc(Src, DstTy,
"conv");
879 Res =
Builder.CreateFPExt(Src, DstTy,
"conv");
882 if (DstTy != ResTy) {
883 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
884 assert(ResTy->isIntegerTy(16) &&
"Only half FP requires extra conversion");
886 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, CGF.CGM.FloatTy),
889 Res =
Builder.CreateFPTrunc(Res, ResTy,
"conv");
898 Value *ScalarExprEmitter::EmitComplexToScalarConversion(
907 Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
908 Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy, Loc);
909 return Builder.CreateOr(Src.first, Src.second,
"tobool");
916 return EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
920 return CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(Ty), Ty);
927 void ScalarExprEmitter::EmitBinOpCheck(
928 ArrayRef<std::pair<Value *, SanitizerMask>> Checks,
const BinOpInfo &Info) {
929 assert(CGF.IsSanitizerScope);
938 StaticData.push_back(CGF.EmitCheckSourceLocation(Info.E->getExprLoc()));
941 CheckName =
"negate_overflow";
942 StaticData.push_back(CGF.EmitCheckTypeDescriptor(UO->
getType()));
943 DynamicData.push_back(Info.RHS);
947 CheckName =
"shift_out_of_bounds";
949 StaticData.push_back(
951 StaticData.push_back(
953 }
else if (Opcode == BO_Div || Opcode == BO_Rem) {
955 CheckName =
"divrem_overflow";
956 StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
960 case BO_Add: CheckName =
"add_overflow";
break;
961 case BO_Sub: CheckName =
"sub_overflow";
break;
962 case BO_Mul: CheckName =
"mul_overflow";
break;
963 default: llvm_unreachable(
"unexpected opcode for bin op check");
965 StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
967 DynamicData.push_back(Info.LHS);
968 DynamicData.push_back(Info.RHS);
971 CGF.EmitCheck(Checks, CheckName, StaticData, DynamicData);
978 Value *ScalarExprEmitter::VisitExpr(
Expr *E) {
979 CGF.ErrorUnsupported(E,
"scalar expression");
982 return llvm::UndefValue::get(CGF.ConvertType(E->
getType()));
992 llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType());
993 unsigned LHSElts = LTy->getNumElements();
997 llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType());
1001 llvm::ConstantInt::get(MTy, llvm::NextPowerOf2(LHSElts - 1) - 1);
1002 Mask =
Builder.CreateAnd(Mask, MaskBits,
"mask");
1010 llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(),
1011 MTy->getNumElements());
1012 Value* NewV = llvm::UndefValue::get(RTy);
1013 for (
unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) {
1014 Value *IIndx = llvm::ConstantInt::get(CGF.SizeTy, i);
1015 Value *Indx =
Builder.CreateExtractElement(Mask, IIndx,
"shuf_idx");
1017 Value *VExt =
Builder.CreateExtractElement(LHS, Indx,
"shuf_elt");
1018 NewV =
Builder.CreateInsertElement(NewV, VExt, IIndx,
"shuf_ins");
1030 if (Idx.isSigned() && Idx.isAllOnesValue())
1031 indices.push_back(llvm::UndefValue::get(CGF.Int32Ty));
1033 indices.push_back(
Builder.getInt32(Idx.getZExtValue()));
1036 Value *SV = llvm::ConstantVector::get(indices);
1037 return Builder.CreateShuffleVector(V1, V2, SV,
"shuffle");
1048 if (SrcType == DstType)
return Src;
1051 "ConvertVector source type must be a vector");
1053 "ConvertVector destination type must be a vector");
1065 assert(SrcTy->isVectorTy() &&
1066 "ConvertVector source IR type must be a vector");
1067 assert(DstTy->isVectorTy() &&
1068 "ConvertVector destination IR type must be a vector");
1070 llvm::Type *SrcEltTy = SrcTy->getVectorElementType(),
1071 *DstEltTy = DstTy->getVectorElementType();
1073 if (DstEltType->isBooleanType()) {
1074 assert((SrcEltTy->isFloatingPointTy() ||
1075 isa<llvm::IntegerType>(SrcEltTy)) &&
"Unknown boolean conversion");
1077 llvm::Value *Zero = llvm::Constant::getNullValue(SrcTy);
1078 if (SrcEltTy->isFloatingPointTy()) {
1079 return Builder.CreateFCmpUNE(Src, Zero,
"tobool");
1081 return Builder.CreateICmpNE(Src, Zero,
"tobool");
1086 Value *Res =
nullptr;
1088 if (isa<llvm::IntegerType>(SrcEltTy)) {
1090 if (isa<llvm::IntegerType>(DstEltTy))
1091 Res =
Builder.CreateIntCast(Src, DstTy, InputSigned,
"conv");
1092 else if (InputSigned)
1093 Res =
Builder.CreateSIToFP(Src, DstTy,
"conv");
1095 Res =
Builder.CreateUIToFP(Src, DstTy,
"conv");
1096 }
else if (isa<llvm::IntegerType>(DstEltTy)) {
1097 assert(SrcEltTy->isFloatingPointTy() &&
"Unknown real conversion");
1098 if (DstEltType->isSignedIntegerOrEnumerationType())
1099 Res =
Builder.CreateFPToSI(Src, DstTy,
"conv");
1101 Res =
Builder.CreateFPToUI(Src, DstTy,
"conv");
1103 assert(SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() &&
1104 "Unknown real conversion");
1105 if (DstEltTy->getTypeID() < SrcEltTy->getTypeID())
1106 Res =
Builder.CreateFPTrunc(Src, DstTy,
"conv");
1108 Res =
Builder.CreateFPExt(Src, DstTy,
"conv");
1118 CGF.EmitScalarExpr(E->
getBase());
1124 return EmitLoadOfLValue(E);
1128 TestAndClearIgnoreResultAssign();
1135 return EmitLoadOfLValue(E);
1140 Value *Idx = Visit(E->
getIdx());
1143 if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
1144 CGF.EmitBoundsCheck(E, E->
getBase(), Idx, IdxTy,
true);
1146 return Builder.CreateExtractElement(Base, Idx,
"vecext");
1149 static llvm::Constant *
getMaskElt(llvm::ShuffleVectorInst *SVI,
unsigned Idx,
1151 int MV = SVI->getMaskValue(Idx);
1153 return llvm::UndefValue::get(I32Ty);
1154 return llvm::ConstantInt::get(I32Ty, Off+MV);
1158 if (C->getBitWidth() != 32) {
1159 assert(llvm::ConstantInt::isValueValidForType(I32Ty,
1160 C->getZExtValue()) &&
1161 "Index operand too large for shufflevector mask!");
1162 return llvm::ConstantInt::get(I32Ty, C->getZExtValue());
1167 Value *ScalarExprEmitter::VisitInitListExpr(
InitListExpr *E) {
1168 bool Ignore = TestAndClearIgnoreResultAssign();
1170 assert (Ignore ==
false &&
"init list ignored");
1174 CGF.ErrorUnsupported(E,
"GNU array range designator extension");
1176 llvm::VectorType *VType =
1177 dyn_cast<llvm::VectorType>(ConvertType(E->
getType()));
1180 if (NumInitElements == 0) {
1182 return EmitNullValue(E->
getType());
1188 unsigned ResElts = VType->getNumElements();
1195 unsigned CurIdx = 0;
1196 bool VIsUndefShuffle =
false;
1198 for (
unsigned i = 0; i != NumInitElements; ++i) {
1200 Value *Init = Visit(IE);
1203 llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType());
1209 if (isa<ExtVectorElementExpr>(IE)) {
1210 llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init);
1212 if (EI->getVectorOperandType()->getNumElements() == ResElts) {
1213 llvm::ConstantInt *
C = cast<llvm::ConstantInt>(EI->getIndexOperand());
1214 Value *LHS =
nullptr, *RHS =
nullptr;
1219 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1221 LHS = EI->getVectorOperand();
1223 VIsUndefShuffle =
true;
1224 }
else if (VIsUndefShuffle) {
1226 llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V);
1227 for (
unsigned j = 0; j != CurIdx; ++j)
1228 Args.push_back(
getMaskElt(SVV, j, 0, CGF.Int32Ty));
1229 Args.push_back(
Builder.getInt32(ResElts + C->getZExtValue()));
1230 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1232 LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
1233 RHS = EI->getVectorOperand();
1234 VIsUndefShuffle =
false;
1236 if (!Args.empty()) {
1237 llvm::Constant *Mask = llvm::ConstantVector::get(Args);
1238 V =
Builder.CreateShuffleVector(LHS, RHS, Mask);
1244 V =
Builder.CreateInsertElement(V, Init,
Builder.getInt32(CurIdx),
1246 VIsUndefShuffle =
false;
1251 unsigned InitElts = VVT->getNumElements();
1256 unsigned Offset = (CurIdx == 0) ? 0 : ResElts;
1257 if (isa<ExtVectorElementExpr>(IE)) {
1258 llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init);
1259 Value *SVOp = SVI->getOperand(0);
1260 llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType());
1262 if (OpTy->getNumElements() == ResElts) {
1263 for (
unsigned j = 0; j != CurIdx; ++j) {
1266 if (VIsUndefShuffle) {
1267 Args.push_back(
getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0,
1270 Args.push_back(
Builder.getInt32(j));
1273 for (
unsigned j = 0, je = InitElts; j != je; ++j)
1274 Args.push_back(
getMaskElt(SVI, j, Offset, CGF.Int32Ty));
1275 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1277 if (VIsUndefShuffle)
1278 V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
1287 for (
unsigned j = 0; j != InitElts; ++j)
1288 Args.push_back(
Builder.getInt32(j));
1289 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1290 llvm::Constant *Mask = llvm::ConstantVector::get(Args);
1291 Init =
Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT),
1295 for (
unsigned j = 0; j != CurIdx; ++j)
1296 Args.push_back(
Builder.getInt32(j));
1297 for (
unsigned j = 0; j != InitElts; ++j)
1298 Args.push_back(
Builder.getInt32(j+Offset));
1299 Args.resize(ResElts, llvm::UndefValue::get(CGF.Int32Ty));
1306 llvm::Constant *Mask = llvm::ConstantVector::get(Args);
1307 V =
Builder.CreateShuffleVector(V, Init, Mask,
"vecinit");
1308 VIsUndefShuffle = isa<llvm::UndefValue>(Init);
1317 for (; CurIdx < ResElts; ++CurIdx) {
1318 Value *Idx =
Builder.getInt32(CurIdx);
1319 llvm::Value *Init = llvm::Constant::getNullValue(EltTy);
1320 V =
Builder.CreateInsertElement(V, Init, Idx,
"vecinit");
1328 if (CE->
getCastKind() == CK_UncheckedDerivedToBase)
1348 Value *ScalarExprEmitter::VisitCastExpr(
CastExpr *CE) {
1355 bool Ignored = TestAndClearIgnoreResultAssign();
1361 case CK_Dependent: llvm_unreachable(
"dependent cast kind in IR gen!");
1362 case CK_BuiltinFnToFnPtr:
1363 llvm_unreachable(
"builtin functions are handled elsewhere");
1365 case CK_LValueBitCast:
1366 case CK_ObjCObjectLValueCast: {
1367 Address Addr = EmitLValue(E).getAddress();
1368 Addr =
Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));
1369 LValue LV = CGF.MakeAddrLValue(Addr, DestTy);
1370 return EmitLoadOfLValue(LV, CE->
getExprLoc());
1373 case CK_CPointerToObjCPointerCast:
1374 case CK_BlockPointerToObjCPointerCast:
1375 case CK_AnyPointerToBlockPointerCast:
1377 Value *Src = Visit(const_cast<Expr*>(E));
1380 if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() &&
1381 SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) {
1382 llvm_unreachable(
"wrong cast for pointers in different address spaces"
1383 "(must be an address space cast)!");
1386 if (CGF.SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
1388 CGF.EmitVTablePtrCheckForCast(PT->getPointeeType(), Src,
1394 return Builder.CreateBitCast(Src, DstTy);
1396 case CK_AddressSpaceConversion: {
1397 Value *Src = Visit(const_cast<Expr*>(E));
1400 return Builder.CreatePointerBitCastOrAddrSpaceCast(Src,
1401 ConvertType(DestTy));
1403 case CK_AtomicToNonAtomic:
1404 case CK_NonAtomicToAtomic:
1406 case CK_UserDefinedConversion:
1407 return Visit(const_cast<Expr*>(E));
1409 case CK_BaseToDerived: {
1411 assert(DerivedClassDecl &&
"BaseToDerived arg isn't a C++ object pointer!");
1413 Address Base = CGF.EmitPointerWithAlignment(E);
1415 CGF.GetAddressOfDerivedClass(Base, DerivedClassDecl,
1417 CGF.ShouldNullCheckClassCastValue(CE));
1421 if (CGF.sanitizePerformTypeCheck())
1425 if (CGF.SanOpts.has(SanitizerKind::CFIDerivedCast))
1434 case CK_UncheckedDerivedToBase:
1435 case CK_DerivedToBase: {
1438 return CGF.EmitPointerWithAlignment(CE).getPointer();
1442 Address V = CGF.EmitPointerWithAlignment(E);
1444 return CGF.EmitDynamicCast(V, DCE);
1447 case CK_ArrayToPointerDecay:
1448 return CGF.EmitArrayToPointerDecay(E).getPointer();
1449 case CK_FunctionToPointerDecay:
1450 return EmitLValue(E).getPointer();
1452 case CK_NullToPointer:
1453 if (MustVisitNullValue(E))
1456 return llvm::ConstantPointerNull::get(
1457 cast<llvm::PointerType>(ConvertType(DestTy)));
1459 case CK_NullToMemberPointer: {
1460 if (MustVisitNullValue(E))
1464 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
1467 case CK_ReinterpretMemberPointer:
1468 case CK_BaseToDerivedMemberPointer:
1469 case CK_DerivedToBaseMemberPointer: {
1470 Value *Src = Visit(E);
1478 return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
1481 case CK_ARCProduceObject:
1482 return CGF.EmitARCRetainScalarExpr(E);
1483 case CK_ARCConsumeObject:
1484 return CGF.EmitObjCConsumeObject(E->
getType(), Visit(E));
1485 case CK_ARCReclaimReturnedObject:
1486 return CGF.EmitARCReclaimReturnedObject(E, Ignored);
1487 case CK_ARCExtendBlockObject:
1488 return CGF.EmitARCExtendBlockObject(E);
1490 case CK_CopyAndAutoreleaseBlockObject:
1491 return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->
getType());
1493 case CK_FloatingRealToComplex:
1494 case CK_FloatingComplexCast:
1495 case CK_IntegralRealToComplex:
1496 case CK_IntegralComplexCast:
1497 case CK_IntegralComplexToFloatingComplex:
1498 case CK_FloatingComplexToIntegralComplex:
1499 case CK_ConstructorConversion:
1501 llvm_unreachable(
"scalar cast to non-scalar value");
1503 case CK_LValueToRValue:
1504 assert(CGF.getContext().hasSameUnqualifiedType(E->
getType(), DestTy));
1505 assert(E->
isGLValue() &&
"lvalue-to-rvalue applied to r-value!");
1506 return Visit(const_cast<Expr*>(E));
1508 case CK_IntegralToPointer: {
1509 Value *Src = Visit(const_cast<Expr*>(E));
1516 Builder.CreateIntCast(Src, MiddleTy, InputSigned,
"conv");
1518 return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy));
1520 case CK_PointerToIntegral:
1521 assert(!DestTy->
isBooleanType() &&
"bool should use PointerToBool");
1522 return Builder.CreatePtrToInt(Visit(E), ConvertType(DestTy));
1525 CGF.EmitIgnoredExpr(E);
1528 case CK_VectorSplat: {
1530 Value *Elt = Visit(const_cast<Expr*>(E));
1532 unsigned NumElements = DstTy->getVectorNumElements();
1533 return Builder.CreateVectorSplat(NumElements, Elt,
"splat");
1536 case CK_IntegralCast:
1537 case CK_IntegralToFloating:
1538 case CK_FloatingToIntegral:
1539 case CK_FloatingCast:
1540 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
1542 case CK_BooleanToSignedIntegral:
1543 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
1546 case CK_IntegralToBoolean:
1547 return EmitIntToBoolConversion(Visit(E));
1548 case CK_PointerToBoolean:
1549 return EmitPointerToBoolConversion(Visit(E));
1550 case CK_FloatingToBoolean:
1551 return EmitFloatToBoolConversion(Visit(E));
1552 case CK_MemberPointerToBoolean: {
1555 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
1558 case CK_FloatingComplexToReal:
1559 case CK_IntegralComplexToReal:
1560 return CGF.EmitComplexExpr(E,
false,
true).first;
1562 case CK_FloatingComplexToBoolean:
1563 case CK_IntegralComplexToBoolean: {
1567 return EmitComplexToScalarConversion(V, E->
getType(), DestTy,
1571 case CK_ZeroToOCLEvent: {
1572 assert(DestTy->
isEventT() &&
"CK_ZeroToOCLEvent cast on non-event type");
1573 return llvm::Constant::getNullValue(ConvertType(DestTy));
1578 llvm_unreachable(
"unknown scalar cast");
1581 Value *ScalarExprEmitter::VisitStmtExpr(
const StmtExpr *E) {
1587 return CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(RetAlloca, E->
getType()),
1599 BinOp.RHS = llvm::ConstantInt::get(InVal->getType(), 1,
false);
1601 BinOp.Opcode = IsInc ? BO_Add : BO_Sub;
1602 BinOp.FPContractable =
false;
1607 llvm::Value *ScalarExprEmitter::EmitIncDecConsiderOverflowBehavior(
1610 llvm::ConstantInt::get(InVal->getType(), IsInc ? 1 : -1,
true);
1611 StringRef
Name = IsInc ?
"inc" :
"dec";
1612 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
1614 return Builder.CreateAdd(InVal, Amount, Name);
1616 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
1617 return Builder.CreateNSWAdd(InVal, Amount, Name);
1622 llvm_unreachable(
"Unknown SignedOverflowBehaviorTy");
1627 bool isInc,
bool isPre) {
1630 llvm::PHINode *atomicPHI =
nullptr;
1634 int amount = (isInc ? 1 : -1);
1637 type = atomicTy->getValueType();
1642 ->setAtomic(llvm::AtomicOrdering::SequentiallyConsistent);
1647 return Builder.CreateAtomicRMW(
1648 llvm::AtomicRMWInst::Xchg, LV.
getPointer(), True,
1649 llvm::AtomicOrdering::SequentiallyConsistent);
1656 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
1657 CGF.getLangOpts().getSignedOverflowBehavior() !=
1659 llvm::AtomicRMWInst::BinOp aop = isInc ? llvm::AtomicRMWInst::Add :
1660 llvm::AtomicRMWInst::Sub;
1661 llvm::Instruction::BinaryOps op = isInc ? llvm::Instruction::Add :
1662 llvm::Instruction::Sub;
1664 llvm::ConstantInt::get(ConvertType(type), 1,
true), type);
1666 LV.
getPointer(), amt, llvm::AtomicOrdering::SequentiallyConsistent);
1667 return isPre ?
Builder.CreateBinOp(op, old, amt) : old;
1669 value = EmitLoadOfLValue(LV, E->
getExprLoc());
1672 llvm::BasicBlock *startBB =
Builder.GetInsertBlock();
1673 llvm::BasicBlock *opBB = CGF.createBasicBlock(
"atomic_op", CGF.CurFn);
1674 value = CGF.EmitToMemory(value, type);
1677 atomicPHI =
Builder.CreatePHI(value->getType(), 2);
1678 atomicPHI->addIncoming(value, startBB);
1681 value = EmitLoadOfLValue(LV, E->
getExprLoc());
1699 bool CanOverflow = value->getType()->getIntegerBitWidth() >=
1700 CGF.IntTy->getIntegerBitWidth();
1702 value = EmitIncDecConsiderOverflowBehavior(E, value, isInc);
1704 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) {
1708 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount,
true);
1709 value =
Builder.CreateAdd(value, amt, isInc ?
"inc" :
"dec");
1718 = CGF.getContext().getAsVariableArrayType(type)) {
1720 if (!isInc) numElts =
Builder.CreateNSWNeg(numElts,
"vla.negsize");
1721 if (CGF.getLangOpts().isSignedOverflowDefined())
1722 value =
Builder.CreateGEP(value, numElts,
"vla.inc");
1724 value =
Builder.CreateInBoundsGEP(value, numElts,
"vla.inc");
1730 value = CGF.EmitCastToVoidPtr(value);
1731 if (CGF.getLangOpts().isSignedOverflowDefined())
1732 value =
Builder.CreateGEP(value, amt,
"incdec.funcptr");
1734 value =
Builder.CreateInBoundsGEP(value, amt,
"incdec.funcptr");
1735 value =
Builder.CreateBitCast(value, input->getType());
1740 if (CGF.getLangOpts().isSignedOverflowDefined())
1741 value =
Builder.CreateGEP(value, amt,
"incdec.ptr");
1743 value =
Builder.CreateInBoundsGEP(value, amt,
"incdec.ptr");
1749 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount);
1751 value =
Builder.CreateAdd(value, amt, isInc ?
"inc" :
"dec");
1755 llvm::ConstantFP::get(value->getType(), amount),
1756 isInc ?
"inc" :
"dec");
1764 if (type->
isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
1766 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
1768 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
1770 input,
"incdec.conv");
1772 value =
Builder.CreateFPExt(input, CGF.CGM.FloatTy,
"incdec.conv");
1776 if (value->getType()->isFloatTy())
1777 amt = llvm::ConstantFP::get(VMContext,
1778 llvm::APFloat(static_cast<float>(amount)));
1779 else if (value->getType()->isDoubleTy())
1780 amt = llvm::ConstantFP::get(VMContext,
1781 llvm::APFloat(static_cast<double>(amount)));
1784 llvm::APFloat F(static_cast<float>(amount));
1786 const llvm::fltSemantics *FS;
1789 if (value->getType()->isFP128Ty())
1790 FS = &CGF.getTarget().getFloat128Format();
1791 else if (value->getType()->isHalfTy())
1792 FS = &CGF.getTarget().getHalfFormat();
1794 FS = &CGF.getTarget().getLongDoubleFormat();
1795 F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
1796 amt = llvm::ConstantFP::get(VMContext, F);
1798 value =
Builder.CreateFAdd(value, amt, isInc ?
"inc" :
"dec");
1800 if (type->
isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
1801 if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
1803 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16,
1805 value,
"incdec.conv");
1807 value =
Builder.CreateFPTrunc(value, input->getType(),
"incdec.conv");
1814 value = CGF.EmitCastToVoidPtr(value);
1817 if (!isInc) size = -size;
1819 llvm::ConstantInt::get(CGF.SizeTy, size.
getQuantity());
1821 if (CGF.getLangOpts().isSignedOverflowDefined())
1822 value =
Builder.CreateGEP(value, sizeValue,
"incdec.objptr");
1824 value =
Builder.CreateInBoundsGEP(value, sizeValue,
"incdec.objptr");
1825 value =
Builder.CreateBitCast(value, input->getType());
1829 llvm::BasicBlock *opBB =
Builder.GetInsertBlock();
1830 llvm::BasicBlock *contBB = CGF.createBasicBlock(
"atomic_cont", CGF.CurFn);
1831 auto Pair = CGF.EmitAtomicCompareExchange(
1835 atomicPHI->addIncoming(old, opBB);
1836 Builder.CreateCondBr(success, contBB, opBB);
1837 Builder.SetInsertPoint(contBB);
1838 return isPre ? value : input;
1843 CGF.EmitStoreThroughBitfieldLValue(
RValue::get(value), LV, &value);
1845 CGF.EmitStoreThroughLValue(
RValue::get(value), LV);
1849 return isPre ? value : input;
1854 Value *ScalarExprEmitter::VisitUnaryMinus(
const UnaryOperator *E) {
1855 TestAndClearIgnoreResultAssign();
1860 if (BinOp.RHS->getType()->isFPOrFPVectorTy())
1861 BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType());
1863 BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType());
1865 BinOp.Opcode = BO_Sub;
1866 BinOp.FPContractable =
false;
1868 return EmitSub(BinOp);
1871 Value *ScalarExprEmitter::VisitUnaryNot(
const UnaryOperator *E) {
1872 TestAndClearIgnoreResultAssign();
1874 return Builder.CreateNot(Op,
"neg");
1877 Value *ScalarExprEmitter::VisitUnaryLNot(
const UnaryOperator *E) {
1881 Value *Zero = llvm::Constant::getNullValue(Oper->getType());
1883 if (Oper->getType()->isFPOrFPVectorTy())
1884 Result =
Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper, Zero,
"cmp");
1886 Result =
Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero,
"cmp");
1887 return Builder.CreateSExt(Result, ConvertType(E->
getType()),
"sext");
1891 Value *BoolVal = CGF.EvaluateExprAsBool(E->
getSubExpr());
1896 BoolVal =
Builder.CreateNot(BoolVal,
"lnot");
1899 return Builder.CreateZExt(BoolVal, ConvertType(E->
getType()),
"lnot.ext");
1902 Value *ScalarExprEmitter::VisitOffsetOfExpr(
OffsetOfExpr *E) {
1911 llvm::Value* Result = llvm::Constant::getNullValue(ResultType);
1913 for (
unsigned i = 0; i != n; ++i) {
1922 Idx =
Builder.CreateIntCast(Idx, ResultType, IdxSigned,
"conv");
1926 CGF.getContext().getAsArrayType(CurrentType)->getElementType();
1929 llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType,
1930 CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity());
1933 Offset =
Builder.CreateMul(Idx, ElemSize);
1948 if (*Field == MemberDecl)
1951 assert(i < RL.
getFieldCount() &&
"offsetof field in wrong type");
1955 CGF.getContext().getCharWidth();
1956 Offset = llvm::ConstantInt::get(ResultType, OffsetInt);
1959 CurrentType = MemberDecl->
getType();
1964 llvm_unreachable(
"dependent __builtin_offsetof");
1968 CGF.ErrorUnsupported(E,
"virtual base in offsetof");
1982 Offset = llvm::ConstantInt::get(ResultType, OffsetInt.getQuantity());
1986 Result =
Builder.CreateAdd(Result, Offset);
1994 ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr(
1999 CGF.getContext().getAsVariableArrayType(TypeToSize)) {
2002 CGF.EmitVariablyModifiedType(TypeToSize);
2011 std::tie(numElts, eltType) = CGF.getVLASize(VAT);
2016 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType);
2017 if (!eltSize.
isOne())
2018 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts);
2025 .toCharUnitsFromBits(CGF.getContext().getOpenMPDefaultSimdAlign(
2028 return llvm::ConstantInt::get(CGF.SizeTy, Alignment);
2036 Value *ScalarExprEmitter::VisitUnaryReal(
const UnaryOperator *E) {
2043 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
2047 return CGF.EmitComplexExpr(Op,
false,
true).first;
2053 Value *ScalarExprEmitter::VisitUnaryImag(
const UnaryOperator *E) {
2060 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
2064 return CGF.EmitComplexExpr(Op,
true,
false).second;
2072 CGF.EmitScalarExpr(Op,
true);
2073 return llvm::Constant::getNullValue(ConvertType(E->
getType()));
2080 BinOpInfo ScalarExprEmitter::EmitBinOps(
const BinaryOperator *E) {
2081 TestAndClearIgnoreResultAssign();
2083 Result.LHS = Visit(E->
getLHS());
2084 Result.RHS = Visit(E->
getRHS());
2092 LValue ScalarExprEmitter::EmitCompoundAssignLValue(
2094 Value *(ScalarExprEmitter::*Func)(
const BinOpInfo &),
2100 return CGF.EmitScalarCompoundAssignWithComplex(E, Result);
2104 OpInfo.RHS = Visit(E->
getRHS());
2112 llvm::PHINode *atomicPHI =
nullptr;
2114 QualType type = atomicTy->getValueType();
2117 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
2118 CGF.getLangOpts().getSignedOverflowBehavior() !=
2120 llvm::AtomicRMWInst::BinOp aop = llvm::AtomicRMWInst::BAD_BINOP;
2121 switch (OpInfo.Opcode) {
2123 case BO_MulAssign:
case BO_DivAssign:
2129 aop = llvm::AtomicRMWInst::Add;
2132 aop = llvm::AtomicRMWInst::Sub;
2138 aop = llvm::AtomicRMWInst::Xor;
2141 aop = llvm::AtomicRMWInst::Or;
2144 llvm_unreachable(
"Invalid compound assignment type");
2146 if (aop != llvm::AtomicRMWInst::BAD_BINOP) {
2148 EmitScalarConversion(OpInfo.RHS, E->
getRHS()->
getType(), LHSTy,
2152 llvm::AtomicOrdering::SequentiallyConsistent);
2158 llvm::BasicBlock *startBB =
Builder.GetInsertBlock();
2159 llvm::BasicBlock *opBB = CGF.createBasicBlock(
"atomic_op", CGF.CurFn);
2160 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->
getExprLoc());
2161 OpInfo.LHS = CGF.EmitToMemory(OpInfo.LHS, type);
2164 atomicPHI =
Builder.CreatePHI(OpInfo.LHS->getType(), 2);
2165 atomicPHI->addIncoming(OpInfo.LHS, startBB);
2166 OpInfo.LHS = atomicPHI;
2169 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->
getExprLoc());
2176 Result = (this->*Func)(OpInfo);
2183 llvm::BasicBlock *opBB =
Builder.GetInsertBlock();
2184 llvm::BasicBlock *contBB = CGF.createBasicBlock(
"atomic_cont", CGF.CurFn);
2185 auto Pair = CGF.EmitAtomicCompareExchange(
2187 llvm::Value *old = CGF.EmitToMemory(Pair.first.getScalarVal(), LHSTy);
2189 atomicPHI->addIncoming(old, opBB);
2190 Builder.CreateCondBr(success, contBB, opBB);
2191 Builder.SetInsertPoint(contBB);
2200 CGF.EmitStoreThroughBitfieldLValue(
RValue::get(Result), LHSLV, &Result);
2202 CGF.EmitStoreThroughLValue(
RValue::get(Result), LHSLV);
2208 Value *(ScalarExprEmitter::*Func)(
const BinOpInfo &)) {
2209 bool Ignore = TestAndClearIgnoreResultAssign();
2211 LValue LHS = EmitCompoundAssignLValue(E, Func, RHS);
2218 if (!CGF.getLangOpts().CPlusPlus)
2226 return EmitLoadOfLValue(LHS, E->
getExprLoc());
2229 void ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck(
2230 const BinOpInfo &Ops,
llvm::Value *Zero,
bool isDiv) {
2233 if (CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero)) {
2234 Checks.push_back(std::make_pair(
Builder.CreateICmpNE(Ops.RHS, Zero),
2235 SanitizerKind::IntegerDivideByZero));
2238 if (CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow) &&
2239 Ops.Ty->hasSignedIntegerRepresentation()) {
2240 llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType());
2243 Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
2244 llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL);
2250 std::make_pair(NotOverflow, SanitizerKind::SignedIntegerOverflow));
2253 if (Checks.size() > 0)
2254 EmitBinOpCheck(Checks, Ops);
2257 Value *ScalarExprEmitter::EmitDiv(
const BinOpInfo &Ops) {
2260 if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
2261 CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
2262 Ops.Ty->isIntegerType()) {
2263 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
2264 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero,
true);
2265 }
else if (CGF.SanOpts.has(SanitizerKind::FloatDivideByZero) &&
2266 Ops.Ty->isRealFloatingType()) {
2267 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
2269 EmitBinOpCheck(std::make_pair(NonZero, SanitizerKind::FloatDivideByZero),
2274 if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
2276 if (CGF.getLangOpts().OpenCL) {
2279 if (ValTy->isFloatTy() ||
2280 (isa<llvm::VectorType>(ValTy) &&
2281 cast<llvm::VectorType>(ValTy)->getElementType()->isFloatTy()))
2282 CGF.SetFPAccuracy(Val, 2.5);
2286 else if (Ops.Ty->hasUnsignedIntegerRepresentation())
2287 return Builder.CreateUDiv(Ops.LHS, Ops.RHS,
"div");
2289 return Builder.CreateSDiv(Ops.LHS, Ops.RHS,
"div");
2292 Value *ScalarExprEmitter::EmitRem(
const BinOpInfo &Ops) {
2294 if (CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero)) {
2296 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
2298 if (Ops.Ty->isIntegerType())
2299 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero,
false);
2302 if (Ops.Ty->hasUnsignedIntegerRepresentation())
2303 return Builder.CreateURem(Ops.LHS, Ops.RHS,
"rem");
2305 return Builder.CreateSRem(Ops.LHS, Ops.RHS,
"rem");
2308 Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(
const BinOpInfo &Ops) {
2312 bool isSigned = Ops.Ty->isSignedIntegerOrEnumerationType();
2313 switch (Ops.Opcode) {
2317 IID = isSigned ? llvm::Intrinsic::sadd_with_overflow :
2318 llvm::Intrinsic::uadd_with_overflow;
2323 IID = isSigned ? llvm::Intrinsic::ssub_with_overflow :
2324 llvm::Intrinsic::usub_with_overflow;
2329 IID = isSigned ? llvm::Intrinsic::smul_with_overflow :
2330 llvm::Intrinsic::umul_with_overflow;
2333 llvm_unreachable(
"Unsupported operation for overflow detection");
2339 llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
2341 llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy);
2343 Value *resultAndOverflow =
Builder.CreateCall(intrinsic, {Ops.LHS, Ops.RHS});
2344 Value *result =
Builder.CreateExtractValue(resultAndOverflow, 0);
2345 Value *overflow =
Builder.CreateExtractValue(resultAndOverflow, 1);
2348 const std::string *handlerName =
2349 &CGF.getLangOpts().OverflowHandler;
2350 if (handlerName->empty()) {
2353 if (!isSigned || CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) {
2356 SanitizerMask Kind = isSigned ? SanitizerKind::SignedIntegerOverflow
2357 : SanitizerKind::UnsignedIntegerOverflow;
2358 EmitBinOpCheck(std::make_pair(NotOverflow, Kind), Ops);
2360 CGF.EmitTrapCheck(
Builder.CreateNot(overflow));
2365 llvm::BasicBlock *initialBB =
Builder.GetInsertBlock();
2367 llvm::BasicBlock *continueBB = CGF.createBasicBlock(
"nooverflow", CGF.CurFn,
2368 &*std::next(insertPt));
2369 llvm::BasicBlock *overflowBB = CGF.createBasicBlock(
"overflow", CGF.CurFn);
2371 Builder.CreateCondBr(overflow, overflowBB, continueBB);
2375 Builder.SetInsertPoint(overflowBB);
2379 llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty };
2380 llvm::FunctionType *handlerTy =
2381 llvm::FunctionType::get(CGF.Int64Ty, argTypes,
true);
2382 llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName);
2395 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())
2398 CGF.EmitNounwindRuntimeCall(handler, handlerArgs);
2401 handlerResult =
Builder.CreateTrunc(handlerResult, opTy);
2404 Builder.SetInsertPoint(continueBB);
2405 llvm::PHINode *phi =
Builder.CreatePHI(opTy, 2);
2406 phi->addIncoming(result, initialBB);
2407 phi->addIncoming(handlerResult, overflowBB);
2414 const BinOpInfo &op,
2415 bool isSubtraction) {
2420 Value *pointer = op.LHS;
2422 Value *index = op.RHS;
2426 if (!isSubtraction && !pointer->getType()->isPointerTy()) {
2427 std::swap(pointer, index);
2428 std::swap(pointerOperand, indexOperand);
2431 unsigned width = cast<llvm::IntegerType>(index->getType())->getBitWidth();
2442 index = CGF.
Builder.CreateNeg(index,
"idx.neg");
2444 if (CGF.
SanOpts.
has(SanitizerKind::ArrayBounds))
2457 index = CGF.
Builder.CreateMul(index, objectSize);
2460 result = CGF.
Builder.CreateGEP(result, index,
"add.ptr");
2475 index = CGF.
Builder.CreateMul(index, numElements,
"vla.index");
2476 pointer = CGF.
Builder.CreateGEP(pointer, index,
"add.ptr");
2478 index = CGF.
Builder.CreateNSWMul(index, numElements,
"vla.index");
2479 pointer = CGF.
Builder.CreateInBoundsGEP(pointer, index,
"add.ptr");
2489 result = CGF.
Builder.CreateGEP(result, index,
"add.ptr");
2494 return CGF.
Builder.CreateGEP(pointer, index,
"add.ptr");
2496 return CGF.
Builder.CreateInBoundsGEP(pointer, index,
"add.ptr");
2506 bool negMul,
bool negAdd) {
2507 assert(!(negMul && negAdd) &&
"Only one of negMul and negAdd should be set.");
2509 Value *MulOp0 = MulOp->getOperand(0);
2510 Value *MulOp1 = MulOp->getOperand(1);
2514 llvm::ConstantFP::getZeroValueForNegation(MulOp0->getType()), MulOp0,
2516 }
else if (negAdd) {
2519 llvm::ConstantFP::getZeroValueForNegation(Addend->getType()), Addend,
2523 Value *FMulAdd = Builder.CreateCall(
2525 {MulOp0, MulOp1, Addend});
2526 MulOp->eraseFromParent();
2541 assert((op.Opcode == BO_Add || op.Opcode == BO_AddAssign ||
2542 op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) &&
2543 "Only fadd/fsub can be the root of an fmuladd.");
2546 if (!op.FPContractable)
2557 if (
auto *LHSBinOp = dyn_cast<llvm::BinaryOperator>(op.LHS)) {
2558 if (LHSBinOp->getOpcode() == llvm::Instruction::FMul &&
2559 LHSBinOp->use_empty())
2560 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder,
false, isSub);
2562 if (
auto *RHSBinOp = dyn_cast<llvm::BinaryOperator>(op.RHS)) {
2563 if (RHSBinOp->getOpcode() == llvm::Instruction::FMul &&
2564 RHSBinOp->use_empty())
2565 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub,
false);
2571 Value *ScalarExprEmitter::EmitAdd(
const BinOpInfo &op) {
2572 if (op.LHS->getType()->isPointerTy() ||
2573 op.RHS->getType()->isPointerTy())
2576 if (op.Ty->isSignedIntegerOrEnumerationType()) {
2577 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
2579 return Builder.CreateAdd(op.LHS, op.RHS,
"add");
2581 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
2582 return Builder.CreateNSWAdd(op.LHS, op.RHS,
"add");
2585 return EmitOverflowCheckedBinOp(op);
2589 if (op.Ty->isUnsignedIntegerType() &&
2590 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow))
2591 return EmitOverflowCheckedBinOp(op);
2593 if (op.LHS->getType()->isFPOrFPVectorTy()) {
2598 return Builder.CreateFAdd(op.LHS, op.RHS,
"add");
2601 return Builder.CreateAdd(op.LHS, op.RHS,
"add");
2604 Value *ScalarExprEmitter::EmitSub(
const BinOpInfo &op) {
2606 if (!op.LHS->getType()->isPointerTy()) {
2607 if (op.Ty->isSignedIntegerOrEnumerationType()) {
2608 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
2610 return Builder.CreateSub(op.LHS, op.RHS,
"sub");
2612 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
2613 return Builder.CreateNSWSub(op.LHS, op.RHS,
"sub");
2616 return EmitOverflowCheckedBinOp(op);
2620 if (op.Ty->isUnsignedIntegerType() &&
2621 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow))
2622 return EmitOverflowCheckedBinOp(op);
2624 if (op.LHS->getType()->isFPOrFPVectorTy()) {
2628 return Builder.CreateFSub(op.LHS, op.RHS,
"sub");
2631 return Builder.CreateSub(op.LHS, op.RHS,
"sub");
2636 if (!op.RHS->getType()->isPointerTy())
2643 =
Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy,
"sub.ptr.lhs.cast");
2645 =
Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy,
"sub.ptr.rhs.cast");
2646 Value *diffInChars =
Builder.CreateSub(LHS, RHS,
"sub.ptr.sub");
2656 = CGF.getContext().getAsVariableArrayType(elementType)) {
2658 std::tie(numElements, elementType) = CGF.getVLASize(vla);
2660 divisor = numElements;
2663 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType);
2664 if (!eltSize.
isOne())
2665 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
2674 if (elementType->isVoidType() || elementType->isFunctionType())
2677 elementSize = CGF.getContext().getTypeSizeInChars(elementType);
2680 if (elementSize.
isOne())
2683 divisor = CGF.CGM.getSize(elementSize);
2689 return Builder.CreateExactSDiv(diffInChars, divisor,
"sub.ptr.div");
2692 Value *ScalarExprEmitter::GetWidthMinusOneValue(Value* LHS,Value* RHS) {
2693 llvm::IntegerType *Ty;
2694 if (llvm::VectorType *VT = dyn_cast<llvm::VectorType>(LHS->getType()))
2695 Ty = cast<llvm::IntegerType>(VT->getElementType());
2697 Ty = cast<llvm::IntegerType>(LHS->getType());
2698 return llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth() - 1);
2701 Value *ScalarExprEmitter::EmitShl(
const BinOpInfo &Ops) {
2704 Value *RHS = Ops.RHS;
2705 if (Ops.LHS->getType() != RHS->getType())
2706 RHS =
Builder.CreateIntCast(RHS, Ops.LHS->getType(),
false,
"sh_prom");
2708 bool SanitizeBase = CGF.SanOpts.has(SanitizerKind::ShiftBase) &&
2709 Ops.Ty->hasSignedIntegerRepresentation() &&
2710 !CGF.getLangOpts().isSignedOverflowDefined();
2711 bool SanitizeExponent = CGF.SanOpts.has(SanitizerKind::ShiftExponent);
2713 if (CGF.getLangOpts().OpenCL)
2715 Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS),
"shl.mask");
2716 else if ((SanitizeBase || SanitizeExponent) &&
2717 isa<llvm::IntegerType>(Ops.LHS->getType())) {
2720 llvm::Value *WidthMinusOne = GetWidthMinusOneValue(Ops.LHS, RHS);
2723 if (SanitizeExponent) {
2725 std::make_pair(ValidExponent, SanitizerKind::ShiftExponent));
2732 llvm::BasicBlock *Orig =
Builder.GetInsertBlock();
2733 llvm::BasicBlock *Cont = CGF.createBasicBlock(
"cont");
2734 llvm::BasicBlock *CheckShiftBase = CGF.createBasicBlock(
"check");
2735 Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);
2736 CGF.EmitBlock(CheckShiftBase);
2739 Builder.CreateSub(WidthMinusOne, RHS,
"shl.zeros",
2742 if (CGF.getLangOpts().CPlusPlus) {
2747 llvm::Value *One = llvm::ConstantInt::get(BitsShiftedOff->getType(), 1);
2748 BitsShiftedOff =
Builder.CreateLShr(BitsShiftedOff, One);
2750 llvm::Value *Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0);
2752 CGF.EmitBlock(Cont);
2753 llvm::PHINode *BaseCheck =
Builder.CreatePHI(ValidBase->getType(), 2);
2754 BaseCheck->addIncoming(
Builder.getTrue(), Orig);
2755 BaseCheck->addIncoming(ValidBase, CheckShiftBase);
2756 Checks.push_back(std::make_pair(BaseCheck, SanitizerKind::ShiftBase));
2759 assert(!Checks.empty());
2760 EmitBinOpCheck(Checks, Ops);
2763 return Builder.CreateShl(Ops.LHS, RHS,
"shl");
2766 Value *ScalarExprEmitter::EmitShr(
const BinOpInfo &Ops) {
2769 Value *RHS = Ops.RHS;
2770 if (Ops.LHS->getType() != RHS->getType())
2771 RHS =
Builder.CreateIntCast(RHS, Ops.LHS->getType(),
false,
"sh_prom");
2774 if (CGF.getLangOpts().OpenCL)
2776 Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS),
"shr.mask");
2777 else if (CGF.SanOpts.has(SanitizerKind::ShiftExponent) &&
2778 isa<llvm::IntegerType>(Ops.LHS->getType())) {
2781 Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS));
2782 EmitBinOpCheck(std::make_pair(Valid, SanitizerKind::ShiftExponent), Ops);
2785 if (Ops.Ty->hasUnsignedIntegerRepresentation())
2786 return Builder.CreateLShr(Ops.LHS, RHS,
"shr");
2787 return Builder.CreateAShr(Ops.LHS, RHS,
"shr");
2795 default: llvm_unreachable(
"unexpected element type");
2796 case BuiltinType::Char_U:
2797 case BuiltinType::UChar:
2798 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
2799 llvm::Intrinsic::ppc_altivec_vcmpgtub_p;
2800 case BuiltinType::Char_S:
2801 case BuiltinType::SChar:
2802 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
2803 llvm::Intrinsic::ppc_altivec_vcmpgtsb_p;
2804 case BuiltinType::UShort:
2805 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
2806 llvm::Intrinsic::ppc_altivec_vcmpgtuh_p;
2807 case BuiltinType::Short:
2808 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
2809 llvm::Intrinsic::ppc_altivec_vcmpgtsh_p;
2810 case BuiltinType::UInt:
2811 case BuiltinType::ULong:
2812 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
2813 llvm::Intrinsic::ppc_altivec_vcmpgtuw_p;
2814 case BuiltinType::Int:
2815 case BuiltinType::Long:
2816 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
2817 llvm::Intrinsic::ppc_altivec_vcmpgtsw_p;
2818 case BuiltinType::Float:
2819 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p :
2820 llvm::Intrinsic::ppc_altivec_vcmpgtfp_p;
2825 llvm::CmpInst::Predicate UICmpOpc,
2826 llvm::CmpInst::Predicate SICmpOpc,
2827 llvm::CmpInst::Predicate FCmpOpc) {
2828 TestAndClearIgnoreResultAssign();
2835 Value *LHS = CGF.EmitScalarExpr(E->
getLHS());
2836 Value *RHS = CGF.EmitScalarExpr(E->
getRHS());
2837 Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison(
2838 CGF, LHS, RHS, MPT, E->
getOpcode() == BO_NE);
2840 Value *LHS = Visit(E->
getLHS());
2841 Value *RHS = Visit(E->
getRHS());
2847 enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6;
2852 Value *FirstVecArg = LHS,
2853 *SecondVecArg = RHS;
2860 default: llvm_unreachable(
"is not a comparison operation");
2872 std::swap(FirstVecArg, SecondVecArg);
2879 if (ElementKind == BuiltinType::Float) {
2881 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
2882 std::swap(FirstVecArg, SecondVecArg);
2890 if (ElementKind == BuiltinType::Float) {
2892 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
2897 std::swap(FirstVecArg, SecondVecArg);
2902 Value *CR6Param =
Builder.getInt32(CR6);
2903 llvm::Function *F = CGF.CGM.getIntrinsic(ID);
2904 Result =
Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg});
2905 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->
getType(),
2909 if (LHS->getType()->isFPOrFPVectorTy()) {
2910 Result =
Builder.CreateFCmp(FCmpOpc, LHS, RHS,
"cmp");
2912 Result =
Builder.CreateICmp(SICmpOpc, LHS, RHS,
"cmp");
2915 Result =
Builder.CreateICmp(UICmpOpc, LHS, RHS,
"cmp");
2921 return Builder.CreateSExt(Result, ConvertType(E->
getType()),
"sext");
2928 LHS = CGF.EmitComplexExpr(E->
getLHS());
2929 CETy = CTy->getElementType();
2931 LHS.first = Visit(E->
getLHS());
2932 LHS.second = llvm::Constant::getNullValue(LHS.first->getType());
2936 RHS = CGF.EmitComplexExpr(E->
getRHS());
2937 assert(CGF.getContext().hasSameUnqualifiedType(CETy,
2938 CTy->getElementType()) &&
2939 "The element types must always match.");
2942 RHS.first = Visit(E->
getRHS());
2943 RHS.second = llvm::Constant::getNullValue(RHS.first->getType());
2944 assert(CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) &&
2945 "The element types must always match.");
2948 Value *ResultR, *ResultI;
2950 ResultR =
Builder.CreateFCmp(FCmpOpc, LHS.first, RHS.first,
"cmp.r");
2951 ResultI =
Builder.CreateFCmp(FCmpOpc, LHS.second, RHS.second,
"cmp.i");
2955 ResultR =
Builder.CreateICmp(UICmpOpc, LHS.first, RHS.first,
"cmp.r");
2956 ResultI =
Builder.CreateICmp(UICmpOpc, LHS.second, RHS.second,
"cmp.i");
2960 Result =
Builder.CreateAnd(ResultR, ResultI,
"and.ri");
2963 "Complex comparison other than == or != ?");
2964 Result =
Builder.CreateOr(ResultR, ResultI,
"or.ri");
2968 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->
getType(),
2972 Value *ScalarExprEmitter::VisitBinAssign(
const BinaryOperator *E) {
2973 bool Ignore = TestAndClearIgnoreResultAssign();
2980 std::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
2984 std::tie(LHS, RHS) = CGF.EmitARCStoreAutoreleasing(E);
2988 std::tie(LHS, RHS) = CGF.EmitARCStoreUnsafeUnretained(E, Ignore);
2992 RHS = Visit(E->
getRHS());
2994 RHS = CGF.EmitARCStoreWeak(LHS.getAddress(), RHS, Ignore);
3000 RHS = Visit(E->
getRHS());
3007 if (LHS.isBitField())
3008 CGF.EmitStoreThroughBitfieldLValue(
RValue::get(RHS), LHS, &RHS);
3010 CGF.EmitStoreThroughLValue(
RValue::get(RHS), LHS);
3018 if (!CGF.getLangOpts().CPlusPlus)
3022 if (!LHS.isVolatileQualified())
3026 return EmitLoadOfLValue(LHS, E->
getExprLoc());
3029 Value *ScalarExprEmitter::VisitBinLAnd(
const BinaryOperator *E) {
3032 CGF.incrementProfileCounter(E);
3034 Value *LHS = Visit(E->
getLHS());
3035 Value *RHS = Visit(E->
getRHS());
3036 Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
3037 if (LHS->getType()->isFPOrFPVectorTy()) {
3038 LHS =
Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero,
"cmp");
3039 RHS =
Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero,
"cmp");
3041 LHS =
Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero,
"cmp");
3042 RHS =
Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero,
"cmp");
3045 return Builder.CreateSExt(And, ConvertType(E->
getType()),
"sext");
3053 if (CGF.ConstantFoldsToSimpleInteger(E->
getLHS(), LHSCondVal)) {
3055 CGF.incrementProfileCounter(E);
3057 Value *RHSCond = CGF.EvaluateExprAsBool(E->
getRHS());
3059 return Builder.CreateZExtOrBitCast(RHSCond, ResTy,
"land.ext");
3063 if (!CGF.ContainsLabel(E->
getRHS()))
3064 return llvm::Constant::getNullValue(ResTy);
3067 llvm::BasicBlock *ContBlock = CGF.createBasicBlock(
"land.end");
3068 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock(
"land.rhs");
3073 CGF.EmitBranchOnBoolExpr(E->
getLHS(), RHSBlock, ContBlock,
3074 CGF.getProfileCount(E->
getRHS()));
3081 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
3083 PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI);
3086 CGF.EmitBlock(RHSBlock);
3087 CGF.incrementProfileCounter(E);
3088 Value *RHSCond = CGF.EvaluateExprAsBool(E->
getRHS());
3092 RHSBlock =
Builder.GetInsertBlock();
3098 CGF.EmitBlock(ContBlock);
3101 PN->addIncoming(RHSCond, RHSBlock);
3104 return Builder.CreateZExtOrBitCast(PN, ResTy,
"land.ext");
3110 CGF.incrementProfileCounter(E);
3112 Value *LHS = Visit(E->
getLHS());
3113 Value *RHS = Visit(E->
getRHS());
3114 Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
3115 if (LHS->getType()->isFPOrFPVectorTy()) {
3116 LHS =
Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero,
"cmp");
3117 RHS =
Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero,
"cmp");
3119 LHS =
Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero,
"cmp");
3120 RHS =
Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero,
"cmp");
3122 Value *Or =
Builder.CreateOr(LHS, RHS);
3123 return Builder.CreateSExt(Or, ConvertType(E->
getType()),
"sext");
3131 if (CGF.ConstantFoldsToSimpleInteger(E->
getLHS(), LHSCondVal)) {
3133 CGF.incrementProfileCounter(E);
3135 Value *RHSCond = CGF.EvaluateExprAsBool(E->
getRHS());
3137 return Builder.CreateZExtOrBitCast(RHSCond, ResTy,
"lor.ext");
3141 if (!CGF.ContainsLabel(E->
getRHS()))
3142 return llvm::ConstantInt::get(ResTy, 1);
3145 llvm::BasicBlock *ContBlock = CGF.createBasicBlock(
"lor.end");
3146 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock(
"lor.rhs");
3151 CGF.EmitBranchOnBoolExpr(E->
getLHS(), ContBlock, RHSBlock,
3152 CGF.getCurrentProfileCount() -
3153 CGF.getProfileCount(E->
getRHS()));
3160 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
3162 PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI);
3167 CGF.EmitBlock(RHSBlock);
3168 CGF.incrementProfileCounter(E);
3169 Value *RHSCond = CGF.EvaluateExprAsBool(E->
getRHS());
3174 RHSBlock =
Builder.GetInsertBlock();
3178 CGF.EmitBlock(ContBlock);
3179 PN->addIncoming(RHSCond, RHSBlock);
3182 return Builder.CreateZExtOrBitCast(PN, ResTy,
"lor.ext");
3185 Value *ScalarExprEmitter::VisitBinComma(
const BinaryOperator *E) {
3186 CGF.EmitIgnoredExpr(E->
getLHS());
3187 CGF.EnsureInsertPoint();
3188 return Visit(E->
getRHS());
3213 Value *ScalarExprEmitter::
3215 TestAndClearIgnoreResultAssign();
3227 if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
3228 Expr *live = lhsExpr, *dead = rhsExpr;
3229 if (!CondExprBool) std::swap(live, dead);
3232 if (!CGF.ContainsLabel(dead)) {
3234 CGF.incrementProfileCounter(E);
3235 Value *Result = Visit(live);
3241 Result = llvm::UndefValue::get(CGF.ConvertType(E->
getType()));
3249 if (CGF.getLangOpts().OpenCL
3251 CGF.incrementProfileCounter(E);
3253 llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
3258 llvm::VectorType *vecTy = cast<llvm::VectorType>(condType);
3260 unsigned numElem = vecTy->getNumElements();
3261 llvm::Type *elemType = vecTy->getElementType();
3263 llvm::Value *zeroVec = llvm::Constant::getNullValue(vecTy);
3266 llvm::VectorType::get(elemType,
3274 bool wasCast =
false;
3275 llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType());
3276 if (rhsVTy->getElementType()->isFloatingPointTy()) {
3277 RHSTmp =
Builder.CreateBitCast(RHS, tmp2->getType());
3278 LHSTmp =
Builder.CreateBitCast(LHS, tmp->getType());
3286 tmp5 =
Builder.CreateBitCast(tmp5, RHS->getType());
3296 CGF.incrementProfileCounter(E);
3298 llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr);
3303 assert(!RHS &&
"LHS and RHS types must match");
3306 return Builder.CreateSelect(CondV, LHS, RHS,
"cond");
3309 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock(
"cond.true");
3310 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock(
"cond.false");
3311 llvm::BasicBlock *ContBlock = CGF.createBasicBlock(
"cond.end");
3314 CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock,
3315 CGF.getProfileCount(lhsExpr));
3317 CGF.EmitBlock(LHSBlock);
3318 CGF.incrementProfileCounter(E);
3320 Value *LHS = Visit(lhsExpr);
3323 LHSBlock =
Builder.GetInsertBlock();
3326 CGF.EmitBlock(RHSBlock);
3328 Value *RHS = Visit(rhsExpr);
3331 RHSBlock =
Builder.GetInsertBlock();
3332 CGF.EmitBlock(ContBlock);
3341 llvm::PHINode *PN =
Builder.CreatePHI(LHS->getType(), 2,
"cond");
3342 PN->addIncoming(LHS, LHSBlock);
3343 PN->addIncoming(RHS, RHSBlock);
3347 Value *ScalarExprEmitter::VisitChooseExpr(
ChooseExpr *E) {
3351 Value *ScalarExprEmitter::VisitVAArgExpr(
VAArgExpr *VE) {
3355 CGF.EmitVariablyModifiedType(Ty);
3358 Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
3364 CGF.ErrorUnsupported(VE,
"va_arg expression");
3365 return llvm::UndefValue::get(ArgTy);
3372 if (ArgTy != Val->getType()) {
3373 if (ArgTy->isPointerTy() && !Val->getType()->isPointerTy())
3374 Val =
Builder.CreateIntToPtr(Val, ArgTy);
3376 Val =
Builder.CreateTrunc(Val, ArgTy);
3382 Value *ScalarExprEmitter::VisitBlockExpr(
const BlockExpr *block) {
3383 return CGF.EmitBlockLiteral(block);
3388 Value *Src,
unsigned NumElementsDst) {
3389 llvm::Value *UnV = llvm::UndefValue::get(Src->getType());
3391 Args.push_back(Builder.getInt32(0));
3392 Args.push_back(Builder.getInt32(1));
3393 Args.push_back(Builder.getInt32(2));
3394 if (NumElementsDst == 4)
3395 Args.push_back(llvm::UndefValue::get(CGF.
Int32Ty));
3396 llvm::Constant *Mask = llvm::ConstantVector::get(Args);
3397 return Builder.CreateShuffleVector(Src, UnV, Mask);
3400 Value *ScalarExprEmitter::VisitAsTypeExpr(
AsTypeExpr *E) {
3401 Value *Src = CGF.EmitScalarExpr(E->
getSrcExpr());
3405 unsigned NumElementsSrc = isa<llvm::VectorType>(SrcTy) ?
3406 cast<llvm::VectorType>(SrcTy)->getNumElements() : 0;
3407 unsigned NumElementsDst = isa<llvm::VectorType>(DstTy) ?
3408 cast<llvm::VectorType>(DstTy)->getNumElements() : 0;
3412 if (NumElementsSrc == 3 && NumElementsDst != 3) {
3414 Src =
Builder.CreateBitCast(Src, DstTy);
3415 Src->setName(
"astype");
3422 if (NumElementsSrc != 3 && NumElementsDst == 3) {
3423 auto Vec4Ty = llvm::VectorType::get(DstTy->getVectorElementType(), 4);
3424 Src =
Builder.CreateBitCast(Src, Vec4Ty);
3426 Src->setName(
"astype");
3430 return Builder.CreateBitCast(Src, DstTy,
"astype");
3433 Value *ScalarExprEmitter::VisitAtomicExpr(
AtomicExpr *E) {
3434 return CGF.EmitAtomicExpr(E).getScalarVal();
3445 "Invalid scalar expression to emit");
3447 return ScalarExprEmitter(*
this, IgnoreResultAssign)
3448 .Visit(const_cast<Expr *>(E));
3457 "Invalid scalar expression to emit");
3458 return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy, Loc);
3468 "Invalid complex -> scalar conversion");
3469 return ScalarExprEmitter(*
this)
3470 .EmitComplexToScalarConversion(Src, SrcTy, DstTy, Loc);
3476 bool isInc,
bool isPre) {
3477 return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre);
3500 ScalarExprEmitter Scalar(*
this);
3501 Value *Result =
nullptr;
3503 #define COMPOUND_OP(Op) \
3504 case BO_##Op##Assign: \
3505 return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \
3541 llvm_unreachable(
"Not valid compound assignment operators");
3544 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
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
llvm::Value * getPointer() 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.
Address getAddress() const
ParenExpr - This represents a parethesized expression, e.g.
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
const Expr * getResultExpr() const
The generic selection's result expression.
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
bool isBooleanType() const
const LangOptions & getLangOpts() const
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)
Expr * getIndexExpr(unsigned Idx)
bool hadArrayRangeDesignator() const
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
CompoundLiteralExpr - [C99 6.5.2.5].
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
field_iterator field_begin() const
UnaryExprOrTypeTrait getKind() const
unsigned getValue() const
A C++ throw-expression (C++ [except.throw]).
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
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.
RecordDecl - Represents a struct/union/class.
An object to manage conditionally-evaluated expressions.
llvm::Value * EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre)
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
bool isVolatileQualified() const
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isReferenceType() const
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that that type refers to...
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
llvm::APSInt getShuffleMaskIdx(const ASTContext &Ctx, unsigned N) const
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
bool isFPContractable() const
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Describes an C or C++ initializer list.
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
static bool hasScalarEvaluationKind(QualType T)
Expr * getTrueExpr() const
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
CharUnits - This is an opaque type for sizes expressed in character units.
path_iterator path_begin()
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
llvm::PointerType * VoidPtrTy
A builtin binary operation expression such as "x + y" or "x <= y".
RecordDecl * getDecl() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
static Value * tryEmitFMulAdd(const BinOpInfo &op, const CodeGenFunction &CGF, CGBuilderTy &Builder, bool isSub=false)
ObjCStringLiteral, used for Objective-C string literals i.e.
static llvm::Constant * getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, unsigned Off, llvm::Type *I32Ty)
Scope - A scope is a transient data structure that is used while parsing the program.
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Helper class for OffsetOfExpr.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
bool isExtVectorType() const
detail::InMemoryDirectory::const_iterator I
A default argument (C++ [dcl.fct.default]).
static bool ShouldNullCheckClassCastValue(const CastExpr *Cast)
Checking the operand of a load. Must be suitably sized and aligned.
This object can be modified without requiring retains or releases.
Represents the this expression in C++.
field_iterator field_end() const
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource AlignSource=AlignmentSource::Type)
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
Returns lifetime attribute of this type.
CastKind
CastKind - The kind of operation required for a conversion.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
const Expr * getExpr() const
Get the initialization expression that will be used.
Represents a call to the builtin function __builtin_va_arg.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
bool isRealFloatingType() const
Floating point categories.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
const ObjCMethodDecl * getMethodDecl() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
llvm::Value * getPointer() const
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Expr - This represents one expression.
Allow any unmodeled side effect.
bool isAnyComplexType() const
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
llvm::Value * EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified complex type to the specified destination type, where the destination type is an LLVM scalar type.
SourceLocation getExprLoc() const LLVM_READONLY
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
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.
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
llvm::IntegerType * Int32Ty
An RAII object to record that we're evaluating a statement expression.
Expr * getSubExpr() const
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
An expression that sends a message to the given Objective-C object or class.
unsigned getNumComponents() const
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Represents a GCC generic vector type.
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...
The scope of a CXXDefaultInitExpr.
QualType getElementType() const
QualType getComputationLHSType() const
The result type of a method or function.
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
QualType getComputationResultType() const
unsigned getNumSubExprs() const
getNumSubExprs - Return the size of the SubExprs array.
The l-value was considered opaque, so the alignment was determined from a type.
There is no lifetime qualification on this type.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Assigning into this object requires the old value to be released and the new value to be retained...
A field in a dependent type, known only by its name.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
ASTContext & getContext() const
Encodes a location in the source.
CharUnits getPointerAlign() const
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
const TemplateArgument * iterator
SourceLocation getExprLoc() const LLVM_READONLY
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > PL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
A scoped helper to set the current debug location to the specified location or preferred location of ...
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
bool isCompoundAssignmentOp() const
SanitizerSet SanOpts
Sanitizers enabled for this function.
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>.
ObjCProtocolExpr used for protocol expression in Objective-C.
const CodeGenOptions & getCodeGenOpts() const
TypeCheckKind
Situations in which we might emit a check for the suitability of a pointer or glvalue.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
QualType getReturnType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isVectorType() const
An expression trait intrinsic.
uint64_t getValue() const
Assigning into this object requires a lifetime extension.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
ObjCBoxedExpr - used for generalized expression boxing.
QualType getType() const
Return the type wrapped by this type source info.
const OffsetOfNode & getComponent(unsigned Idx) const
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
QualType getPointeeType() const
CompoundAssignOperator - For compound assignments (e.g.
Represents a C11 generic selection.
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
AddrLabelExpr - The GNU address of label extension, representing &&label.
Expr * getReplacement() const
SourceLocation getExprLoc() const LLVM_READONLY
const Expr * getExpr() const
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
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.
Checking the destination of a store. Must be suitably sized and aligned.
detail::InMemoryDirectory::const_iterator E
A pointer to member type per C++ 8.3.3 - Pointers to members.
ExplicitCastExpr - An explicit cast written in the source code.
static Value * ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF, Value *Src, unsigned NumElementsDst)
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
llvm::APFloat getValue() const
const VariableArrayType * getAsVariableArrayType(QualType T) const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
#define VISITCOMP(CODE, UI, SI, FP)
Represents a pointer to an Objective C object.
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Complex values, per C99 6.2.5p11.
const T * getAs() const
Member-template getAs<specific type>'.
Checking the operand of a static_cast to a derived pointer type.
Expr * getFalseExpr() const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
QualType getTypeOfArgument() const
Gets the argument type, or the type of the argument expression, whichever is appropriate.
QualType getCanonicalType() const
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
An implicit indirection through a C++ base class, when the field found is in a base class...
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
bool isFunctionType() const
ExtVectorType - Extended vector type.
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.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
const Expr * getSubExpr() const
Represents a C++ struct/union/class.
BoundNodesTreeBuilder *const Builder
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
llvm::Type * ConvertType(QualType T)
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
FieldDecl * getField() const
For a field offsetof node, returns the field.
This class is used for builtin types like 'int'.
std::pair< llvm::Value *, QualType > getVLASize(const VariableArrayType *vla)
getVLASize - Returns an LLVM value that corresponds to the size, in non-variably-sized elements...
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E)
llvm::Value * EmitScalarConversion(llvm::Value *Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified type to the specified destination type, both of which are LLVM s...
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
A reference to a declared variable, function, enum, etc.
static RValue get(llvm::Value *V)
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
Set the IRBuilder to not attach debug locations.
const Expr * getInit(unsigned Init) const
LValue - This represents an lvalue references.
A boolean literal, per ([C++ lex.bool] Boolean literals).
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Represents a C array with a specified size that is not an integer-constant-expression.
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)
isCheapEnoughToEvaluateUnconditionally - Return true if the specified expression is cheap enough and ...
Represents an implicitly-generated value initialization of an object of a given type.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Kind getKind() const
Determine what kind of offsetof node this is.
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.