30 #include "llvm/ADT/APFixedPoint.h"
31 #include "llvm/ADT/Optional.h"
32 #include "llvm/IR/CFG.h"
33 #include "llvm/IR/Constants.h"
34 #include "llvm/IR/DataLayout.h"
35 #include "llvm/IR/DerivedTypes.h"
36 #include "llvm/IR/FixedPointBuilder.h"
37 #include "llvm/IR/Function.h"
38 #include "llvm/IR/GetElementPtrTypeIterator.h"
39 #include "llvm/IR/GlobalVariable.h"
40 #include "llvm/IR/Intrinsics.h"
41 #include "llvm/IR/IntrinsicsPowerPC.h"
42 #include "llvm/IR/MatrixBuilder.h"
43 #include "llvm/IR/Module.h"
44 #include "llvm/Support/TypeSize.h"
47 using namespace clang;
48 using namespace CodeGen;
62 bool mayHaveIntegerOverflow(llvm::ConstantInt *LHS, llvm::ConstantInt *RHS,
67 const auto &LHSAP = LHS->getValue();
68 const auto &RHSAP = RHS->getValue();
70 Result =
Signed ? LHSAP.sadd_ov(RHSAP, Overflow)
71 : LHSAP.uadd_ov(RHSAP, Overflow);
72 }
else if (
Opcode == BO_Sub) {
73 Result =
Signed ? LHSAP.ssub_ov(RHSAP, Overflow)
74 : LHSAP.usub_ov(RHSAP, Overflow);
75 }
else if (
Opcode == BO_Mul) {
76 Result =
Signed ? LHSAP.smul_ov(RHSAP, Overflow)
77 : LHSAP.umul_ov(RHSAP, Overflow);
79 if (Signed && !RHS->isZero())
80 Result = LHSAP.sdiv_ov(RHSAP, Overflow);
96 bool mayHaveIntegerOverflow()
const {
98 auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS);
99 auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS);
100 if (!LHSCI || !RHSCI)
104 return ::mayHaveIntegerOverflow(
109 bool isDivremOp()
const {
115 bool mayHaveIntegerDivisionByZero()
const {
117 if (
auto *CI = dyn_cast<llvm::ConstantInt>(RHS))
123 bool mayHaveFloatDivisionByZero()
const {
125 if (
auto *CFP = dyn_cast<llvm::ConstantFP>(RHS))
126 return CFP->isZero();
133 bool isFixedPointOp()
const {
136 if (
const auto *BinOp = dyn_cast<BinaryOperator>(E)) {
137 QualType LHSType = BinOp->getLHS()->getType();
138 QualType RHSType = BinOp->getRHS()->getType();
141 if (
const auto *UnOp = dyn_cast<UnaryOperator>(E))
142 return UnOp->getSubExpr()->getType()->isFixedPointType();
147 static bool MustVisitNullValue(
const Expr *E) {
170 static bool IsWidenedIntegerOp(
const ASTContext &Ctx,
const Expr *E) {
171 return getUnwidenedIntegerType(Ctx, E).hasValue();
175 static bool CanElideOverflowCheck(
const ASTContext &Ctx,
const BinOpInfo &Op) {
176 assert((isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) &&
177 "Expected a unary or binary operator");
181 if (!Op.mayHaveIntegerOverflow())
185 if (
const auto *UO = dyn_cast<UnaryOperator>(Op.E))
186 return !UO->canOverflow();
190 const auto *BO = cast<BinaryOperator>(Op.E);
191 auto OptionalLHSTy = getUnwidenedIntegerType(Ctx, BO->getLHS());
195 auto OptionalRHSTy = getUnwidenedIntegerType(Ctx, BO->getRHS());
204 if ((Op.Opcode != BO_Mul && Op.Opcode != BO_MulAssign) ||
210 unsigned PromotedSize = Ctx.
getTypeSize(Op.E->getType());
211 return (2 * Ctx.
getTypeSize(LHSTy)) < PromotedSize ||
215 class ScalarExprEmitter
219 bool IgnoreResultAssign;
220 llvm::LLVMContext &VMContext;
224 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
225 VMContext(cgf.getLLVMContext()) {
232 bool TestAndClearIgnoreResultAssign() {
233 bool I = IgnoreResultAssign;
234 IgnoreResultAssign =
false;
244 void EmitBinOpCheck(
ArrayRef<std::pair<Value *, SanitizerMask>> Checks,
245 const BinOpInfo &Info);
251 void EmitLValueAlignmentAssumption(
const Expr *E,
Value *
V) {
252 const AlignValueAttr *AVAttr =
nullptr;
253 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
257 if (
const auto *TTy =
259 AVAttr = TTy->getDecl()->
getAttr<AlignValueAttr>();
266 if (isa<ParmVarDecl>(VD) && !CGF.
SanOpts.
has(SanitizerKind::Alignment))
269 AVAttr = VD->
getAttr<AlignValueAttr>();
274 if (
const auto *TTy =
275 dyn_cast<TypedefType>(E->
getType()))
276 AVAttr = TTy->getDecl()->getAttr<AlignValueAttr>();
282 llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(AlignmentValue);
293 EmitLValueAlignmentAssumption(E,
V);
303 void EmitFloatConversionCheck(
Value *OrigSrc,
QualType OrigSrcType,
309 enum ImplicitConversionCheckKind :
unsigned char {
310 ICCK_IntegerTruncation = 0,
311 ICCK_UnsignedIntegerTruncation = 1,
312 ICCK_SignedIntegerTruncation = 2,
313 ICCK_IntegerSignChange = 3,
314 ICCK_SignedIntegerTruncationOrSignChange = 4,
330 struct ScalarConversionOpts {
331 bool TreatBooleanAsSigned;
332 bool EmitImplicitIntegerTruncationChecks;
333 bool EmitImplicitIntegerSignChangeChecks;
335 ScalarConversionOpts()
336 : TreatBooleanAsSigned(
false),
337 EmitImplicitIntegerTruncationChecks(
false),
338 EmitImplicitIntegerSignChangeChecks(
false) {}
341 : TreatBooleanAsSigned(
false),
342 EmitImplicitIntegerTruncationChecks(
344 EmitImplicitIntegerSignChangeChecks(
348 llvm::Type *SrcTy, llvm::Type *DstTy,
349 ScalarConversionOpts Opts);
353 ScalarConversionOpts Opts = ScalarConversionOpts());
372 llvm::Value *
Zero = llvm::Constant::getNullValue(
V->getType());
373 return Builder.CreateFCmpUNE(
V,
Zero,
"tobool");
380 return Builder.CreateICmpNE(
V,
Zero,
"tobool");
387 if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(
V)) {
388 if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) {
389 Value *Result = ZI->getOperand(0);
394 ZI->eraseFromParent();
399 return Builder.CreateIsNotNull(
V,
"tobool");
413 llvm_unreachable(
"Stmt can't have complex result type!");
439 return Visit(
GE->getResultExpr());
453 return Builder.getInt(E->
getValue());
456 return Builder.getInt(E->
getValue());
459 return llvm::ConstantFP::get(VMContext, E->
getValue());
462 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
465 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
468 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
471 return EmitNullValue(E->
getType());
474 return EmitNullValue(E->
getType());
480 return Builder.CreateBitCast(
V, ConvertType(E->
getType()));
506 return EmitLoadOfLValue(E);
516 return EmitLoadOfLValue(E);
521 return EmitLoadOfLValue(E);
537 return llvm::ConstantInt::get(Builder.getInt1Ty(), 1);
547 Value *VisitExtVectorElementExpr(
Expr *E) {
return EmitLoadOfLValue(E); }
554 return EmitLoadOfLValue(E);
561 "ArrayInitIndexExpr not inside an ArrayInitLoopExpr?");
566 return EmitNullValue(E->
getType());
570 return VisitCastExpr(E);
576 return EmitLoadOfLValue(E);
580 EmitLValueAlignmentAssumption(E,
V);
589 return EmitScalarPrePostIncDec(E, LV,
false,
false);
593 return EmitScalarPrePostIncDec(E, LV,
true,
false);
597 return EmitScalarPrePostIncDec(E, LV,
false,
true);
601 return EmitScalarPrePostIncDec(E, LV,
true,
true);
604 llvm::Value *EmitIncDecConsiderOverflowBehavior(
const UnaryOperator *E,
609 bool isInc,
bool isPre);
613 if (isa<MemberPointerType>(E->
getType()))
616 return EmitLValue(E->
getSubExpr()).getPointer(CGF);
621 return EmitLoadOfLValue(E);
625 TestAndClearIgnoreResultAssign();
639 return EmitLoadOfLValue(E);
671 return llvm::ConstantInt::get(ConvertType(E->
getType()), E->
getValue());
683 return llvm::ConstantInt::get(Builder.getInt32Ty(), E->
getValue());
687 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->
getValue());
701 return EmitNullValue(E->
getType());
710 return Builder.getInt1(E->
getValue());
714 Value *EmitMul(
const BinOpInfo &Ops) {
715 if (Ops.Ty->isSignedIntegerOrEnumerationType()) {
716 switch (CGF.
getLangOpts().getSignedOverflowBehavior()) {
718 return Builder.CreateMul(Ops.LHS, Ops.RHS,
"mul");
720 if (!CGF.
SanOpts.
has(SanitizerKind::SignedIntegerOverflow))
721 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS,
"mul");
724 if (CanElideOverflowCheck(CGF.
getContext(), Ops))
725 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS,
"mul");
726 return EmitOverflowCheckedBinOp(Ops);
730 if (Ops.Ty->isConstantMatrixType()) {
731 llvm::MatrixBuilder MB(Builder);
734 auto *BO = cast<BinaryOperator>(Ops.E);
735 auto *LHSMatTy = dyn_cast<ConstantMatrixType>(
736 BO->getLHS()->getType().getCanonicalType());
737 auto *RHSMatTy = dyn_cast<ConstantMatrixType>(
738 BO->getRHS()->getType().getCanonicalType());
740 if (LHSMatTy && RHSMatTy)
741 return MB.CreateMatrixMultiply(Ops.LHS, Ops.RHS, LHSMatTy->getNumRows(),
742 LHSMatTy->getNumColumns(),
743 RHSMatTy->getNumColumns());
744 return MB.CreateScalarMultiply(Ops.LHS, Ops.RHS);
747 if (Ops.Ty->isUnsignedIntegerType() &&
748 CGF.
SanOpts.
has(SanitizerKind::UnsignedIntegerOverflow) &&
749 !CanElideOverflowCheck(CGF.
getContext(), Ops))
750 return EmitOverflowCheckedBinOp(Ops);
752 if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
755 return Builder.CreateFMul(Ops.LHS, Ops.RHS,
"mul");
757 if (Ops.isFixedPointOp())
758 return EmitFixedPointBinOp(Ops);
759 return Builder.CreateMul(Ops.LHS, Ops.RHS,
"mul");
763 Value *EmitOverflowCheckedBinOp(
const BinOpInfo &Ops);
766 void EmitUndefinedBehaviorIntegerDivAndRemCheck(
const BinOpInfo &Ops,
767 llvm::Value *
Zero,
bool isDiv);
775 Value *EmitDiv(
const BinOpInfo &Ops);
776 Value *EmitRem(
const BinOpInfo &Ops);
777 Value *EmitAdd(
const BinOpInfo &Ops);
778 Value *EmitSub(
const BinOpInfo &Ops);
779 Value *EmitShl(
const BinOpInfo &Ops);
780 Value *EmitShr(
const BinOpInfo &Ops);
781 Value *EmitAnd(
const BinOpInfo &Ops) {
782 return Builder.CreateAnd(Ops.LHS, Ops.RHS,
"and");
784 Value *EmitXor(
const BinOpInfo &Ops) {
785 return Builder.CreateXor(Ops.LHS, Ops.RHS,
"xor");
787 Value *EmitOr (
const BinOpInfo &Ops) {
788 return Builder.CreateOr(Ops.LHS, Ops.RHS,
"or");
792 Value *EmitFixedPointBinOp(
const BinOpInfo &Ops);
796 Value *(ScalarExprEmitter::*F)(
const BinOpInfo &),
800 Value *(ScalarExprEmitter::*F)(
const BinOpInfo &));
803 #define HANDLEBINOP(OP) \
804 Value *VisitBin ## OP(const BinaryOperator *E) { \
805 return Emit ## OP(EmitBinOps(E)); \
807 Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \
808 return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \
824 llvm::CmpInst::Predicate SICmpOpc,
825 llvm::CmpInst::Predicate FCmpOpc,
bool IsSignaling);
826 #define VISITCOMP(CODE, UI, SI, FP, SIG) \
827 Value *VisitBin##CODE(const BinaryOperator *E) { \
828 return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \
829 llvm::FCmpInst::FP, SIG); }
844 Value *VisitBinPtrMemD(
const Expr *E) {
return EmitLoadOfLValue(E); }
845 Value *VisitBinPtrMemI(
const Expr *E) {
return EmitLoadOfLValue(E); }
880 assert(SrcType.
isCanonical() &&
"EmitScalarConversion strips typedefs");
883 return EmitFloatToBoolConversion(Src);
888 assert((SrcType->
isIntegerType() || isa<llvm::PointerType>(Src->getType())) &&
889 "Unknown scalar type to convert");
891 if (isa<llvm::IntegerType>(Src->getType()))
892 return EmitIntToBoolConversion(Src);
894 assert(isa<llvm::PointerType>(Src->getType()));
895 return EmitPointerToBoolConversion(Src, SrcType);
898 void ScalarExprEmitter::EmitFloatConversionCheck(
901 assert(SrcType->
isFloatingType() &&
"not a conversion from floating point");
902 if (!isa<llvm::IntegerType>(DstTy))
909 llvm::Value *Check =
nullptr;
910 const llvm::fltSemantics &SrcSema =
919 APSInt Min = APSInt::getMinValue(Width, Unsigned);
920 APFloat MinSrc(SrcSema, APFloat::uninitialized);
921 if (MinSrc.convertFromAPInt(Min, !Unsigned, APFloat::rmTowardZero) &
925 MinSrc = APFloat::getInf(SrcSema,
true);
929 MinSrc.subtract(APFloat(SrcSema, 1), APFloat::rmTowardNegative);
931 APSInt Max = APSInt::getMaxValue(Width, Unsigned);
932 APFloat MaxSrc(SrcSema, APFloat::uninitialized);
933 if (MaxSrc.convertFromAPInt(Max, !Unsigned, APFloat::rmTowardZero) &
937 MaxSrc = APFloat::getInf(SrcSema,
false);
941 MaxSrc.add(APFloat(SrcSema, 1), APFloat::rmTowardPositive);
946 const llvm::fltSemantics &
Sema =
949 MinSrc.convert(
Sema, APFloat::rmTowardZero, &IsInexact);
950 MaxSrc.convert(
Sema, APFloat::rmTowardZero, &IsInexact);
954 Builder.CreateFCmpOGT(Src, llvm::ConstantFP::get(VMContext, MinSrc));
956 Builder.CreateFCmpOLT(Src, llvm::ConstantFP::get(VMContext, MaxSrc));
957 Check = Builder.CreateAnd(
GE,
LE);
962 CGF.
EmitCheck(std::make_pair(Check, SanitizerKind::FloatCastOverflow),
963 SanitizerHandler::FloatCastOverflow, StaticArgs, OrigSrc);
968 static std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
969 std::pair<llvm::Value *, SanitizerMask>>
972 llvm::Type *SrcTy = Src->getType();
973 llvm::Type *DstTy = Dst->getType();
978 assert(SrcTy->getScalarSizeInBits() > Dst->getType()->getScalarSizeInBits());
979 assert(isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) &&
980 "non-integer llvm type");
987 ScalarExprEmitter::ImplicitConversionCheckKind
Kind;
989 if (!SrcSigned && !DstSigned) {
990 Kind = ScalarExprEmitter::ICCK_UnsignedIntegerTruncation;
991 Mask = SanitizerKind::ImplicitUnsignedIntegerTruncation;
993 Kind = ScalarExprEmitter::ICCK_SignedIntegerTruncation;
994 Mask = SanitizerKind::ImplicitSignedIntegerTruncation;
997 llvm::Value *Check =
nullptr;
999 Check = Builder.CreateIntCast(Dst, SrcTy, DstSigned,
"anyext");
1001 Check = Builder.CreateICmpEQ(Check, Src,
"truncheck");
1003 return std::make_pair(
Kind, std::make_pair(Check, Mask));
1011 void ScalarExprEmitter::EmitIntegerTruncationCheck(
Value *Src,
QualType SrcType,
1023 unsigned SrcBits = Src->getType()->getScalarSizeInBits();
1024 unsigned DstBits = Dst->getType()->getScalarSizeInBits();
1026 if (SrcBits <= DstBits)
1029 assert(!DstType->
isBooleanType() &&
"we should not get here with booleans.");
1036 if (CGF.
SanOpts.
has(SanitizerKind::ImplicitIntegerSignChange) &&
1037 (!SrcSigned && DstSigned))
1042 std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
1043 std::pair<llvm::Value *, SanitizerMask>>
1052 llvm::Constant *StaticArgs[] = {
1055 llvm::ConstantInt::get(Builder.getInt8Ty(), Check.first)};
1056 CGF.
EmitCheck(Check.second, SanitizerHandler::ImplicitConversion, StaticArgs,
1062 static std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
1063 std::pair<llvm::Value *, SanitizerMask>>
1066 llvm::Type *SrcTy = Src->getType();
1067 llvm::Type *DstTy = Dst->getType();
1069 assert(isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) &&
1070 "non-integer llvm type");
1076 unsigned SrcBits = SrcTy->getScalarSizeInBits();
1077 unsigned DstBits = DstTy->getScalarSizeInBits();
1081 assert(((SrcBits != DstBits) || (SrcSigned != DstSigned)) &&
1082 "either the widths should be different, or the signednesses.");
1086 const char *Name) ->
Value * {
1088 bool VSigned = VType->isSignedIntegerOrEnumerationType();
1089 llvm::Type *VTy =
V->getType();
1093 return llvm::ConstantInt::getFalse(VTy->getContext());
1096 llvm::Constant *
Zero = llvm::ConstantInt::get(VTy, 0);
1099 return Builder.CreateICmp(llvm::ICmpInst::ICMP_SLT,
V,
Zero,
1100 llvm::Twine(Name) +
"." +
V->getName() +
1101 ".negativitycheck");
1105 llvm::Value *SrcIsNegative = EmitIsNegativeTest(Src, SrcType,
"src");
1107 llvm::Value *DstIsNegative = EmitIsNegativeTest(Dst, DstType,
"dst");
1112 llvm::Value *Check =
nullptr;
1113 Check = Builder.CreateICmpEQ(SrcIsNegative, DstIsNegative,
"signchangecheck");
1115 return std::make_pair(
1116 ScalarExprEmitter::ICCK_IntegerSignChange,
1117 std::make_pair(Check, SanitizerKind::ImplicitIntegerSignChange));
1120 void ScalarExprEmitter::EmitIntegerSignChangeCheck(
Value *Src,
QualType SrcType,
1123 if (!CGF.
SanOpts.
has(SanitizerKind::ImplicitIntegerSignChange))
1126 llvm::Type *SrcTy = Src->getType();
1127 llvm::Type *DstTy = Dst->getType();
1137 unsigned SrcBits = SrcTy->getScalarSizeInBits();
1138 unsigned DstBits = DstTy->getScalarSizeInBits();
1145 if (SrcSigned == DstSigned && SrcBits == DstBits)
1149 if (!SrcSigned && !DstSigned)
1154 if ((DstBits > SrcBits) && DstSigned)
1156 if (CGF.
SanOpts.
has(SanitizerKind::ImplicitSignedIntegerTruncation) &&
1157 (SrcBits > DstBits) && SrcSigned) {
1167 std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
1168 std::pair<llvm::Value *, SanitizerMask>>
1172 ImplicitConversionCheckKind CheckKind;
1178 CheckKind = Check.first;
1179 Checks.emplace_back(Check.second);
1181 if (CGF.
SanOpts.
has(SanitizerKind::ImplicitSignedIntegerTruncation) &&
1182 (SrcBits > DstBits) && !SrcSigned && DstSigned) {
1188 CheckKind = ICCK_SignedIntegerTruncationOrSignChange;
1189 Checks.emplace_back(Check.second);
1193 llvm::Constant *StaticArgs[] = {
1196 llvm::ConstantInt::get(Builder.getInt8Ty(), CheckKind)};
1198 CGF.
EmitCheck(Checks, SanitizerHandler::ImplicitConversion, StaticArgs,
1203 QualType DstType, llvm::Type *SrcTy,
1205 ScalarConversionOpts Opts) {
1207 llvm::Type *SrcElementTy;
1208 llvm::Type *DstElementTy;
1212 SrcElementTy = cast<llvm::VectorType>(SrcTy)->getElementType();
1213 DstElementTy = cast<llvm::VectorType>(DstTy)->getElementType();
1218 "cannot cast between matrix and non-matrix types");
1219 SrcElementTy = SrcTy;
1220 DstElementTy = DstTy;
1221 SrcElementType = SrcType;
1222 DstElementType = DstType;
1225 if (isa<llvm::IntegerType>(SrcElementTy)) {
1227 if (SrcElementType->
isBooleanType() && Opts.TreatBooleanAsSigned) {
1231 if (isa<llvm::IntegerType>(DstElementTy))
1232 return Builder.CreateIntCast(Src, DstTy, InputSigned,
"conv");
1234 return Builder.CreateSIToFP(Src, DstTy,
"conv");
1235 return Builder.CreateUIToFP(Src, DstTy,
"conv");
1238 if (isa<llvm::IntegerType>(DstElementTy)) {
1239 assert(SrcElementTy->isFloatingPointTy() &&
"Unknown real conversion");
1247 IsSigned ? llvm::Intrinsic::fptosi_sat : llvm::Intrinsic::fptoui_sat;
1248 return Builder.CreateCall(CGF.
CGM.
getIntrinsic(IID, {DstTy, SrcTy}), Src);
1252 return Builder.CreateFPToSI(Src, DstTy,
"conv");
1253 return Builder.CreateFPToUI(Src, DstTy,
"conv");
1256 if (DstElementTy->getTypeID() < SrcElementTy->getTypeID())
1257 return Builder.CreateFPTrunc(Src, DstTy,
"conv");
1258 return Builder.CreateFPExt(Src, DstTy,
"conv");
1266 ScalarConversionOpts Opts) {
1281 return Builder.CreateIsNotNull(Src,
"tobool");
1284 return EmitFixedPointConversion(Src, SrcType, DstType, Loc);
1287 "Unhandled scalar conversion from a fixed point type to another type.");
1291 return EmitFixedPointConversion(Src, SrcType, DstType, Loc);
1294 "Unhandled scalar conversion to a fixed point type from another type.");
1297 QualType NoncanonicalSrcType = SrcType;
1298 QualType NoncanonicalDstType = DstType;
1302 if (SrcType == DstType)
return Src;
1306 llvm::Value *OrigSrc = Src;
1308 llvm::Type *SrcTy = Src->getType();
1312 return EmitConversionToBool(Src, SrcType);
1314 llvm::Type *DstTy = ConvertType(DstType);
1319 if (DstTy->isFloatingPointTy()) {
1321 return Builder.CreateCall(
1329 Src = Builder.CreateCall(
1334 Src = Builder.CreateFPExt(Src, CGF.
CGM.
FloatTy,
"conv");
1342 if (SrcTy == DstTy) {
1343 if (Opts.EmitImplicitIntegerSignChangeChecks)
1344 EmitIntegerSignChangeCheck(Src, NoncanonicalSrcType, Src,
1345 NoncanonicalDstType, Loc);
1353 if (
auto DstPT = dyn_cast<llvm::PointerType>(DstTy)) {
1355 if (isa<llvm::PointerType>(SrcTy))
1356 return Builder.CreateBitCast(Src, DstTy,
"conv");
1358 assert(SrcType->
isIntegerType() &&
"Not ptr->ptr or int->ptr conversion?");
1363 llvm::Value* IntResult =
1364 Builder.CreateIntCast(Src, MiddleTy, InputSigned,
"conv");
1366 return Builder.CreateIntToPtr(IntResult, DstTy,
"conv");
1369 if (isa<llvm::PointerType>(SrcTy)) {
1371 assert(isa<llvm::IntegerType>(DstTy) &&
"not ptr->int?");
1372 return Builder.CreatePtrToInt(Src, DstTy,
"conv");
1381 "Splatted expr doesn't match with vector element type?");
1384 unsigned NumElements = cast<llvm::FixedVectorType>(DstTy)->getNumElements();
1385 return Builder.CreateVectorSplat(NumElements, Src,
"splat");
1389 return EmitScalarCast(Src, SrcType, DstType, SrcTy, DstTy, Opts);
1391 if (isa<llvm::VectorType>(SrcTy) || isa<llvm::VectorType>(DstTy)) {
1393 llvm::TypeSize SrcSize = SrcTy->getPrimitiveSizeInBits();
1394 llvm::TypeSize DstSize = DstTy->getPrimitiveSizeInBits();
1395 if (SrcSize == DstSize)
1396 return Builder.CreateBitCast(Src, DstTy,
"conv");
1405 llvm::Type *SrcElementTy = cast<llvm::VectorType>(SrcTy)->getElementType();
1406 llvm::Type *DstElementTy = cast<llvm::VectorType>(DstTy)->getElementType();
1409 assert(((SrcElementTy->isIntegerTy() &&
1410 DstElementTy->isIntegerTy()) ||
1411 (SrcElementTy->isFloatingPointTy() &&
1412 DstElementTy->isFloatingPointTy())) &&
1413 "unexpected conversion between a floating-point vector and an "
1417 if (SrcElementTy->isIntegerTy())
1418 return Builder.CreateIntCast(Src, DstTy,
false,
"conv");
1421 if (SrcSize > DstSize)
1422 return Builder.CreateFPTrunc(Src, DstTy,
"conv");
1425 return Builder.CreateFPExt(Src, DstTy,
"conv");
1429 Value *Res =
nullptr;
1430 llvm::Type *ResTy = DstTy;
1437 if (CGF.
SanOpts.
has(SanitizerKind::FloatCastOverflow) &&
1439 EmitFloatConversionCheck(OrigSrc, OrigSrcType, Src, SrcType, DstType, DstTy,
1445 if (SrcTy->isFloatingPointTy()) {
1449 return Builder.CreateCall(
1452 return Builder.CreateFPTrunc(Src, DstTy);
1457 Res = EmitScalarCast(Src, SrcType, DstType, SrcTy, DstTy, Opts);
1459 if (DstTy != ResTy) {
1461 assert(ResTy->isIntegerTy(16) &&
"Only half FP requires extra conversion");
1462 Res = Builder.CreateCall(
1466 Res = Builder.CreateFPTrunc(Res, ResTy,
"conv");
1470 if (Opts.EmitImplicitIntegerTruncationChecks)
1471 EmitIntegerTruncationCheck(Src, NoncanonicalSrcType, Res,
1472 NoncanonicalDstType, Loc);
1474 if (Opts.EmitImplicitIntegerSignChangeChecks)
1475 EmitIntegerSignChangeCheck(Src, NoncanonicalSrcType, Res,
1476 NoncanonicalDstType, Loc);
1484 llvm::FixedPointBuilder<CGBuilderTy> FPBuilder(Builder);
1485 llvm::Value *Result;
1487 Result = FPBuilder.CreateFloatingToFixed(Src,
1490 Result = FPBuilder.CreateFixedToFloating(Src,
1492 ConvertType(DstTy));
1498 Result = FPBuilder.CreateFixedToInteger(Src, SrcFPSema,
1499 DstFPSema.getWidth(),
1500 DstFPSema.isSigned());
1502 Result = FPBuilder.CreateIntegerToFixed(Src, SrcFPSema.isSigned(),
1505 Result = FPBuilder.CreateFixedToFixed(Src, SrcFPSema, DstFPSema);
1512 Value *ScalarExprEmitter::EmitComplexToScalarConversion(
1521 Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
1522 Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy, Loc);
1523 return Builder.CreateOr(Src.first, Src.second,
"tobool");
1530 return EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
1541 void ScalarExprEmitter::EmitBinOpCheck(
1542 ArrayRef<std::pair<Value *, SanitizerMask>> Checks,
const BinOpInfo &Info) {
1554 if (UO && UO->
getOpcode() == UO_Minus) {
1555 Check = SanitizerHandler::NegateOverflow;
1557 DynamicData.push_back(Info.RHS);
1561 Check = SanitizerHandler::ShiftOutOfBounds;
1563 StaticData.push_back(
1565 StaticData.push_back(
1569 Check = SanitizerHandler::DivremOverflow;
1574 case BO_Add: Check = SanitizerHandler::AddOverflow;
break;
1575 case BO_Sub: Check = SanitizerHandler::SubOverflow;
break;
1576 case BO_Mul: Check = SanitizerHandler::MulOverflow;
break;
1577 default: llvm_unreachable(
"unexpected opcode for bin op check");
1581 DynamicData.push_back(Info.LHS);
1582 DynamicData.push_back(Info.RHS);
1585 CGF.
EmitCheck(Checks, Check, StaticData, DynamicData);
1592 Value *ScalarExprEmitter::VisitExpr(
Expr *E) {
1604 llvm::Constant *GlobalConstStr = Builder.CreateGlobalStringPtr(
1610 if (GlobalConstStr->getType()->getPointerAddressSpace() == ExprAS)
1611 return GlobalConstStr;
1613 llvm::PointerType *PtrTy = cast<llvm::PointerType>(GlobalConstStr->getType());
1614 llvm::PointerType *NewPtrTy =
1615 llvm::PointerType::getWithSamePointeeType(PtrTy, ExprAS);
1616 return Builder.CreateAddrSpaceCast(GlobalConstStr, NewPtrTy,
"usn_addr_cast");
1626 auto *LTy = cast<llvm::FixedVectorType>(LHS->getType());
1627 unsigned LHSElts = LTy->getNumElements();
1631 auto *MTy = cast<llvm::FixedVectorType>(Mask->getType());
1635 llvm::ConstantInt::get(MTy, llvm::NextPowerOf2(LHSElts - 1) - 1);
1636 Mask = Builder.CreateAnd(Mask, MaskBits,
"mask");
1644 auto *RTy = llvm::FixedVectorType::get(LTy->getElementType(),
1645 MTy->getNumElements());
1646 Value* NewV = llvm::UndefValue::get(RTy);
1647 for (
unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) {
1648 Value *IIndx = llvm::ConstantInt::get(CGF.
SizeTy, i);
1649 Value *Indx = Builder.CreateExtractElement(Mask, IIndx,
"shuf_idx");
1651 Value *VExt = Builder.CreateExtractElement(LHS, Indx,
"shuf_elt");
1652 NewV = Builder.CreateInsertElement(NewV, VExt, IIndx,
"shuf_ins");
1664 if (Idx.isSigned() && Idx.isAllOnes())
1665 Indices.push_back(-1);
1667 Indices.push_back(Idx.getZExtValue());
1670 return Builder.CreateShuffleVector(V1, V2, Indices,
"shuffle");
1681 if (SrcType == DstType)
return Src;
1684 "ConvertVector source type must be a vector");
1686 "ConvertVector destination type must be a vector");
1688 llvm::Type *SrcTy = Src->getType();
1689 llvm::Type *DstTy = ConvertType(DstType);
1698 assert(SrcTy->isVectorTy() &&
1699 "ConvertVector source IR type must be a vector");
1700 assert(DstTy->isVectorTy() &&
1701 "ConvertVector destination IR type must be a vector");
1703 llvm::Type *SrcEltTy = cast<llvm::VectorType>(SrcTy)->getElementType(),
1704 *DstEltTy = cast<llvm::VectorType>(DstTy)->getElementType();
1706 if (DstEltType->isBooleanType()) {
1707 assert((SrcEltTy->isFloatingPointTy() ||
1708 isa<llvm::IntegerType>(SrcEltTy)) &&
"Unknown boolean conversion");
1710 llvm::Value *
Zero = llvm::Constant::getNullValue(SrcTy);
1711 if (SrcEltTy->isFloatingPointTy()) {
1712 return Builder.CreateFCmpUNE(Src,
Zero,
"tobool");
1714 return Builder.CreateICmpNE(Src,
Zero,
"tobool");
1719 Value *Res =
nullptr;
1721 if (isa<llvm::IntegerType>(SrcEltTy)) {
1723 if (isa<llvm::IntegerType>(DstEltTy))
1724 Res = Builder.CreateIntCast(Src, DstTy, InputSigned,
"conv");
1725 else if (InputSigned)
1726 Res = Builder.CreateSIToFP(Src, DstTy,
"conv");
1728 Res = Builder.CreateUIToFP(Src, DstTy,
"conv");
1729 }
else if (isa<llvm::IntegerType>(DstEltTy)) {
1730 assert(SrcEltTy->isFloatingPointTy() &&
"Unknown real conversion");
1731 if (DstEltType->isSignedIntegerOrEnumerationType())
1732 Res = Builder.CreateFPToSI(Src, DstTy,
"conv");
1734 Res = Builder.CreateFPToUI(Src, DstTy,
"conv");
1736 assert(SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() &&
1737 "Unknown real conversion");
1738 if (DstEltTy->getTypeID() < SrcEltTy->getTypeID())
1739 Res = Builder.CreateFPTrunc(Src, DstTy,
"conv");
1741 Res = Builder.CreateFPExt(Src, DstTy,
"conv");
1756 return Builder.getInt(
Value);
1760 return EmitLoadOfLValue(E);
1764 TestAndClearIgnoreResultAssign();
1772 return EmitLoadOfLValue(E);
1780 if (CGF.
SanOpts.
has(SanitizerKind::ArrayBounds))
1783 return Builder.CreateExtractElement(
Base, Idx,
"vecext");
1787 TestAndClearIgnoreResultAssign();
1796 llvm::MatrixBuilder MB(Builder);
1797 Value *Idx = MB.CreateIndex(RowIdx, ColumnIdx, NumRows);
1799 MB.CreateIndexAssumption(Idx, MatrixTy->getNumElementsFlattened());
1804 return Builder.CreateExtractElement(Matrix, Idx,
"matrixext");
1807 static int getMaskElt(llvm::ShuffleVectorInst *SVI,
unsigned Idx,
1809 int MV = SVI->getMaskValue(Idx);
1816 assert(llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue()) &&
1817 "Index operand too large for shufflevector mask!");
1818 return C->getZExtValue();
1822 bool Ignore = TestAndClearIgnoreResultAssign();
1824 assert (Ignore ==
false &&
"init list ignored");
1830 llvm::VectorType *VType =
1831 dyn_cast<llvm::VectorType>(ConvertType(E->
getType()));
1834 if (NumInitElements == 0) {
1836 return EmitNullValue(E->
getType());
1842 unsigned ResElts = cast<llvm::FixedVectorType>(VType)->getNumElements();
1849 unsigned CurIdx = 0;
1850 bool VIsUndefShuffle =
false;
1851 llvm::Value *
V = llvm::UndefValue::get(VType);
1852 for (
unsigned i = 0; i != NumInitElements; ++i) {
1854 Value *Init = Visit(IE);
1857 llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType());
1863 if (isa<ExtVectorElementExpr>(IE)) {
1864 llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init);
1866 if (cast<llvm::FixedVectorType>(EI->getVectorOperandType())
1867 ->getNumElements() == ResElts) {
1868 llvm::ConstantInt *
C = cast<llvm::ConstantInt>(EI->getIndexOperand());
1869 Value *LHS =
nullptr, *RHS =
nullptr;
1874 Args.resize(ResElts, -1);
1876 LHS = EI->getVectorOperand();
1878 VIsUndefShuffle =
true;
1879 }
else if (VIsUndefShuffle) {
1881 llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(
V);
1882 for (
unsigned j = 0; j != CurIdx; ++j)
1884 Args.push_back(ResElts +
C->getZExtValue());
1885 Args.resize(ResElts, -1);
1887 LHS = cast<llvm::ShuffleVectorInst>(
V)->getOperand(0);
1888 RHS = EI->getVectorOperand();
1889 VIsUndefShuffle =
false;
1891 if (!Args.empty()) {
1892 V = Builder.CreateShuffleVector(LHS, RHS, Args);
1898 V = Builder.CreateInsertElement(
V, Init, Builder.getInt32(CurIdx),
1900 VIsUndefShuffle =
false;
1905 unsigned InitElts = cast<llvm::FixedVectorType>(VVT)->getNumElements();
1910 unsigned Offset = (CurIdx == 0) ? 0 : ResElts;
1911 if (isa<ExtVectorElementExpr>(IE)) {
1912 llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init);
1913 Value *SVOp = SVI->getOperand(0);
1914 auto *OpTy = cast<llvm::FixedVectorType>(SVOp->getType());
1916 if (OpTy->getNumElements() == ResElts) {
1917 for (
unsigned j = 0; j != CurIdx; ++j) {
1920 if (VIsUndefShuffle) {
1921 Args.push_back(
getMaskElt(cast<llvm::ShuffleVectorInst>(
V), j, 0));
1926 for (
unsigned j = 0, je = InitElts; j != je; ++j)
1928 Args.resize(ResElts, -1);
1930 if (VIsUndefShuffle)
1931 V = cast<llvm::ShuffleVectorInst>(
V)->getOperand(0);
1940 for (
unsigned j = 0; j != InitElts; ++j)
1942 Args.resize(ResElts, -1);
1943 Init = Builder.CreateShuffleVector(Init, Args,
"vext");
1946 for (
unsigned j = 0; j != CurIdx; ++j)
1948 for (
unsigned j = 0; j != InitElts; ++j)
1949 Args.push_back(j +
Offset);
1950 Args.resize(ResElts, -1);
1957 V = Builder.CreateShuffleVector(
V, Init, Args,
"vecinit");
1958 VIsUndefShuffle = isa<llvm::UndefValue>(Init);
1964 llvm::Type *EltTy = VType->getElementType();
1967 for (; CurIdx < ResElts; ++CurIdx) {
1968 Value *Idx = Builder.getInt32(CurIdx);
1969 llvm::Value *Init = llvm::Constant::getNullValue(EltTy);
1970 V = Builder.CreateInsertElement(
V, Init, Idx,
"vecinit");
1978 if (CE->
getCastKind() == CK_UncheckedDerivedToBase)
1988 if (ICE->isGLValue())
2005 bool Ignored = TestAndClearIgnoreResultAssign();
2011 case CK_Dependent: llvm_unreachable(
"dependent cast kind in IR gen!");
2012 case CK_BuiltinFnToFnPtr:
2013 llvm_unreachable(
"builtin functions are handled elsewhere");
2015 case CK_LValueBitCast:
2016 case CK_ObjCObjectLValueCast: {
2017 Address Addr = EmitLValue(E).getAddress(CGF);
2020 return EmitLoadOfLValue(LV, CE->
getExprLoc());
2023 case CK_LValueToRValueBitCast: {
2029 return EmitLoadOfLValue(DestLV, CE->
getExprLoc());
2032 case CK_CPointerToObjCPointerCast:
2033 case CK_BlockPointerToObjCPointerCast:
2034 case CK_AnyPointerToBlockPointerCast:
2036 Value *Src = Visit(
const_cast<Expr*
>(E));
2037 llvm::Type *SrcTy = Src->getType();
2038 llvm::Type *DstTy = ConvertType(DestTy);
2039 if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() &&
2040 SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) {
2041 llvm_unreachable(
"wrong cast for pointers in different address spaces"
2042 "(must be an address space cast)!");
2045 if (CGF.
SanOpts.
has(SanitizerKind::CFIUnrelatedCast)) {
2048 PT->getPointeeType(),
2064 Src = Builder.CreateLaunderInvariantGroup(Src);
2072 Src = Builder.CreateStripInvariantGroup(Src);
2077 if (
auto *CI = dyn_cast<llvm::CallBase>(Src)) {
2078 if (CI->getMetadata(
"heapallocsite") && isa<ExplicitCastExpr>(CE)) {
2080 if (!PointeeType.
isNull())
2089 if (
const auto *FixedSrc = dyn_cast<llvm::FixedVectorType>(SrcTy)) {
2090 if (
const auto *ScalableDst = dyn_cast<llvm::ScalableVectorType>(DstTy)) {
2093 bool NeedsBitCast =
false;
2094 auto PredType = llvm::ScalableVectorType::get(Builder.getInt1Ty(), 16);
2095 llvm::Type *OrigType = DstTy;
2096 if (ScalableDst == PredType &&
2097 FixedSrc->getElementType() == Builder.getInt8Ty()) {
2098 DstTy = llvm::ScalableVectorType::get(Builder.getInt8Ty(), 2);
2099 ScalableDst = cast<llvm::ScalableVectorType>(DstTy);
2100 NeedsBitCast =
true;
2102 if (FixedSrc->getElementType() == ScalableDst->getElementType()) {
2103 llvm::Value *UndefVec = llvm::UndefValue::get(DstTy);
2104 llvm::Value *
Zero = llvm::Constant::getNullValue(CGF.
CGM.
Int64Ty);
2105 llvm::Value *Result = Builder.CreateInsertVector(
2106 DstTy, UndefVec, Src,
Zero,
"castScalableSve");
2108 Result = Builder.CreateBitCast(Result, OrigType);
2117 if (
const auto *ScalableSrc = dyn_cast<llvm::ScalableVectorType>(SrcTy)) {
2118 if (
const auto *FixedDst = dyn_cast<llvm::FixedVectorType>(DstTy)) {
2121 auto PredType = llvm::ScalableVectorType::get(Builder.getInt1Ty(), 16);
2122 if (ScalableSrc == PredType &&
2123 FixedDst->getElementType() == Builder.getInt8Ty()) {
2124 SrcTy = llvm::ScalableVectorType::get(Builder.getInt8Ty(), 2);
2125 ScalableSrc = cast<llvm::ScalableVectorType>(SrcTy);
2126 Src = Builder.CreateBitCast(Src, SrcTy);
2128 if (ScalableSrc->getElementType() == FixedDst->getElementType()) {
2129 llvm::Value *
Zero = llvm::Constant::getNullValue(CGF.
CGM.
Int64Ty);
2130 return Builder.CreateExtractVector(DstTy, Src,
Zero,
"castFixedSve");
2141 if ((isa<llvm::FixedVectorType>(SrcTy) &&
2142 isa<llvm::ScalableVectorType>(DstTy)) ||
2143 (isa<llvm::ScalableVectorType>(SrcTy) &&
2144 isa<llvm::FixedVectorType>(DstTy))) {
2152 return EmitLoadOfLValue(DestLV, CE->
getExprLoc());
2154 return Builder.CreateBitCast(Src, DstTy);
2156 case CK_AddressSpaceConversion: {
2159 Result.Val.isNullPointer()) {
2163 if (Result.HasSideEffects)
2166 ConvertType(DestTy)), DestTy);
2174 case CK_AtomicToNonAtomic:
2175 case CK_NonAtomicToAtomic:
2176 case CK_UserDefinedConversion:
2177 return Visit(
const_cast<Expr*
>(E));
2180 llvm::Value *
V = Visit(
const_cast<Expr *
>(E));
2185 llvm::Type *T = ConvertType(DestTy);
2186 if (T !=
V->getType())
2187 V = Builder.CreateBitCast(
V, T);
2192 case CK_BaseToDerived: {
2194 assert(DerivedClassDecl &&
"BaseToDerived arg isn't a C++ object pointer!");
2208 if (CGF.
SanOpts.
has(SanitizerKind::CFIDerivedCast))
2216 case CK_UncheckedDerivedToBase:
2217 case CK_DerivedToBase: {
2229 case CK_ArrayToPointerDecay:
2231 case CK_FunctionToPointerDecay:
2232 return EmitLValue(E).getPointer(CGF);
2234 case CK_NullToPointer:
2235 if (MustVisitNullValue(E))
2241 case CK_NullToMemberPointer: {
2242 if (MustVisitNullValue(E))
2249 case CK_ReinterpretMemberPointer:
2250 case CK_BaseToDerivedMemberPointer:
2251 case CK_DerivedToBaseMemberPointer: {
2252 Value *Src = Visit(E);
2263 case CK_ARCProduceObject:
2265 case CK_ARCConsumeObject:
2267 case CK_ARCReclaimReturnedObject:
2269 case CK_ARCExtendBlockObject:
2272 case CK_CopyAndAutoreleaseBlockObject:
2275 case CK_FloatingRealToComplex:
2276 case CK_FloatingComplexCast:
2277 case CK_IntegralRealToComplex:
2278 case CK_IntegralComplexCast:
2279 case CK_IntegralComplexToFloatingComplex:
2280 case CK_FloatingComplexToIntegralComplex:
2281 case CK_ConstructorConversion:
2283 llvm_unreachable(
"scalar cast to non-scalar value");
2285 case CK_LValueToRValue:
2287 assert(E->
isGLValue() &&
"lvalue-to-rvalue applied to r-value!");
2288 return Visit(
const_cast<Expr*
>(E));
2290 case CK_IntegralToPointer: {
2291 Value *Src = Visit(
const_cast<Expr*
>(E));
2295 auto DestLLVMTy = ConvertType(DestTy);
2298 llvm::Value* IntResult =
2299 Builder.CreateIntCast(Src, MiddleTy, InputSigned,
"conv");
2301 auto *IntToPtr = Builder.CreateIntToPtr(IntResult, DestLLVMTy);
2307 IntToPtr = Builder.CreateLaunderInvariantGroup(IntToPtr);
2311 case CK_PointerToIntegral: {
2312 assert(!DestTy->
isBooleanType() &&
"bool should use PointerToBool");
2313 auto *PtrExpr = Visit(E);
2321 PtrExpr = Builder.CreateStripInvariantGroup(PtrExpr);
2324 return Builder.CreatePtrToInt(PtrExpr, ConvertType(DestTy));
2330 case CK_MatrixCast: {
2331 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
2334 case CK_VectorSplat: {
2335 llvm::Type *DstTy = ConvertType(DestTy);
2336 Value *Elt = Visit(
const_cast<Expr *
>(E));
2338 llvm::ElementCount NumElements =
2339 cast<llvm::VectorType>(DstTy)->getElementCount();
2340 return Builder.CreateVectorSplat(NumElements, Elt,
"splat");
2343 case CK_FixedPointCast:
2344 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
2347 case CK_FixedPointToBoolean:
2349 "Expected src type to be fixed point type");
2350 assert(DestTy->
isBooleanType() &&
"Expected dest type to be boolean type");
2351 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
2354 case CK_FixedPointToIntegral:
2356 "Expected src type to be fixed point type");
2357 assert(DestTy->
isIntegerType() &&
"Expected dest type to be an integer");
2358 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
2361 case CK_IntegralToFixedPoint:
2363 "Expected src type to be an integer");
2365 "Expected dest type to be fixed point type");
2366 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
2369 case CK_IntegralCast: {
2370 ScalarConversionOpts Opts;
2371 if (
auto *ICE = dyn_cast<ImplicitCastExpr>(CE)) {
2372 if (!ICE->isPartOfExplicitCast())
2373 Opts = ScalarConversionOpts(CGF.
SanOpts);
2375 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
2378 case CK_IntegralToFloating:
2379 case CK_FloatingToIntegral:
2380 case CK_FloatingCast:
2381 case CK_FixedPointToFloating:
2382 case CK_FloatingToFixedPoint: {
2384 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
2387 case CK_BooleanToSignedIntegral: {
2388 ScalarConversionOpts Opts;
2389 Opts.TreatBooleanAsSigned =
true;
2390 return EmitScalarConversion(Visit(E), E->
getType(), DestTy,
2393 case CK_IntegralToBoolean:
2394 return EmitIntToBoolConversion(Visit(E));
2395 case CK_PointerToBoolean:
2396 return EmitPointerToBoolConversion(Visit(E), E->
getType());
2397 case CK_FloatingToBoolean: {
2399 return EmitFloatToBoolConversion(Visit(E));
2401 case CK_MemberPointerToBoolean: {
2402 llvm::Value *MemPtr = Visit(E);
2407 case CK_FloatingComplexToReal:
2408 case CK_IntegralComplexToReal:
2411 case CK_FloatingComplexToBoolean:
2412 case CK_IntegralComplexToBoolean: {
2416 return EmitComplexToScalarConversion(
V, E->
getType(), DestTy,
2420 case CK_ZeroToOCLOpaqueType: {
2423 "CK_ZeroToOCLEvent cast on non-event type");
2424 return llvm::Constant::getNullValue(ConvertType(DestTy));
2427 case CK_IntToOCLSampler:
2432 llvm_unreachable(
"unknown scalar cast");
2435 Value *ScalarExprEmitter::VisitStmtExpr(
const StmtExpr *E) {
2450 Scope.ForceCleanup({&
V});
2459 llvm::Value *InVal,
bool IsInc,
2463 BinOp.RHS = llvm::ConstantInt::get(InVal->getType(), 1,
false);
2465 BinOp.Opcode = IsInc ? BO_Add : BO_Sub;
2466 BinOp.FPFeatures = FPFeatures;
2471 llvm::Value *ScalarExprEmitter::EmitIncDecConsiderOverflowBehavior(
2473 llvm::Value *Amount =
2474 llvm::ConstantInt::get(InVal->getType(), IsInc ? 1 : -1,
true);
2475 StringRef Name = IsInc ?
"inc" :
"dec";
2476 switch (CGF.
getLangOpts().getSignedOverflowBehavior()) {
2478 return Builder.CreateAdd(InVal, Amount, Name);
2480 if (!CGF.
SanOpts.
has(SanitizerKind::SignedIntegerOverflow))
2481 return Builder.CreateNSWAdd(InVal, Amount, Name);
2485 return Builder.CreateNSWAdd(InVal, Amount, Name);
2489 llvm_unreachable(
"Unknown SignedOverflowBehaviorTy");
2494 class OMPLastprivateConditionalUpdateRAII {
2503 ~OMPLastprivateConditionalUpdateRAII() {
2513 bool isInc,
bool isPre) {
2514 OMPLastprivateConditionalUpdateRAII OMPRegion(CGF, E);
2516 llvm::PHINode *atomicPHI =
nullptr;
2520 int amount = (isInc ? 1 : -1);
2521 bool isSubtraction = !isInc;
2524 type = atomicTy->getValueType();
2525 if (isInc &&
type->isBooleanType()) {
2529 ->setAtomic(llvm::AtomicOrdering::SequentiallyConsistent);
2530 return Builder.getTrue();
2534 return Builder.CreateAtomicRMW(
2535 llvm::AtomicRMWInst::Xchg, LV.
getPointer(CGF), True,
2536 llvm::AtomicOrdering::SequentiallyConsistent);
2541 if (!
type->isBooleanType() &&
type->isIntegerType() &&
2542 !(
type->isUnsignedIntegerType() &&
2543 CGF.
SanOpts.
has(SanitizerKind::UnsignedIntegerOverflow)) &&
2551 llvm::ConstantInt::get(ConvertType(
type), 1,
true),
type);
2553 Builder.CreateAtomicRMW(aop, LV.
getPointer(CGF), amt,
2554 llvm::AtomicOrdering::SequentiallyConsistent);
2555 return isPre ? Builder.CreateBinOp(op, old, amt) : old;
2557 value = EmitLoadOfLValue(LV, E->
getExprLoc());
2560 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
2563 Builder.CreateBr(opBB);
2564 Builder.SetInsertPoint(opBB);
2565 atomicPHI = Builder.CreatePHI(value->getType(), 2);
2566 atomicPHI->addIncoming(value, startBB);
2569 value = EmitLoadOfLValue(LV, E->
getExprLoc());
2580 if (isInc &&
type->isBooleanType()) {
2581 value = Builder.getTrue();
2584 }
else if (
type->isIntegerType()) {
2586 bool canPerformLossyDemotionCheck =
false;
2587 if (
type->isPromotableIntegerType()) {
2589 assert(promotedType !=
type &&
"Shouldn't promote to the same type.");
2590 canPerformLossyDemotionCheck =
true;
2591 canPerformLossyDemotionCheck &=
2594 canPerformLossyDemotionCheck &=
2596 type, promotedType);
2597 assert((!canPerformLossyDemotionCheck ||
2598 type->isSignedIntegerOrEnumerationType() ||
2600 ConvertType(
type)->getScalarSizeInBits() ==
2601 ConvertType(promotedType)->getScalarSizeInBits()) &&
2602 "The following check expects that if we do promotion to different "
2603 "underlying canonical type, at least one of the types (either "
2604 "base or promoted) will be signed, or the bitwidths will match.");
2607 SanitizerKind::ImplicitIntegerArithmeticValueChange) &&
2608 canPerformLossyDemotionCheck) {
2618 value = EmitScalarConversion(value,
type, promotedType, E->
getExprLoc());
2619 Value *amt = llvm::ConstantInt::get(value->getType(), amount,
true);
2620 value = Builder.CreateAdd(value, amt, isInc ?
"inc" :
"dec");
2623 value = EmitScalarConversion(value, promotedType,
type, E->
getExprLoc(),
2624 ScalarConversionOpts(CGF.
SanOpts));
2629 }
else if (E->
canOverflow() &&
type->isSignedIntegerOrEnumerationType()) {
2630 value = EmitIncDecConsiderOverflowBehavior(E, value, isInc);
2632 CGF.
SanOpts.
has(SanitizerKind::UnsignedIntegerOverflow)) {
2636 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount,
true);
2637 value = Builder.CreateAdd(value, amt, isInc ?
"inc" :
"dec");
2648 if (!isInc) numElts = Builder.CreateNSWNeg(numElts,
"vla.negsize");
2651 value = Builder.CreateGEP(elemTy, value, numElts,
"vla.inc");
2654 elemTy, value, numElts,
false, isSubtraction,
2658 }
else if (
type->isFunctionType()) {
2659 llvm::Value *amt = Builder.getInt32(amount);
2663 value = Builder.CreateGEP(CGF.
Int8Ty, value, amt,
"incdec.funcptr");
2669 value = Builder.CreateBitCast(value, input->getType());
2673 llvm::Value *amt = Builder.getInt32(amount);
2676 value = Builder.CreateGEP(elemTy, value, amt,
"incdec.ptr");
2679 elemTy, value, amt,
false, isSubtraction,
2684 }
else if (
type->isVectorType()) {
2685 if (
type->hasIntegerRepresentation()) {
2686 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount);
2688 value = Builder.CreateAdd(value, amt, isInc ?
"inc" :
"dec");
2690 value = Builder.CreateFAdd(
2692 llvm::ConstantFP::get(value->getType(), amount),
2693 isInc ?
"inc" :
"dec");
2697 }
else if (
type->isRealFloatingType()) {
2705 value = Builder.CreateCall(
2708 input,
"incdec.conv");
2710 value = Builder.CreateFPExt(input, CGF.
CGM.
FloatTy,
"incdec.conv");
2714 if (value->getType()->isFloatTy())
2715 amt = llvm::ConstantFP::get(VMContext,
2716 llvm::APFloat(
static_cast<float>(amount)));
2717 else if (value->getType()->isDoubleTy())
2718 amt = llvm::ConstantFP::get(VMContext,
2719 llvm::APFloat(
static_cast<double>(amount)));
2723 llvm::APFloat F(
static_cast<float>(amount));
2725 const llvm::fltSemantics *FS;
2728 if (value->getType()->isFP128Ty())
2730 else if (value->getType()->isHalfTy())
2732 else if (value->getType()->isPPC_FP128Ty())
2736 F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
2737 amt = llvm::ConstantFP::get(VMContext, F);
2739 value = Builder.CreateFAdd(value, amt, isInc ?
"inc" :
"dec");
2743 value = Builder.CreateCall(
2746 value,
"incdec.conv");
2748 value = Builder.CreateFPTrunc(value, input->getType(),
"incdec.conv");
2753 }
else if (
type->isFixedPointType()) {
2760 Info.Opcode = isInc ? BO_Add : BO_Sub;
2762 Info.RHS = llvm::ConstantInt::get(value->getType(), 1,
false);
2765 if (
type->isSignedFixedPointType()) {
2766 Info.Opcode = isInc ? BO_Sub : BO_Add;
2767 Info.RHS = Builder.CreateNeg(Info.RHS);
2772 llvm::FixedPointBuilder<CGBuilderTy> FPBuilder(Builder);
2774 Info.RHS = FPBuilder.CreateIntegerToFixed(Info.RHS,
true, DstSema);
2775 value = EmitFixedPointBinOp(Info);
2783 if (!isInc) size = -size;
2784 llvm::Value *sizeValue =
2788 value = Builder.CreateGEP(CGF.
Int8Ty, value, sizeValue,
"incdec.objptr");
2791 CGF.
Int8Ty, value, sizeValue,
false, isSubtraction,
2793 value = Builder.CreateBitCast(value, input->getType());
2797 llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
2802 llvm::Value *
success = Pair.second;
2803 atomicPHI->addIncoming(old, curBlock);
2804 Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
2805 Builder.SetInsertPoint(contBB);
2806 return isPre ? value : input;
2817 return isPre ? value : input;
2823 TestAndClearIgnoreResultAssign();
2827 if (Op->getType()->isFPOrFPVectorTy())
2828 return Builder.CreateFNeg(Op,
"fneg");
2833 BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType());
2835 BinOp.Opcode = BO_Sub;
2838 return EmitSub(BinOp);
2842 TestAndClearIgnoreResultAssign();
2844 return Builder.CreateNot(Op,
"neg");
2853 Value *
Zero = llvm::Constant::getNullValue(Oper->getType());
2855 if (Oper->getType()->isFPOrFPVectorTy()) {
2858 Result = Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper,
Zero,
"cmp");
2860 Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper,
Zero,
"cmp");
2861 return Builder.CreateSExt(Result, ConvertType(E->
getType()),
"sext");
2870 BoolVal = Builder.CreateNot(BoolVal,
"lnot");
2873 return Builder.CreateZExt(BoolVal, ConvertType(E->
getType()),
"lnot.ext");
2881 return Builder.getInt(
Value);
2886 llvm::Type* ResultType = ConvertType(E->
getType());
2887 llvm::Value* Result = llvm::Constant::getNullValue(ResultType);
2889 for (
unsigned i = 0; i != n; ++i) {
2891 llvm::Value *
Offset =
nullptr;
2898 Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned,
"conv");
2905 llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType,
2909 Offset = Builder.CreateMul(Idx, ElemSize);
2923 Field != FieldEnd; ++Field, ++i) {
2924 if (*Field == MemberDecl)
2927 assert(i < RL.
getFieldCount() &&
"offsetof field in wrong type");
2932 Offset = llvm::ConstantInt::get(ResultType, OffsetInt);
2935 CurrentType = MemberDecl->
getType();
2940 llvm_unreachable(
"dependent __builtin_offsetof");
2956 auto *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl());
2962 Result = Builder.CreateAdd(Result,
Offset);
2970 ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr(
2973 if (E->
getKind() == UETT_SizeOf) {
2986 llvm::Value *size = VlaSize.NumElts;
2990 if (!eltSize.
isOne())
2995 }
else if (E->
getKind() == UETT_OpenMPRequiredSimdAlign) {
3001 return llvm::ConstantInt::get(CGF.
SizeTy, Alignment);
3046 return llvm::Constant::getNullValue(ConvertType(E->
getType()));
3053 BinOpInfo ScalarExprEmitter::EmitBinOps(
const BinaryOperator *E) {
3054 TestAndClearIgnoreResultAssign();
3056 Result.LHS = Visit(E->
getLHS());
3057 Result.RHS = Visit(E->
getRHS());
3065 LValue ScalarExprEmitter::EmitCompoundAssignLValue(
3067 Value *(ScalarExprEmitter::*Func)(
const BinOpInfo &),
3077 OpInfo.RHS = Visit(E->
getRHS());
3085 llvm::PHINode *atomicPHI =
nullptr;
3088 if (!
type->isBooleanType() &&
type->isIntegerType() &&
3089 !(
type->isUnsignedIntegerType() &&
3090 CGF.
SanOpts.
has(SanitizerKind::UnsignedIntegerOverflow)) &&
3093 llvm::AtomicRMWInst::BinOp AtomicOp = llvm::AtomicRMWInst::BAD_BINOP;
3094 llvm::Instruction::BinaryOps Op;
3095 switch (OpInfo.Opcode) {
3097 case BO_MulAssign:
case BO_DivAssign:
3115 AtomicOp = llvm::AtomicRMWInst::Xor;
3116 Op = llvm::Instruction::Xor;
3119 AtomicOp = llvm::AtomicRMWInst::Or;
3120 Op = llvm::Instruction::Or;
3123 llvm_unreachable(
"Invalid compound assignment type");
3125 if (AtomicOp != llvm::AtomicRMWInst::BAD_BINOP) {
3127 EmitScalarConversion(OpInfo.RHS, E->
getRHS()->
getType(), LHSTy,
3130 Value *OldVal = Builder.CreateAtomicRMW(
3132 llvm::AtomicOrdering::SequentiallyConsistent);
3136 Result = Builder.CreateBinOp(Op, OldVal, Amt);
3142 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
3144 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->
getExprLoc());
3146 Builder.CreateBr(opBB);
3147 Builder.SetInsertPoint(opBB);
3148 atomicPHI = Builder.CreatePHI(OpInfo.LHS->getType(), 2);
3149 atomicPHI->addIncoming(OpInfo.LHS, startBB);
3150 OpInfo.LHS = atomicPHI;
3153 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->
getExprLoc());
3161 Result = (this->*Func)(OpInfo);
3166 Loc, ScalarConversionOpts(CGF.
SanOpts));
3169 llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
3173 llvm::Value *old = CGF.
EmitToMemory(Pair.first.getScalarVal(), LHSTy);
3174 llvm::Value *
success = Pair.second;
3175 atomicPHI->addIncoming(old, curBlock);
3176 Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
3177 Builder.SetInsertPoint(contBB);
3197 Value *(ScalarExprEmitter::*Func)(
const BinOpInfo &)) {
3198 bool Ignore = TestAndClearIgnoreResultAssign();
3199 Value *RHS =
nullptr;
3200 LValue LHS = EmitCompoundAssignLValue(E, Func, RHS);
3215 return EmitLoadOfLValue(LHS, E->
getExprLoc());
3218 void ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck(
3219 const BinOpInfo &Ops, llvm::Value *
Zero,
bool isDiv) {
3222 if (CGF.
SanOpts.
has(SanitizerKind::IntegerDivideByZero)) {
3223 Checks.push_back(std::make_pair(Builder.CreateICmpNE(Ops.RHS,
Zero),
3224 SanitizerKind::IntegerDivideByZero));
3227 const auto *BO = cast<BinaryOperator>(Ops.E);
3228 if (CGF.
SanOpts.
has(SanitizerKind::SignedIntegerOverflow) &&
3229 Ops.Ty->hasSignedIntegerRepresentation() &&
3231 Ops.mayHaveIntegerOverflow()) {
3232 llvm::IntegerType *Ty = cast<llvm::IntegerType>(
Zero->getType());
3234 llvm::Value *IntMin =
3235 Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
3236 llvm::Value *NegOne = llvm::Constant::getAllOnesValue(Ty);
3238 llvm::Value *LHSCmp = Builder.CreateICmpNE(Ops.LHS, IntMin);
3239 llvm::Value *RHSCmp = Builder.CreateICmpNE(Ops.RHS, NegOne);
3240 llvm::Value *NotOverflow = Builder.CreateOr(LHSCmp, RHSCmp,
"or");
3242 std::make_pair(NotOverflow, SanitizerKind::SignedIntegerOverflow));
3245 if (Checks.size() > 0)
3246 EmitBinOpCheck(Checks, Ops);
3249 Value *ScalarExprEmitter::EmitDiv(
const BinOpInfo &Ops) {
3252 if ((CGF.
SanOpts.
has(SanitizerKind::IntegerDivideByZero) ||
3253 CGF.
SanOpts.
has(SanitizerKind::SignedIntegerOverflow)) &&
3254 Ops.Ty->isIntegerType() &&
3255 (Ops.mayHaveIntegerDivisionByZero() || Ops.mayHaveIntegerOverflow())) {
3256 llvm::Value *
Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
3257 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops,
Zero,
true);
3258 }
else if (CGF.
SanOpts.
has(SanitizerKind::FloatDivideByZero) &&
3259 Ops.Ty->isRealFloatingType() &&
3260 Ops.mayHaveFloatDivisionByZero()) {
3261 llvm::Value *
Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
3262 llvm::Value *NonZero = Builder.CreateFCmpUNE(Ops.RHS,
Zero);
3263 EmitBinOpCheck(std::make_pair(NonZero, SanitizerKind::FloatDivideByZero),
3268 if (Ops.Ty->isConstantMatrixType()) {
3269 llvm::MatrixBuilder MB(Builder);
3272 auto *BO = cast<BinaryOperator>(Ops.E);
3276 "first operand must be a matrix");
3278 "second operand must be an arithmetic type");
3280 return MB.CreateScalarDiv(Ops.LHS, Ops.RHS,
3281 Ops.Ty->hasUnsignedIntegerRepresentation());
3284 if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
3287 Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS,
"div");
3297 llvm::Type *ValTy = Val->getType();
3298 if (ValTy->isFloatTy() ||
3299 (isa<llvm::VectorType>(ValTy) &&
3300 cast<llvm::VectorType>(ValTy)->getElementType()->isFloatTy()))
3305 else if (Ops.isFixedPointOp())
3306 return EmitFixedPointBinOp(Ops);
3307 else if (Ops.Ty->hasUnsignedIntegerRepresentation())
3308 return Builder.CreateUDiv(Ops.LHS, Ops.RHS,
"div");
3310 return Builder.CreateSDiv(Ops.LHS, Ops.RHS,
"div");
3313 Value *ScalarExprEmitter::EmitRem(
const BinOpInfo &Ops) {
3315 if ((CGF.
SanOpts.
has(SanitizerKind::IntegerDivideByZero) ||
3316 CGF.
SanOpts.
has(SanitizerKind::SignedIntegerOverflow)) &&
3317 Ops.Ty->isIntegerType() &&
3318 (Ops.mayHaveIntegerDivisionByZero() || Ops.mayHaveIntegerOverflow())) {
3320 llvm::Value *
Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
3321 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops,
Zero,
false);
3324 if (Ops.Ty->hasUnsignedIntegerRepresentation())
3325 return Builder.CreateURem(Ops.LHS, Ops.RHS,
"rem");
3327 return Builder.CreateSRem(Ops.LHS, Ops.RHS,
"rem");
3330 Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(
const BinOpInfo &Ops) {
3335 bool isSigned = Ops.Ty->isSignedIntegerOrEnumerationType();
3336 switch (Ops.Opcode) {
3340 IID = isSigned ? llvm::Intrinsic::sadd_with_overflow :
3341 llvm::Intrinsic::uadd_with_overflow;
3342 OverflowKind = SanitizerHandler::AddOverflow;
3347 IID = isSigned ? llvm::Intrinsic::ssub_with_overflow :
3348 llvm::Intrinsic::usub_with_overflow;
3349 OverflowKind = SanitizerHandler::SubOverflow;
3354 IID = isSigned ? llvm::Intrinsic::smul_with_overflow :
3355 llvm::Intrinsic::umul_with_overflow;
3356 OverflowKind = SanitizerHandler::MulOverflow;
3359 llvm_unreachable(
"Unsupported operation for overflow detection");
3370 Value *resultAndOverflow = Builder.CreateCall(intrinsic, {Ops.LHS, Ops.RHS});
3371 Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
3372 Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
3377 if (handlerName->empty()) {
3380 if (!isSigned || CGF.
SanOpts.
has(SanitizerKind::SignedIntegerOverflow)) {
3381 llvm::Value *NotOverflow = Builder.CreateNot(overflow);
3383 : SanitizerKind::UnsignedIntegerOverflow;
3384 EmitBinOpCheck(std::make_pair(NotOverflow,
Kind), Ops);
3386 CGF.
EmitTrapCheck(Builder.CreateNot(overflow), OverflowKind);
3391 llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
3392 llvm::BasicBlock *continueBB =
3396 Builder.CreateCondBr(overflow, overflowBB, continueBB);
3400 Builder.SetInsertPoint(overflowBB);
3403 llvm::Type *Int8Ty = CGF.
Int8Ty;
3404 llvm::Type *argTypes[] = { CGF.
Int64Ty, CGF.
Int64Ty, Int8Ty, Int8Ty };
3405 llvm::FunctionType *handlerTy =
3406 llvm::FunctionType::get(CGF.
Int64Ty, argTypes,
true);
3407 llvm::FunctionCallee handler =
3412 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.
Int64Ty);
3413 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.
Int64Ty);
3417 llvm::Value *handlerArgs[] = {
3420 Builder.getInt8(OpID),
3421 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())
3423 llvm::Value *handlerResult =
3427 handlerResult = Builder.CreateTrunc(handlerResult, opTy);
3428 Builder.CreateBr(continueBB);
3430 Builder.SetInsertPoint(continueBB);
3431 llvm::PHINode *phi = Builder.CreatePHI(opTy, 2);
3432 phi->addIncoming(result, initialBB);
3433 phi->addIncoming(handlerResult, overflowBB);
3440 const BinOpInfo &op,
3441 bool isSubtraction) {
3446 Value *pointer = op.LHS;
3447 Expr *pointerOperand =
expr->getLHS();
3448 Value *index = op.RHS;
3449 Expr *indexOperand =
expr->getRHS();
3452 if (!isSubtraction && !pointer->getType()->isPointerTy()) {
3453 std::swap(pointer, index);
3454 std::swap(pointerOperand, indexOperand);
3459 unsigned width = cast<llvm::IntegerType>(index->getType())->getBitWidth();
3461 auto PtrTy = cast<llvm::PointerType>(pointer->getType());
3484 return CGF.
Builder.CreateIntToPtr(index, pointer->getType());
3486 if (width != DL.getIndexTypeSizeInBits(PtrTy)) {
3489 index = CGF.
Builder.CreateIntCast(index, DL.getIndexType(PtrTy), isSigned,
3495 index = CGF.
Builder.CreateNeg(index,
"idx.neg");
3497 if (CGF.
SanOpts.
has(SanitizerKind::ArrayBounds))
3507 llvm::Value *objectSize
3510 index = CGF.
Builder.CreateMul(index, objectSize);
3514 return CGF.
Builder.CreateBitCast(result, pointer->getType());
3529 index = CGF.
Builder.CreateMul(index, numElements,
"vla.index");
3532 index = CGF.
Builder.CreateNSWMul(index, numElements,
"vla.index");
3534 elemTy, pointer, index, isSigned, isSubtraction, op.E->getExprLoc(),
3546 return CGF.
Builder.CreateBitCast(result, pointer->getType());
3554 elemTy, pointer, index, isSigned, isSubtraction, op.E->getExprLoc(),
3565 bool negMul,
bool negAdd) {
3566 assert(!(negMul && negAdd) &&
"Only one of negMul and negAdd should be set.");
3568 Value *MulOp0 = MulOp->getOperand(0);
3569 Value *MulOp1 = MulOp->getOperand(1);
3571 MulOp0 = Builder.CreateFNeg(MulOp0,
"neg");
3573 Addend = Builder.CreateFNeg(Addend,
"neg");
3575 Value *FMulAdd =
nullptr;
3576 if (Builder.getIsFPConstrained()) {
3577 assert(isa<llvm::ConstrainedFPIntrinsic>(MulOp) &&
3578 "Only constrained operation should be created when Builder is in FP "
3579 "constrained mode");
3580 FMulAdd = Builder.CreateConstrainedFPCall(
3581 CGF.
CGM.
getIntrinsic(llvm::Intrinsic::experimental_constrained_fmuladd,
3583 {MulOp0, MulOp1, Addend});
3585 FMulAdd = Builder.CreateCall(
3587 {MulOp0, MulOp1, Addend});
3589 MulOp->eraseFromParent();
3604 assert((op.Opcode == BO_Add || op.Opcode == BO_AddAssign ||
3605 op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) &&
3606 "Only fadd/fsub can be the root of an fmuladd.");
3609 if (!op.FPFeatures.allowFPContractWithinStatement())
3615 if (
auto *LHSBinOp = dyn_cast<llvm::BinaryOperator>(op.LHS)) {
3616 if (LHSBinOp->getOpcode() == llvm::Instruction::FMul &&
3617 LHSBinOp->use_empty())
3618 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder,
false, isSub);
3620 if (
auto *RHSBinOp = dyn_cast<llvm::BinaryOperator>(op.RHS)) {
3621 if (RHSBinOp->getOpcode() == llvm::Instruction::FMul &&
3622 RHSBinOp->use_empty())
3623 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub,
false);
3626 if (
auto *LHSBinOp = dyn_cast<llvm::CallBase>(op.LHS)) {
3627 if (LHSBinOp->getIntrinsicID() ==
3628 llvm::Intrinsic::experimental_constrained_fmul &&
3629 LHSBinOp->use_empty())
3630 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder,
false, isSub);
3632 if (
auto *RHSBinOp = dyn_cast<llvm::CallBase>(op.RHS)) {
3633 if (RHSBinOp->getIntrinsicID() ==
3634 llvm::Intrinsic::experimental_constrained_fmul &&
3635 RHSBinOp->use_empty())
3636 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub,
false);
3642 Value *ScalarExprEmitter::EmitAdd(
const BinOpInfo &op) {
3643 if (op.LHS->getType()->isPointerTy() ||
3644 op.RHS->getType()->isPointerTy())
3647 if (op.Ty->isSignedIntegerOrEnumerationType()) {
3648 switch (CGF.
getLangOpts().getSignedOverflowBehavior()) {
3650 return Builder.CreateAdd(op.LHS, op.RHS,
"add");
3652 if (!CGF.
SanOpts.
has(SanitizerKind::SignedIntegerOverflow))
3653 return Builder.CreateNSWAdd(op.LHS, op.RHS,
"add");
3656 if (CanElideOverflowCheck(CGF.
getContext(), op))
3657 return Builder.CreateNSWAdd(op.LHS, op.RHS,
"add");
3658 return EmitOverflowCheckedBinOp(op);
3662 if (op.Ty->isConstantMatrixType()) {
3663 llvm::MatrixBuilder MB(Builder);
3665 return MB.CreateAdd(op.LHS, op.RHS);
3668 if (op.Ty->isUnsignedIntegerType() &&
3669 CGF.
SanOpts.
has(SanitizerKind::UnsignedIntegerOverflow) &&
3670 !CanElideOverflowCheck(CGF.
getContext(), op))
3671 return EmitOverflowCheckedBinOp(op);
3673 if (op.LHS->getType()->isFPOrFPVectorTy()) {
3679 return Builder.CreateFAdd(op.LHS, op.RHS,
"add");
3682 if (op.isFixedPointOp())
3683 return EmitFixedPointBinOp(op);
3685 return Builder.CreateAdd(op.LHS, op.RHS,
"add");
3690 Value *ScalarExprEmitter::EmitFixedPointBinOp(
const BinOpInfo &op) {
3692 using llvm::ConstantInt;
3700 if (
const auto *BinOp = dyn_cast<BinaryOperator>(op.E)) {
3701 RHSTy = BinOp->getRHS()->getType();
3702 if (
const auto *CAO = dyn_cast<CompoundAssignOperator>(BinOp)) {
3707 LHSTy = CAO->getComputationLHSType();
3708 ResultTy = CAO->getComputationResultType();
3710 LHSTy = BinOp->getLHS()->getType();
3711 }
else if (
const auto *UnOp = dyn_cast<UnaryOperator>(op.E)) {
3712 LHSTy = UnOp->getSubExpr()->getType();
3713 RHSTy = UnOp->getSubExpr()->getType();
3716 Value *LHS = op.LHS;
3717 Value *RHS = op.RHS;
3722 auto CommonFixedSema = LHSFixedSema.getCommonSemantics(RHSFixedSema);
3726 llvm::FixedPointBuilder<CGBuilderTy> FPBuilder(Builder);
3727 switch (op.Opcode) {
3730 Result = FPBuilder.CreateAdd(LHS, LHSFixedSema, RHS, RHSFixedSema);
3734 Result = FPBuilder.CreateSub(LHS, LHSFixedSema, RHS, RHSFixedSema);
3738 Result = FPBuilder.CreateMul(LHS, LHSFixedSema, RHS, RHSFixedSema);
3742 Result = FPBuilder.CreateDiv(LHS, LHSFixedSema, RHS, RHSFixedSema);
3746 Result = FPBuilder.CreateShl(LHS, LHSFixedSema, RHS);
3750 Result = FPBuilder.CreateShr(LHS, LHSFixedSema, RHS);
3753 return FPBuilder.CreateLT(LHS, LHSFixedSema, RHS, RHSFixedSema);
3755 return FPBuilder.CreateGT(LHS, LHSFixedSema, RHS, RHSFixedSema);
3757 return FPBuilder.CreateLE(LHS, LHSFixedSema, RHS, RHSFixedSema);
3759 return FPBuilder.CreateGE(LHS, LHSFixedSema, RHS, RHSFixedSema);
3764 return FPBuilder.CreateEQ(LHS, LHSFixedSema, RHS, RHSFixedSema);
3766 return FPBuilder.CreateNE(LHS, LHSFixedSema, RHS, RHSFixedSema);
3770 llvm_unreachable(
"Found unimplemented fixed point binary operation");
3783 llvm_unreachable(
"Found unsupported binary operation for fixed point types.");
3789 return FPBuilder.CreateFixedToFixed(Result, IsShift ? LHSFixedSema
3794 Value *ScalarExprEmitter::EmitSub(
const BinOpInfo &op) {
3796 if (!op.LHS->getType()->isPointerTy()) {
3797 if (op.Ty->isSignedIntegerOrEnumerationType()) {
3798 switch (CGF.
getLangOpts().getSignedOverflowBehavior()) {
3800 return Builder.CreateSub(op.LHS, op.RHS,
"sub");
3802 if (!CGF.
SanOpts.
has(SanitizerKind::SignedIntegerOverflow))
3803 return Builder.CreateNSWSub(op.LHS, op.RHS,
"sub");
3806 if (CanElideOverflowCheck(CGF.
getContext(), op))
3807 return Builder.CreateNSWSub(op.LHS, op.RHS,
"sub");
3808 return EmitOverflowCheckedBinOp(op);
3812 if (op.Ty->isConstantMatrixType()) {
3813 llvm::MatrixBuilder MB(Builder);
3815 return MB.CreateSub(op.LHS, op.RHS);
3818 if (op.Ty->isUnsignedIntegerType() &&
3819 CGF.
SanOpts.
has(SanitizerKind::UnsignedIntegerOverflow) &&
3820 !CanElideOverflowCheck(CGF.
getContext(), op))
3821 return EmitOverflowCheckedBinOp(op);
3823 if (op.LHS->getType()->isFPOrFPVectorTy()) {
3828 return Builder.CreateFSub(op.LHS, op.RHS,
"sub");
3831 if (op.isFixedPointOp())
3832 return EmitFixedPointBinOp(op);
3834 return Builder.CreateSub(op.LHS, op.RHS,
"sub");
3839 if (!op.RHS->getType()->isPointerTy())
3846 = Builder.CreatePtrToInt(op.LHS, CGF.
PtrDiffTy,
"sub.ptr.lhs.cast");
3848 = Builder.CreatePtrToInt(op.RHS, CGF.
PtrDiffTy,
"sub.ptr.rhs.cast");
3849 Value *diffInChars = Builder.CreateSub(LHS, RHS,
"sub.ptr.sub");
3853 QualType elementType =
expr->getLHS()->getType()->getPointeeType();
3855 llvm::Value *divisor =
nullptr;
3861 elementType = VlaSize.Type;
3862 divisor = VlaSize.NumElts;
3866 if (!eltSize.
isOne())
3882 if (elementSize.
isOne())
3891 return Builder.CreateExactSDiv(diffInChars, divisor,
"sub.ptr.div");
3894 Value *ScalarExprEmitter::GetWidthMinusOneValue(
Value* LHS,
Value* RHS) {
3895 llvm::IntegerType *Ty;
3896 if (llvm::VectorType *VT = dyn_cast<llvm::VectorType>(LHS->getType()))
3897 Ty = cast<llvm::IntegerType>(VT->getElementType());
3899 Ty = cast<llvm::IntegerType>(LHS->getType());
3900 return llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth() - 1);
3904 const Twine &Name) {
3905 llvm::IntegerType *Ty;
3906 if (
auto *VT = dyn_cast<llvm::VectorType>(LHS->getType()))
3907 Ty = cast<llvm::IntegerType>(VT->getElementType());
3909 Ty = cast<llvm::IntegerType>(LHS->getType());
3911 if (llvm::isPowerOf2_64(Ty->getBitWidth()))
3912 return Builder.CreateAnd(RHS, GetWidthMinusOneValue(LHS, RHS), Name);
3914 return Builder.CreateURem(
3915 RHS, llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth()), Name);
3918 Value *ScalarExprEmitter::EmitShl(
const BinOpInfo &Ops) {
3920 if (Ops.isFixedPointOp())
3921 return EmitFixedPointBinOp(Ops);
3925 Value *RHS = Ops.RHS;
3926 if (Ops.LHS->getType() != RHS->getType())
3927 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(),
false,
"sh_prom");
3929 bool SanitizeSignedBase = CGF.
SanOpts.
has(SanitizerKind::ShiftBase) &&
3930 Ops.Ty->hasSignedIntegerRepresentation() &&
3933 bool SanitizeUnsignedBase =
3934 CGF.
SanOpts.
has(SanitizerKind::UnsignedShiftBase) &&
3935 Ops.Ty->hasUnsignedIntegerRepresentation();
3936 bool SanitizeBase = SanitizeSignedBase || SanitizeUnsignedBase;
3937 bool SanitizeExponent = CGF.
SanOpts.
has(SanitizerKind::ShiftExponent);
3940 RHS = ConstrainShiftValue(Ops.LHS, RHS,
"shl.mask");
3941 else if ((SanitizeBase || SanitizeExponent) &&
3942 isa<llvm::IntegerType>(Ops.LHS->getType())) {
3945 llvm::Value *WidthMinusOne = GetWidthMinusOneValue(Ops.LHS, Ops.RHS);
3946 llvm::Value *ValidExponent = Builder.CreateICmpULE(Ops.RHS, WidthMinusOne);
3948 if (SanitizeExponent) {
3950 std::make_pair(ValidExponent, SanitizerKind::ShiftExponent));
3957 llvm::BasicBlock *Orig = Builder.GetInsertBlock();
3960 Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);
3961 llvm::Value *PromotedWidthMinusOne =
3962 (RHS == Ops.RHS) ? WidthMinusOne
3963 : GetWidthMinusOneValue(Ops.LHS, RHS);
3965 llvm::Value *BitsShiftedOff = Builder.CreateLShr(
3966 Ops.LHS, Builder.CreateSub(PromotedWidthMinusOne, RHS,
"shl.zeros",
3969 if (SanitizeUnsignedBase || CGF.
getLangOpts().CPlusPlus) {
3975 llvm::Value *One = llvm::ConstantInt::get(BitsShiftedOff->getType(), 1);
3976 BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One);
3978 llvm::Value *
Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0);
3979 llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff,
Zero);
3981 llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2);
3982 BaseCheck->addIncoming(Builder.getTrue(), Orig);
3983 BaseCheck->addIncoming(ValidBase, CheckShiftBase);
3984 Checks.push_back(std::make_pair(
3985 BaseCheck, SanitizeSignedBase ? SanitizerKind::ShiftBase
3986 : SanitizerKind::UnsignedShiftBase));
3989 assert(!Checks.empty());
3990 EmitBinOpCheck(Checks, Ops);
3993 return Builder.CreateShl(Ops.LHS, RHS,
"shl");
3996 Value *ScalarExprEmitter::EmitShr(
const BinOpInfo &Ops) {
3998 if (Ops.isFixedPointOp())
3999 return EmitFixedPointBinOp(Ops);
4003 Value *RHS = Ops.RHS;
4004 if (Ops.LHS->getType() != RHS->getType())
4005 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(),
false,
"sh_prom");
4009 RHS = ConstrainShiftValue(Ops.LHS, RHS,
"shr.mask");
4010 else if (CGF.
SanOpts.
has(SanitizerKind::ShiftExponent) &&
4011 isa<llvm::IntegerType>(Ops.LHS->getType())) {
4013 llvm::Value *Valid =
4014 Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS));
4015 EmitBinOpCheck(std::make_pair(Valid, SanitizerKind::ShiftExponent), Ops);
4018 if (Ops.Ty->hasUnsignedIntegerRepresentation())
4019 return Builder.CreateLShr(Ops.LHS, RHS,
"shr");
4020 return Builder.CreateAShr(Ops.LHS, RHS,
"shr");
4028 default: llvm_unreachable(
"unexpected element type");
4029 case BuiltinType::Char_U:
4030 case BuiltinType::UChar:
4031 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
4032 llvm::Intrinsic::ppc_altivec_vcmpgtub_p;
4033 case BuiltinType::Char_S:
4034 case BuiltinType::SChar:
4035 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
4036 llvm::Intrinsic::ppc_altivec_vcmpgtsb_p;
4037 case BuiltinType::UShort:
4038 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
4039 llvm::Intrinsic::ppc_altivec_vcmpgtuh_p;
4040 case BuiltinType::Short:
4041 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
4042 llvm::Intrinsic::ppc_altivec_vcmpgtsh_p;
4043 case BuiltinType::UInt:
4044 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
4045 llvm::Intrinsic::ppc_altivec_vcmpgtuw_p;
4046 case BuiltinType::Int:
4047 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
4048 llvm::Intrinsic::ppc_altivec_vcmpgtsw_p;
4049 case BuiltinType::ULong:
4050 case BuiltinType::ULongLong:
4051 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p :
4052 llvm::Intrinsic::ppc_altivec_vcmpgtud_p;
4053 case BuiltinType::Long:
4054 case BuiltinType::LongLong:
4055 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p :
4056 llvm::Intrinsic::ppc_altivec_vcmpgtsd_p;
4058 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p :
4059 llvm::Intrinsic::ppc_altivec_vcmpgtfp_p;
4060 case BuiltinType::Double:
4061 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_vsx_xvcmpeqdp_p :
4062 llvm::Intrinsic::ppc_vsx_xvcmpgtdp_p;
4063 case BuiltinType::UInt128:
4064 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequq_p
4065 : llvm::Intrinsic::ppc_altivec_vcmpgtuq_p;
4066 case BuiltinType::Int128:
4067 return (IT ==
VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequq_p
4068 : llvm::Intrinsic::ppc_altivec_vcmpgtsq_p;
4073 llvm::CmpInst::Predicate UICmpOpc,
4074 llvm::CmpInst::Predicate SICmpOpc,
4075 llvm::CmpInst::Predicate FCmpOpc,
4077 TestAndClearIgnoreResultAssign();
4087 CGF, LHS, RHS, MPT, E->
getOpcode() == BO_NE);
4089 BinOpInfo BOInfo = EmitBinOps(E);
4090 Value *LHS = BOInfo.LHS;
4091 Value *RHS = BOInfo.RHS;
4097 enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6;
4102 Value *FirstVecArg = LHS,
4103 *SecondVecArg = RHS;
4109 default: llvm_unreachable(
"is not a comparison operation");
4121 std::swap(FirstVecArg, SecondVecArg);
4130 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
4131 std::swap(FirstVecArg, SecondVecArg);
4141 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
4146 std::swap(FirstVecArg, SecondVecArg);
4151 Value *CR6Param = Builder.getInt32(CR6);
4153 Result = Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg});
4160 llvm::IntegerType *ResultTy = cast<llvm::IntegerType>(Result->getType());
4161 if (ResultTy->getBitWidth() > 1 &&
4163 Result = Builder.CreateTrunc(Result, Builder.getInt1Ty());
4168 if (BOInfo.isFixedPointOp()) {
4169 Result = EmitFixedPointBinOp(BOInfo);
4170 }
else if (LHS->getType()->isFPOrFPVectorTy()) {
4173 Result = Builder.CreateFCmp(FCmpOpc, LHS, RHS,
"cmp");
4175 Result = Builder.CreateFCmpS(FCmpOpc, LHS, RHS,
"cmp");
4177 Result = Builder.CreateICmp(SICmpOpc, LHS, RHS,
"cmp");
4182 !isa<llvm::ConstantPointerNull>(LHS) &&
4183 !isa<llvm::ConstantPointerNull>(RHS)) {
4192 LHS = Builder.CreateStripInvariantGroup(LHS);
4194 RHS = Builder.CreateStripInvariantGroup(RHS);
4197 Result = Builder.CreateICmp(UICmpOpc, LHS, RHS,
"cmp");
4203 return Builder.CreateSExt(Result, ConvertType(E->
getType()),
"sext");
4211 CETy = CTy->getElementType();
4213 LHS.first = Visit(E->
getLHS());
4214 LHS.second = llvm::Constant::getNullValue(LHS.first->getType());
4220 CTy->getElementType()) &&
4221 "The element types must always match.");
4224 RHS.first = Visit(E->
getRHS());
4225 RHS.second = llvm::Constant::getNullValue(RHS.first->getType());
4227 "The element types must always match.");
4230 Value *ResultR, *ResultI;
4234 ResultR = Builder.CreateFCmp(FCmpOpc, LHS.first, RHS.first,
"cmp.r");
4235 ResultI = Builder.CreateFCmp(FCmpOpc, LHS.second, RHS.second,
"cmp.i");
4239 ResultR = Builder.CreateICmp(UICmpOpc, LHS.first, RHS.first,
"cmp.r");
4240 ResultI = Builder.CreateICmp(UICmpOpc, LHS.second, RHS.second,
"cmp.i");
4244 Result = Builder.CreateAnd(ResultR, ResultI,
"and.ri");
4247 "Complex comparison other than == or != ?");
4248 Result = Builder.CreateOr(ResultR, ResultI,
"or.ri");
4257 bool Ignore = TestAndClearIgnoreResultAssign();
4276 RHS = Visit(E->
getRHS());
4284 RHS = Visit(E->
getRHS());
4312 return EmitLoadOfLValue(LHS, E->
getExprLoc());
4322 Value *
Zero = llvm::ConstantAggregateZero::get(LHS->getType());
4323 if (LHS->getType()->isFPOrFPVectorTy()) {
4326 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS,
Zero,
"cmp");
4327 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS,
Zero,
"cmp");
4329 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS,
Zero,
"cmp");
4330 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS,
Zero,
"cmp");
4332 Value *
And = Builder.CreateAnd(LHS, RHS);
4333 return Builder.CreateSExt(
And, ConvertType(E->
getType()),
"sext");
4337 llvm::Type *ResTy = ConvertType(E->
getType());
4352 if (InstrumentRegions &&
4356 Builder.CreateCondBr(RHSCond, RHSBlockCnt, FBlock);
4364 return Builder.CreateZExtOrBitCast(RHSCond, ResTy,
"land.ext");
4369 return llvm::Constant::getNullValue(ResTy);
4384 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
4386 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
4388 PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI);
4397 RHSBlock = Builder.GetInsertBlock();
4402 if (InstrumentRegions &&
4405 Builder.CreateCondBr(RHSCond, RHSBlockCnt, ContBlock);
4409 PN->addIncoming(RHSCond, RHSBlockCnt);
4419 PN->addIncoming(RHSCond, RHSBlock);
4424 PN->setDebugLoc(Builder.getCurrentDebugLocation());
4428 return Builder.CreateZExtOrBitCast(PN, ResTy,
"land.ext");
4438 Value *
Zero = llvm::ConstantAggregateZero::get(LHS->getType());
4439 if (LHS->getType()->isFPOrFPVectorTy()) {
4442 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS,
Zero,
"cmp");
4443 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS,
Zero,
"cmp");
4445 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS,
Zero,
"cmp");
4446 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS,
Zero,
"cmp");
4448 Value *Or = Builder.CreateOr(LHS, RHS);
4449 return Builder.CreateSExt(Or, ConvertType(E->
getType()),
"sext");
4453 llvm::Type *ResTy = ConvertType(E->
getType());
4468 if (InstrumentRegions &&
4472 Builder.CreateCondBr(RHSCond, FBlock, RHSBlockCnt);
4480 return Builder.CreateZExtOrBitCast(RHSCond, ResTy,
"lor.ext");
4485 return llvm::ConstantInt::get(ResTy, 1);
4501 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
4503 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
4505 PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI);
4517 RHSBlock = Builder.GetInsertBlock();
4522 if (InstrumentRegions &&
4525 Builder.CreateCondBr(RHSCond, ContBlock, RHSBlockCnt);
4529 PN->addIncoming(RHSCond, RHSBlockCnt);
4535 PN->addIncoming(RHSCond, RHSBlock);
4538 return Builder.CreateZExtOrBitCast(PN, ResTy,
"lor.ext");
4544 return Visit(E->
getRHS());
4569 Value *ScalarExprEmitter::
4571 TestAndClearIgnoreResultAssign();
4584 Expr *live = lhsExpr, *dead = rhsExpr;
4585 if (!CondExprBool) std::swap(live, dead);
4591 Value *Result = Visit(live);
4610 llvm::Value *LHS = Visit(lhsExpr);
4611 llvm::Value *RHS = Visit(rhsExpr);
4613 llvm::Type *condType = ConvertType(condExpr->
getType());
4614 auto *vecTy = cast<llvm::FixedVectorType>(condType);
4616 unsigned numElem = vecTy->getNumElements();
4617 llvm::Type *elemType = vecTy->getElementType();
4619 llvm::Value *zeroVec = llvm::Constant::getNullValue(vecTy);
4620 llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec);
4621 llvm::Value *tmp = Builder.CreateSExt(
4622 TestMSB, llvm::FixedVectorType::get(elemType, numElem),
"sext");
4623 llvm::Value *tmp2 = Builder.CreateNot(tmp);
4626 llvm::Value *RHSTmp = RHS;
4627 llvm::Value *LHSTmp = LHS;
4628 bool wasCast =
false;
4629 llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType());
4630 if (rhsVTy->getElementType()->isFloatingPointTy()) {
4631 RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
4632 LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
4636 llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
4637 llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
4638 llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4,
"cond");
4640 tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
4650 llvm::Value *LHS = Visit(lhsExpr);
4651 llvm::Value *RHS = Visit(rhsExpr);
4653 llvm::Type *CondType = ConvertType(condExpr->
getType());
4654 auto *VecTy = cast<llvm::VectorType>(CondType);
4655 llvm::Value *ZeroVec = llvm::Constant::getNullValue(VecTy);
4657 CondV = Builder.CreateICmpNE(CondV, ZeroVec,
"vector_cond");
4658 return Builder.CreateSelect(CondV, LHS, RHS,
"vector_select");
4667 llvm::Value *StepV = Builder.CreateZExtOrBitCast(CondV, CGF.
Int64Ty);
4671 llvm::Value *LHS = Visit(lhsExpr);
4672 llvm::Value *RHS = Visit(rhsExpr);
4675 assert(!RHS &&
"LHS and RHS types must match");
4678 return Builder.CreateSelect(CondV, LHS, RHS,
"cond");
4692 Value *LHS = Visit(lhsExpr);
4695 LHSBlock = Builder.GetInsertBlock();
4696 Builder.CreateBr(ContBlock);
4700 Value *RHS = Visit(rhsExpr);
4703 RHSBlock = Builder.GetInsertBlock();
4713 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2,
"cond");
4714 PN->addIncoming(LHS, LHSBlock);
4715 PN->addIncoming(RHS, RHSBlock);
4732 llvm::Type *ArgTy = ConvertType(VE->
getType());
4737 return llvm::UndefValue::get(ArgTy);
4741 llvm::Value *Val = Builder.CreateLoad(ArgPtr);
4744 if (ArgTy != Val->getType()) {
4745 if (ArgTy->isPointerTy() && !Val->getType()->isPointerTy())
4746 Val = Builder.CreateIntToPtr(Val, ArgTy);
4748 Val = Builder.CreateTrunc(Val, ArgTy);
4754 Value *ScalarExprEmitter::VisitBlockExpr(
const BlockExpr *block) {
4760 Value *Src,
unsigned NumElementsDst) {
4761 static constexpr
int Mask[] = {0, 1, 2, -1};
4762 return Builder.CreateShuffleVector(Src,
4763 llvm::makeArrayRef(Mask, NumElementsDst));
4783 const llvm::DataLayout &DL,
4784 Value *Src, llvm::Type *DstTy,
4785 StringRef Name =
"") {
4786 auto SrcTy = Src->getType();
4789 if (!SrcTy->isPointerTy() && !DstTy->isPointerTy())
4790 return Builder.CreateBitCast(Src, DstTy, Name);
4793 if (SrcTy->isPointerTy() && DstTy->isPointerTy())
4794 return Builder.CreatePointerBitCastOrAddrSpaceCast(Src, DstTy, Name);
4797 if (SrcTy->isPointerTy() && !DstTy->isPointerTy()) {
4799 if (!DstTy->isIntegerTy())
4800 Src = Builder.CreatePtrToInt(Src, DL.getIntPtrType(SrcTy));
4802 return Builder.CreateBitOrPointerCast(Src, DstTy, Name);
4806 if (!SrcTy->isIntegerTy())
4807 Src = Builder.CreateBitCast(Src, DL.getIntPtrType(DstTy));
4809 return Builder.CreateIntToPtr(Src, DstTy, Name);
4814 llvm::Type *DstTy = ConvertType(E->
getType());
4816 llvm::Type *SrcTy = Src->getType();
4817 unsigned NumElementsSrc =
4818 isa<llvm::VectorType>(SrcTy)
4819 ? cast<llvm::FixedVectorType>(SrcTy)->getNumElements()
4821 unsigned NumElementsDst =
4822 isa<llvm::VectorType>(DstTy)
4823 ? cast<llvm::FixedVectorType>(DstTy)->getNumElements()
4832 if (NumElementsSrc == 3 && NumElementsDst != 3) {
4837 Src->setName(
"astype");
4844 if (NumElementsSrc != 3 && NumElementsDst == 3) {
4845 auto *Vec4Ty = llvm::FixedVectorType::get(
4846 cast<llvm::VectorType>(DstTy)->getElementType(), 4);
4851 Src->setName(
"astype");
4856 Src, DstTy,
"astype");
4871 "Invalid scalar expression to emit");
4873 return ScalarExprEmitter(*
this, IgnoreResultAssign)
4874 .Visit(
const_cast<Expr *
>(E));
4883 "Invalid scalar expression to emit");
4884 return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy, Loc);
4894 "Invalid complex -> scalar conversion");
4895 return ScalarExprEmitter(*
this)
4896 .EmitComplexToScalarConversion(Src, SrcTy, DstTy, Loc);
4902 bool isInc,
bool isPre) {
4903 return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre);
4913 llvm::Type *BaseTy =
4928 ScalarExprEmitter Scalar(*
this);
4929 Value *Result =
nullptr;
4931 #define COMPOUND_OP(Op) \
4932 case BO_##Op##Assign: \
4933 return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \
4970 llvm_unreachable(
"Not valid compound assignment operators");
4973 llvm_unreachable(
"Unhandled compound assignment operator");
4988 llvm::LLVMContext &VMContext,
4994 llvm::Value *TotalOffset =
nullptr;
4997 if (isa<llvm::Constant>(GEPVal)) {
5000 Value *BasePtr_int =
5001 Builder.CreatePtrToInt(BasePtr, DL.getIntPtrType(BasePtr->getType()));
5003 Builder.CreatePtrToInt(GEPVal, DL.getIntPtrType(GEPVal->getType()));
5004 TotalOffset = Builder.CreateSub(GEPVal_int, BasePtr_int);
5005 return {TotalOffset, Builder.getFalse()};
5008 auto *GEP = cast<llvm::GEPOperator>(GEPVal);
5009 assert(GEP->getPointerOperand() == BasePtr &&
5010 "BasePtr must be the base of the GEP.");
5011 assert(GEP->isInBounds() &&
"Expected inbounds GEP");
5013 auto *IntPtrTy = DL.getIntPtrType(GEP->getPointerOperandType());
5016 auto *
Zero = llvm::ConstantInt::getNullValue(IntPtrTy);
5017 auto *SAddIntrinsic =
5018 CGM.
getIntrinsic(llvm::Intrinsic::sadd_with_overflow, IntPtrTy);
5019 auto *SMulIntrinsic =
5020 CGM.
getIntrinsic(llvm::Intrinsic::smul_with_overflow, IntPtrTy);
5023 llvm::Value *OffsetOverflows = Builder.getFalse();
5027 llvm::Value *RHS) -> llvm::Value * {
5028 assert((
Opcode == BO_Add ||
Opcode == BO_Mul) &&
"Can't eval binop");
5031 if (
auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS)) {
5032 if (
auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS)) {
5034 bool HasOverflow = mayHaveIntegerOverflow(LHSCI, RHSCI,
Opcode,
5037 OffsetOverflows = Builder.getTrue();
5038 return llvm::ConstantInt::get(VMContext, N);
5043 auto *ResultAndOverflow = Builder.CreateCall(
5044 (
Opcode == BO_Add) ? SAddIntrinsic : SMulIntrinsic, {LHS, RHS});
5045 OffsetOverflows = Builder.CreateOr(
5046 Builder.CreateExtractValue(ResultAndOverflow, 1), OffsetOverflows);
5047 return Builder.CreateExtractValue(ResultAndOverflow, 0);
5051 for (
auto GTI = llvm::gep_type_begin(GEP), GTE = llvm::gep_type_end(GEP);
5052 GTI != GTE; ++GTI) {
5053 llvm::Value *LocalOffset;
5054 auto *Index = GTI.getOperand();
5056 if (
auto *STy = GTI.getStructTypeOrNull()) {
5059 unsigned FieldNo = cast<llvm::ConstantInt>(Index)->getZExtValue();
5060 LocalOffset = llvm::ConstantInt::get(
5061 IntPtrTy, DL.getStructLayout(STy)->getElementOffset(FieldNo));
5065 auto *ElementSize = llvm::ConstantInt::get(
5066 IntPtrTy, DL.getTypeAllocSize(GTI.getIndexedType()));
5067 auto *IndexS = Builder.CreateIntCast(Index, IntPtrTy,
true);
5068 LocalOffset = eval(BO_Mul, ElementSize, IndexS);
5073 if (!TotalOffset || TotalOffset ==
Zero)
5074 TotalOffset = LocalOffset;
5076 TotalOffset = eval(BO_Add, TotalOffset, LocalOffset);
5079 return {TotalOffset, OffsetOverflows};
5085 bool SignedIndices,
bool IsSubtraction,
5087 llvm::Type *PtrTy = Ptr->getType();
5088 Value *GEPVal =
Builder.CreateInBoundsGEP(ElemTy, Ptr, IdxList, Name);
5091 if (!
SanOpts.
has(SanitizerKind::PointerOverflow))
5095 bool PerformNullCheck = !NullPointerIsDefined(
5096 Builder.GetInsertBlock()->getParent(), PtrTy->getPointerAddressSpace());
5099 bool PerformOverflowCheck =
5100 !isa<llvm::Constant>(GEPVal) && PtrTy->getPointerAddressSpace() == 0;
5102 if (!(PerformNullCheck || PerformOverflowCheck))
5108 llvm::Type *
IntPtrTy = DL.getIntPtrType(PtrTy);
5113 assert((!isa<llvm::Constant>(EvaluatedGEP.
TotalOffset) ||
5115 "If the offset got constant-folded, we don't expect that there was an "
5118 auto *
Zero = llvm::ConstantInt::getNullValue(
IntPtrTy);
5132 if (PerformNullCheck) {
5144 auto *BaseIsNotNullptr =
Builder.CreateIsNotNull(Ptr);
5145 auto *ResultIsNotNullptr =
Builder.CreateIsNotNull(ComputedGEP);
5148 ?
Builder.CreateICmpEQ(BaseIsNotNullptr, ResultIsNotNullptr)
5149 :
Builder.CreateAnd(BaseIsNotNullptr, ResultIsNotNullptr);
5150 Checks.emplace_back(Valid, SanitizerKind::PointerOverflow);
5153 if (PerformOverflowCheck) {
5158 llvm::Value *ValidGEP;
5160 if (SignedIndices) {
5166 auto *PosOrZeroValid =
Builder.CreateICmpUGE(ComputedGEP, IntPtr);
5167 auto *PosOrZeroOffset =
5169 llvm::Value *NegValid =
Builder.CreateICmpULT(ComputedGEP, IntPtr);
5171 Builder.CreateSelect(PosOrZeroOffset, PosOrZeroValid, NegValid);
5177 ValidGEP =
Builder.CreateICmpUGE(ComputedGEP, IntPtr);
5183 ValidGEP =
Builder.CreateICmpULE(ComputedGEP, IntPtr);
5185 ValidGEP =
Builder.CreateAnd(ValidGEP, NoOffsetOverflow);
5186 Checks.emplace_back(ValidGEP, SanitizerKind::PointerOverflow);
5189 assert(!Checks.empty() &&
"Should have produced some checks.");
5193 llvm::Value *DynamicArgs[] = {IntPtr, ComputedGEP};
5194 EmitCheck(Checks, SanitizerHandler::PointerOverflow, StaticArgs, DynamicArgs);