37#define DEBUG_TYPE "instcombine"
41using namespace PatternMatch;
51 if (!V->hasOneUse())
return nullptr;
53 bool MadeChange =
false;
57 Value *
A =
nullptr, *
B =
nullptr, *One =
nullptr;
67 if (
I &&
I->isLogicalShift() &&
76 if (
I->getOpcode() == Instruction::LShr && !
I->isExact()) {
81 if (
I->getOpcode() == Instruction::Shl && !
I->hasNoUnsignedWrap()) {
82 I->setHasNoUnsignedWrap();
91 return MadeChange ? V :
nullptr;
107 bool HasAnyNoWrap =
I.hasNoSignedWrap() ||
I.hasNoUnsignedWrap();
115 bool HasAnyNoWrap =
I.hasNoSignedWrap() ||
I.hasNoUnsignedWrap();
153 bool PropagateNSW = HasNSW && cast<ShlOperator>(
Y)->hasNoSignedWrap();
168 Value *Shl = Builder.
CreateShl(FrX, Z,
"mulshl", HasNUW, PropagateNSW);
189 bool AssumeNonZero,
bool DoFold);
192 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
210 Type *Ty =
I.getType();
212 const bool HasNSW =
I.hasNoSignedWrap();
213 const bool HasNUW =
I.hasNoUnsignedWrap();
232 assert(Shl &&
"Constant folding of immediate constants failed");
235 if (HasNUW &&
Mul->hasNoUnsignedWrap())
251 if (
match(NewCst,
m_APInt(V)) && *V != V->getBitWidth() - 1)
265 auto *Op1C = cast<Constant>(Op1);
269 HasNSW && Op1C->isNotMinSignedValue()));
278 const APInt *NegPow2C;
282 unsigned SrcWidth =
X->getType()->getScalarSizeInBits();
284 if (ShiftAmt >=
BitWidth - SrcWidth) {
287 return BinaryOperator::CreateShl(Z, ConstantInt::get(Ty, ShiftAmt));
308 auto *BOp0 = cast<BinaryOperator>(Op0);
310 (BOp0->getOpcode() == Instruction::Or || BOp0->hasNoUnsignedWrap());
312 auto *BO = BinaryOperator::CreateAdd(NewMul, NewC);
313 if (HasNUW && Op0NUW) {
315 if (
auto *NewMulBO = dyn_cast<BinaryOperator>(NewMul))
316 NewMulBO->setHasNoUnsignedWrap();
317 BO->setHasNoUnsignedWrap();
325 if (Op0 == Op1 &&
match(Op0, m_Intrinsic<Intrinsic::abs>(
m_Value(
X))))
326 return BinaryOperator::CreateMul(
X,
X);
331 if (
I.hasNoSignedWrap() &&
349 auto *NewMul = BinaryOperator::CreateMul(
X,
Y);
350 if (HasNSW && cast<OverflowingBinaryOperator>(Op0)->
hasNoSignedWrap() &&
352 NewMul->setHasNoSignedWrap();
365 return BinaryOperator::CreateMul(NegOp0,
X);
373 auto UDivCheck = [&C1](
const APInt &
C) {
return C.urem(*C1).isZero(); };
374 auto SDivCheck = [&C1](
const APInt &
C) {
382 auto BOpc = cast<BinaryOperator>(Op0)->getOpcode();
395 if (!Div || (Div->
getOpcode() != Instruction::UDiv &&
396 Div->
getOpcode() != Instruction::SDiv)) {
398 Div = dyn_cast<BinaryOperator>(Op1);
400 Value *Neg = dyn_castNegVal(
Y);
403 (Div->
getOpcode() == Instruction::UDiv ||
404 Div->
getOpcode() == Instruction::SDiv)) {
414 auto RemOpc = Div->
getOpcode() == Instruction::UDiv ? Instruction::URem
422 return BinaryOperator::CreateSub(XFreeze, Rem);
423 return BinaryOperator::CreateSub(Rem, XFreeze);
435 return BinaryOperator::CreateAnd(Op0, Op1);
447 X->getType()->isIntOrIntVectorTy(1) &&
X->getType() ==
Y->getType() &&
448 (Op0->
hasOneUse() || Op1->hasOneUse() ||
X ==
Y)) {
457 X->getType()->isIntOrIntVectorTy(1) &&
X->getType() ==
Y->getType() &&
458 (Op0->
hasOneUse() || Op1->hasOneUse())) {
473 X->getType()->isIntOrIntVectorTy(1))
488 *
C ==
C->getBitWidth() - 1) {
500 *
C ==
C->getBitWidth() - 1) {
553 bool Changed =
false;
554 if (!HasNSW && willNotOverflowSignedMul(Op0, Op1,
I)) {
556 I.setHasNoSignedWrap(
true);
559 if (!HasNUW && willNotOverflowUnsignedMul(Op0, Op1,
I,
I.hasNoSignedWrap())) {
561 I.setHasNoUnsignedWrap(
true);
564 return Changed ? &
I :
nullptr;
569 assert((Opcode == Instruction::FMul || Opcode == Instruction::FDiv) &&
570 "Expected fmul or fdiv");
572 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
588 (Op0->
hasOneUse() || Op1->hasOneUse())) {
604 Intrinsic::powi, {
X->getType(), YZ->
getType()}, {
X, YZ}, &
I);
610 unsigned Opcode =
I.getOpcode();
611 assert((Opcode == Instruction::FMul || Opcode == Instruction::FDiv) &&
612 "Unexpected opcode");
619 Constant *One = ConstantInt::get(
Y->getType(), 1);
620 if (willNotOverflowSignedAdd(
Y, One,
I)) {
627 Value *Op0 =
I.getOperand(0);
628 Value *Op1 =
I.getOperand(1);
629 if (Opcode == Instruction::FMul &&
I.isOnlyUserOfAnyOperand() &&
634 Y->getType() == Z->getType()) {
639 if (Opcode == Instruction::FDiv &&
I.hasAllowReassoc() &&
I.hasNoNaNs()) {
646 willNotOverflowSignedSub(
Y, ConstantInt::get(
Y->getType(), 1),
I)) {
648 Instruction *NewPow = createPowiExpr(
I, *
this, Op1,
Y, NegOne);
659 willNotOverflowSignedSub(
Y, ConstantInt::get(
Y->getType(), 1),
I)) {
661 auto *NewPow = createPowiExpr(
I, *
this,
X,
Y, NegOne);
670 Value *Op0 =
I.getOperand(0);
671 Value *Op1 =
I.getOperand(1);
731 BinaryOperator *DivOp = cast<BinaryOperator>(((Z == Op0) ? Op1 : Op0));
756 if (
I.hasNoSignedZeros() &&
760 if (
I.hasNoSignedZeros() &&
767 if (
I.hasNoNaNs() &&
I.hasNoSignedZeros() && Op0 == Op1 && Op0->
hasNUses(2)) {
794 if (
I.isOnlyUserOfAnyOperand()) {
848 I.getFastMathFlags(),
874 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
889 {
I.getType()}, {Op1, Op0}, &
I);
900 if (
I.hasNoNaNs() &&
I.hasNoSignedZeros()) {
905 X->getType()->isIntOrIntVectorTy(1)) {
907 SI->copyFastMathFlags(
I.getFastMathFlags());
911 X->getType()->isIntOrIntVectorTy(1)) {
913 SI->copyFastMathFlags(
I.getFastMathFlags());
922 if (
I.hasAllowReassoc())
931 Log2 = cast<IntrinsicInst>(Op0);
936 Log2 = cast<IntrinsicInst>(Op1);
950 Value *Start =
nullptr, *Step =
nullptr;
964 if (!Result->hasNoNaNs())
965 Result->setHasNoInfs(
false);
976 SelectInst *SI = dyn_cast<SelectInst>(
I.getOperand(1));
1001 Value *SelectCond = SI->getCondition();
1002 if (SI->use_empty() && SelectCond->
hasOneUse())
1008 while (BBI != BBFront) {
1016 for (
Use &
Op : BBI->operands()) {
1020 }
else if (
Op == SelectCond) {
1030 if (&*BBI == SelectCond)
1031 SelectCond =
nullptr;
1034 if (!SelectCond && !SI)
1045 Product = IsSigned ? C1.
smul_ov(C2, Overflow) : C1.
umul_ov(C2, Overflow);
1072 assert((
I.getOpcode() == Instruction::SDiv ||
1073 I.getOpcode() == Instruction::UDiv) &&
1074 "Expected integer divide");
1076 bool IsSigned =
I.getOpcode() == Instruction::SDiv;
1077 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1078 Type *Ty =
I.getType();
1087 auto *
Mul = cast<OverflowingBinaryOperator>(Op0);
1088 auto *Shl = cast<OverflowingBinaryOperator>(Op1);
1089 bool HasNUW =
Mul->hasNoUnsignedWrap() && Shl->hasNoUnsignedWrap();
1090 bool HasNSW =
Mul->hasNoSignedWrap() && Shl->hasNoSignedWrap();
1093 if (!IsSigned && HasNUW)
1097 if (IsSigned && HasNSW && (Op0->
hasOneUse() || Op1->hasOneUse())) {
1107 auto *Shl0 = cast<OverflowingBinaryOperator>(Op0);
1108 auto *Shl1 = cast<OverflowingBinaryOperator>(Op1);
1114 ((Shl0->hasNoUnsignedWrap() && Shl1->hasNoUnsignedWrap()) ||
1115 (Shl0->hasNoUnsignedWrap() && Shl0->hasNoSignedWrap() &&
1116 Shl1->hasNoSignedWrap())))
1121 if (IsSigned && Shl0->hasNoSignedWrap() && Shl1->hasNoSignedWrap() &&
1122 Shl1->hasNoUnsignedWrap())
1130 auto *Shl0 = cast<OverflowingBinaryOperator>(Op0);
1131 auto *Shl1 = cast<OverflowingBinaryOperator>(Op1);
1133 if (IsSigned ? (Shl0->hasNoSignedWrap() && Shl1->hasNoSignedWrap())
1134 : (Shl0->hasNoUnsignedWrap() && Shl1->hasNoUnsignedWrap())) {
1135 Constant *One = ConstantInt::get(
X->getType(), 1);
1139 One,
Y,
"shl.dividend",
1142 IsSigned ? (Shl0->hasNoUnsignedWrap() || Shl1->hasNoUnsignedWrap())
1143 : Shl0->hasNoSignedWrap());
1144 return Builder.
CreateLShr(Dividend, Z,
"",
I.isExact());
1153 assert(
I.isIntDivRem() &&
"Unexpected instruction");
1154 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1158 auto *Op1C = dyn_cast<Constant>(Op1);
1159 Type *Ty =
I.getType();
1160 auto *VTy = dyn_cast<FixedVectorType>(Ty);
1162 unsigned NumElts = VTy->getNumElements();
1163 for (
unsigned i = 0; i != NumElts; ++i) {
1165 if (Elt && (Elt->
isNullValue() || isa<UndefValue>(Elt)))
1203 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1204 bool IsSigned =
I.getOpcode() == Instruction::SDiv;
1205 Type *Ty =
I.getType();
1218 ConstantInt::get(Ty, Product));
1226 if (
isMultiple(*C2, *C1, Quotient, IsSigned)) {
1228 ConstantInt::get(Ty, Quotient));
1229 NewDiv->setIsExact(
I.isExact());
1234 if (
isMultiple(*C1, *C2, Quotient, IsSigned)) {
1236 ConstantInt::get(Ty, Quotient));
1237 auto *OBO = cast<OverflowingBinaryOperator>(Op0);
1238 Mul->setHasNoUnsignedWrap(!IsSigned && OBO->hasNoUnsignedWrap());
1239 Mul->setHasNoSignedWrap(OBO->hasNoSignedWrap());
1252 if (
isMultiple(*C2, C1Shifted, Quotient, IsSigned)) {
1254 ConstantInt::get(Ty, Quotient));
1255 BO->setIsExact(
I.isExact());
1260 if (
isMultiple(C1Shifted, *C2, Quotient, IsSigned)) {
1262 ConstantInt::get(Ty, Quotient));
1263 auto *OBO = cast<OverflowingBinaryOperator>(Op0);
1264 Mul->setHasNoUnsignedWrap(!IsSigned && OBO->hasNoUnsignedWrap());
1265 Mul->setHasNoSignedWrap(OBO->hasNoSignedWrap());
1278 return BinaryOperator::CreateNSWAdd(
X, ConstantInt::get(Ty, Quotient));
1283 return BinaryOperator::CreateNUWAdd(
X,
1284 ConstantInt::get(Ty, C1->
udiv(*C2)));
1325 return BinaryOperator::CreateNSWShl(ConstantInt::get(Ty, 1),
Y);
1327 return BinaryOperator::CreateNUWShl(ConstantInt::get(Ty, 1),
Y);
1331 bool HasNSW = cast<OverflowingBinaryOperator>(Op1)->hasNoSignedWrap();
1332 bool HasNUW = cast<OverflowingBinaryOperator>(Op1)->hasNoUnsignedWrap();
1333 if ((IsSigned && HasNSW) || (!IsSigned && HasNUW)) {
1342 if (!IsSigned && Op1->hasOneUse() &&
1360 auto *InnerDiv = cast<PossiblyExactOperator>(Op0);
1361 auto *
Mul = cast<OverflowingBinaryOperator>(InnerDiv->getOperand(0));
1363 if (!IsSigned &&
Mul->hasNoUnsignedWrap())
1364 NewDiv = BinaryOperator::CreateUDiv(
X,
Y);
1365 else if (IsSigned &&
Mul->hasNoSignedWrap())
1366 NewDiv = BinaryOperator::CreateSDiv(
X,
Y);
1370 NewDiv->
setIsExact(
I.isExact() && InnerDiv->isExact());
1377 auto OB0HasNSW = cast<OverflowingBinaryOperator>(Op0)->
hasNoSignedWrap();
1378 auto OB0HasNUW = cast<OverflowingBinaryOperator>(Op0)->hasNoUnsignedWrap();
1381 auto OB1HasNSW = cast<OverflowingBinaryOperator>(Op1)->
hasNoSignedWrap();
1383 cast<OverflowingBinaryOperator>(Op1)->hasNoUnsignedWrap();
1384 const APInt *C1, *C2;
1385 if (IsSigned && OB0HasNSW) {
1387 return BinaryOperator::CreateSDiv(
A,
B);
1389 if (!IsSigned && OB0HasNUW) {
1391 return BinaryOperator::CreateUDiv(
A,
B);
1393 return BinaryOperator::CreateUDiv(
A,
B);
1399 if (
auto *Val = CreateDivOrNull(
Y, Z))
1403 if (
auto *Val = CreateDivOrNull(
X, Z))
1416 bool AssumeNonZero,
bool DoFold) {
1419 return reinterpret_cast<Value *
>(-1);
1427 return IfFold([&]() {
1443 return IfFold([&]() {
return Builder.
CreateZExt(LogX,
Op->getType()); });
1448 auto *TI = cast<TruncInst>(
Op);
1449 if (AssumeNonZero || TI->hasNoUnsignedWrap())
1451 return IfFold([&]() {
1453 TI->hasNoUnsignedWrap());
1460 auto *BO = cast<OverflowingBinaryOperator>(
Op);
1462 if (AssumeNonZero || BO->hasNoUnsignedWrap() || BO->hasNoSignedWrap())
1464 return IfFold([&]() {
return Builder.
CreateAdd(LogX,
Y); });
1470 auto *PEO = cast<PossiblyExactOperator>(
Op);
1471 if (AssumeNonZero || PEO->isExact())
1473 return IfFold([&]() {
return Builder.
CreateSub(LogX,
Y); });
1480 return IfFold([&]() {
return LogX; });
1482 return IfFold([&]() {
return LogY; });
1489 AssumeNonZero, DoFold))
1491 AssumeNonZero, DoFold))
1492 return IfFold([&]() {
1493 return Builder.
CreateSelect(SI->getOperand(0), LogX, LogY);
1498 auto *
MinMax = dyn_cast<MinMaxIntrinsic>(
Op);
1506 return IfFold([&]() {
1522 Type *Ty =
I.getType();
1525 X->getType() ==
Y->getType() && (
N->hasOneUse() ||
D->hasOneUse())) {
1571 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1573 const APInt *C1, *C2;
1581 X, ConstantInt::get(
X->getType(), C2ShlC1));
1590 Type *Ty =
I.getType();
1611 if (
I.isExact() && cast<PossiblyExactOperator>(Op0)->isExact())
1640 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1641 Type *Ty =
I.getType();
1657 return BinaryOperator::CreateExactAShr(Op0,
C);
1663 return BinaryOperator::CreateExactAShr(Op0, ShAmt);
1698 Constant *NegC = ConstantInt::get(Ty, -(*Op1C));
1732 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1,
I.getName());
1733 BO->setIsExact(
I.isExact());
1751 auto *BO = BinaryOperator::CreateUDiv(Op0, Op1,
I.getName());
1752 BO->setIsExact(
I.isExact());
1782 if (
I.hasNoNaNs() &&
1787 Intrinsic::copysign, {
C->getType()},
1796 if (!(
C->hasExactInverseFP() || (
I.hasAllowReciprocal() &&
C->isNormalFP())))
1804 Instruction::FDiv, ConstantFP::get(
I.getType(), 1.0),
C,
DL);
1805 if (!RecipC || !RecipC->isNormalFP())
1825 if (!
I.hasAllowReassoc() || !
I.hasAllowReciprocal())
1850 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1851 auto *
II = dyn_cast<IntrinsicInst>(Op1);
1852 if (!
II || !
II->hasOneUse() || !
I.hasAllowReassoc() ||
1853 !
I.hasAllowReciprocal())
1863 case Intrinsic::pow:
1864 Args.push_back(
II->getArgOperand(0));
1867 case Intrinsic::powi: {
1875 Args.push_back(
II->getArgOperand(0));
1876 Args.push_back(Builder.
CreateNeg(
II->getArgOperand(1)));
1877 Type *Tys[] = {
I.getType(),
II->getArgOperand(1)->getType()};
1881 case Intrinsic::exp:
1882 case Intrinsic::exp2:
1897 if (!
I.hasAllowReassoc() || !
I.hasAllowReciprocal())
1899 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1900 auto *
II = dyn_cast<IntrinsicInst>(Op1);
1901 if (!
II ||
II->getIntrinsicID() != Intrinsic::sqrt || !
II->hasOneUse() ||
1902 !
II->hasAllowReassoc() || !
II->hasAllowReciprocal())
1906 auto *DivOp = dyn_cast<Instruction>(
II->getOperand(0));
1911 if (!DivOp->hasAllowReassoc() || !
I.hasAllowReciprocal() ||
1912 !DivOp->hasOneUse())
1924 I.getFastMathFlags(),
1943 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
1944 if (isa<Constant>(Op0))
1945 if (
SelectInst *SI = dyn_cast<SelectInst>(Op1))
1949 if (isa<Constant>(Op1))
1950 if (
SelectInst *SI = dyn_cast<SelectInst>(Op0))
1954 if (
I.hasAllowReassoc() &&
I.hasAllowReciprocal()) {
1957 (!isa<Constant>(
Y) || !isa<Constant>(Op1))) {
1963 (!isa<Constant>(
Y) || !isa<Constant>(Op0))) {
1978 if (
I.hasAllowReassoc() && Op0->
hasOneUse() && Op1->hasOneUse()) {
1982 bool IsTan =
match(Op0, m_Intrinsic<Intrinsic::sin>(
m_Value(
X))) &&
1985 !IsTan &&
match(Op0, m_Intrinsic<Intrinsic::cos>(
m_Value(
X))) &&
1988 if ((IsTan || IsCot) &&
hasFloatFn(M, &
TLI,
I.getType(), LibFunc_tan,
1989 LibFunc_tanf, LibFunc_tanl)) {
1992 B.setFastMathFlags(
I.getFastMathFlags());
1994 cast<CallBase>(Op0)->getCalledFunction()->getAttributes();
1996 LibFunc_tanl,
B, Attrs);
1998 Res =
B.CreateFDiv(ConstantFP::get(
I.getType(), 1.0), Res);
2007 if (
I.hasNoNaNs() &&
I.hasAllowReassoc() &&
2016 if (
I.hasNoNaNs() &&
I.hasNoInfs() &&
2020 Intrinsic::copysign, ConstantFP::get(
I.getType(), 1.0),
X, &
I);
2031 if (
I.hasAllowReassoc() &&
2054 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1), *
X =
nullptr;
2056 bool ShiftByX =
false;
2060 bool &PreserveNSW) ->
bool {
2061 const APInt *Tmp =
nullptr;
2080 const APInt *Tmp =
nullptr;
2092 bool Op0PreserveNSW =
true, Op1PreserveNSW =
true;
2093 if (MatchShiftOrMulXC(Op0,
X,
Y, Op0PreserveNSW) &&
2094 MatchShiftOrMulXC(Op1,
X, Z, Op1PreserveNSW)) {
2096 }
else if (MatchShiftCX(Op0,
Y,
X) && MatchShiftCX(Op1, Z,
X)) {
2102 bool IsSRem =
I.getOpcode() == Instruction::SRem;
2109 bool BO0NoWrap = IsSRem ? BO0HasNSW : BO0HasNUW;
2111 APInt RemYZ = IsSRem ?
Y.srem(Z) :
Y.urem(Z);
2115 if (RemYZ.
isZero() && BO0NoWrap)
2121 auto CreateMulOrShift =
2123 Value *RemSimplification =
2124 ConstantInt::get(
I.getType(), RemSimplificationC);
2125 return ShiftByX ? BinaryOperator::CreateShl(RemSimplification,
X)
2126 : BinaryOperator::CreateMul(
X, RemSimplification);
2132 bool BO1NoWrap = IsSRem ? BO1HasNSW : BO1HasNUW;
2136 if (RemYZ ==
Y && BO1NoWrap) {
2147 if (
Y.uge(Z) && (IsSRem ? (BO0HasNSW && BO1HasNSW) : BO0HasNUW)) {
2165 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
2167 if (isa<Constant>(Op1)) {
2168 if (
Instruction *Op0I = dyn_cast<Instruction>(Op0)) {
2169 if (
SelectInst *SI = dyn_cast<SelectInst>(Op0I)) {
2172 }
else if (
auto *PN = dyn_cast<PHINode>(Op0I)) {
2173 const APInt *Op1Int;
2175 (
I.getOpcode() == Instruction::URem ||
2212 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
2213 Type *Ty =
I.getType();
2219 return BinaryOperator::CreateAnd(Op0,
Add);
2245 Value *FrozenOp0 = Op0;
2258 Value *FrozenOp0 = Op0;
2281 Value *Op0 =
I.getOperand(0), *Op1 =
I.getOperand(1);
2300 return BinaryOperator::CreateURem(Op0, Op1,
I.getName());
2304 if (isa<ConstantVector>(Op1) || isa<ConstantDataVector>(Op1)) {
2306 unsigned VWidth = cast<FixedVectorType>(
C->getType())->getNumElements();
2308 bool hasNegative =
false;
2309 bool hasMissing =
false;
2310 for (
unsigned i = 0; i != VWidth; ++i) {
2311 Constant *Elt =
C->getAggregateElement(i);
2318 if (
RHS->isNegative())
2322 if (hasNegative && !hasMissing) {
2324 for (
unsigned i = 0; i != VWidth; ++i) {
2325 Elts[i] =
C->getAggregateElement(i);
2327 if (
RHS->isNegative())
2343 I.getFastMathFlags(),
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
This file provides internal interfaces used to implement the InstCombine.
static Instruction * simplifyIRemMulShl(BinaryOperator &I, InstCombinerImpl &IC)
static Instruction * narrowUDivURem(BinaryOperator &I, InstCombinerImpl &IC)
If we have zero-extended operands of an unsigned div or rem, we may be able to narrow the operation (...
static Value * simplifyValueKnownNonZero(Value *V, InstCombinerImpl &IC, Instruction &CxtI)
The specific integer value is used in a context where it is known to be non-zero.
static const unsigned MaxDepth
static Value * foldMulSelectToNegate(BinaryOperator &I, InstCombiner::BuilderTy &Builder)
static Instruction * foldFDivPowDivisor(BinaryOperator &I, InstCombiner::BuilderTy &Builder)
Negate the exponent of pow/exp to fold division-by-pow() into multiply.
static bool multiplyOverflows(const APInt &C1, const APInt &C2, APInt &Product, bool IsSigned)
True if the multiply can not be expressed in an int this size.
static Value * foldMulShl1(BinaryOperator &Mul, bool CommuteOperands, InstCombiner::BuilderTy &Builder)
Reduce integer multiplication patterns that contain a (+/-1 << Z) factor.
static Value * takeLog2(IRBuilderBase &Builder, Value *Op, unsigned Depth, bool AssumeNonZero, bool DoFold)
static bool isMultiple(const APInt &C1, const APInt &C2, APInt &Quotient, bool IsSigned)
True if C1 is a multiple of C2. Quotient contains C1/C2.
static Instruction * foldFDivSqrtDivisor(BinaryOperator &I, InstCombiner::BuilderTy &Builder)
Convert div to mul if we have an sqrt divisor iff sqrt's operand is a fdiv instruction.
static Instruction * foldFDivConstantDividend(BinaryOperator &I)
Remove negation and try to reassociate constant math.
static Value * foldIDivShl(BinaryOperator &I, InstCombiner::BuilderTy &Builder)
This file provides the interface for the instcombine pass implementation.
static bool hasNoSignedWrap(BinaryOperator &I)
static bool hasNoUnsignedWrap(BinaryOperator &I)
uint64_t IntrinsicInst * II
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
Class for arbitrary precision integers.
APInt umul_ov(const APInt &RHS, bool &Overflow) const
APInt udiv(const APInt &RHS) const
Unsigned division operation.
static void udivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
Dual division/remainder interface.
static APInt getSignMask(unsigned BitWidth)
Get the SignMask for a specific bit width.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
uint64_t getZExtValue() const
Get zero extended value.
static void sdivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
bool isAllOnes() const
Determine if all bits are set. This is true for zero-width values.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
unsigned getBitWidth() const
Return the number of bits in the APInt.
bool ult(const APInt &RHS) const
Unsigned less than comparison.
bool isMinValue() const
Determine if this is the smallest unsigned value.
unsigned countr_zero() const
Count the number of trailing zero bits.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
APInt ushl_ov(const APInt &Amt, bool &Overflow) const
unsigned getSignificantBits() const
Get the minimum bit size for this signed APInt.
APInt smul_ov(const APInt &RHS, bool &Overflow) const
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
static APInt getOneBitSet(unsigned numBits, unsigned BitNo)
Return an APInt with exactly one bit set in the result.
InstListType::iterator iterator
Instruction iterators...
static BinaryOperator * CreateFAddFMF(Value *V1, Value *V2, FastMathFlags FMF, const Twine &Name="")
static BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
BinaryOps getOpcode() const
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
static BinaryOperator * CreateFMulFMF(Value *V1, Value *V2, FastMathFlags FMF, const Twine &Name="")
static BinaryOperator * CreateFDivFMF(Value *V1, Value *V2, FastMathFlags FMF, const Twine &Name="")
static BinaryOperator * CreateFSubFMF(Value *V1, Value *V2, FastMathFlags FMF, const Twine &Name="")
static BinaryOperator * CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, Value *CopyO, const Twine &Name="", InsertPosition InsertBefore=nullptr)
static BinaryOperator * CreateNSWNeg(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
This class represents a function call, abstracting a target machine's calling convention.
static CastInst * CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Create a ZExt or BitCast cast instruction.
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
@ ICMP_ULT
unsigned less than
static Constant * getNeg(Constant *C, bool HasNSW=false)
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getExactLogBase2(Constant *C)
If C is a scalar/fixed width vector of known powers of 2, then this function returns a new scalar/fix...
static Constant * getInfinity(Type *Ty, bool Negative=false)
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getFalse(LLVMContext &Context)
static ConstantInt * getBool(LLVMContext &Context, bool V)
static Constant * get(ArrayRef< Constant * > V)
This is an important base class in LLVM.
static Constant * getAllOnesValue(Type *Ty)
bool isNormalFP() const
Return true if this is a normal (as opposed to denormal, infinity, nan, or zero) floating-point scala...
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
bool isNotMinSignedValue() const
Return true if the value is not the smallest signed value, or, for vectors, does not contain smallest...
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Convenience struct for specifying and reasoning about fast-math flags.
bool allowReassoc() const
Flag queries.
Common base class shared among various IRBuilders.
Value * CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateSRem(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateSelectFMF(Value *C, Value *True, Value *False, FMFSource FMFSource, const Twine &Name="", Instruction *MDFrom=nullptr)
ConstantInt * getTrue()
Get the constant value for i1 true.
Value * CreateSelect(Value *C, Value *True, Value *False, const Twine &Name="", Instruction *MDFrom=nullptr)
Value * CreateFreeze(Value *V, const Twine &Name="")
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateIsNotNeg(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg > -1.
Value * CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateUDiv(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateNeg(Value *V, const Twine &Name="", bool HasNSW=false)
Value * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateBinOpFMF(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, FMFSource FMFSource, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateIsNeg(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg < 0.
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
CallInst * CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with 1 operand which is mangled on its type.
Value * CreateShl(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateSDiv(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="", bool IsNUW=false, bool IsNSW=false)
Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateFAddFMF(Value *L, Value *R, FMFSource FMFSource, const Twine &Name="", MDNode *FPMD=nullptr)
Value * CreateAShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateFNegFMF(Value *V, FMFSource FMFSource, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateFDivFMF(Value *L, Value *R, FMFSource FMFSource, const Twine &Name="", MDNode *FPMD=nullptr)
Value * CreateFMulFMF(Value *L, Value *R, FMFSource FMFSource, const Twine &Name="", MDNode *FPMD=nullptr)
Value * CreateMul(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Instruction * visitMul(BinaryOperator &I)
Instruction * FoldOpIntoSelect(Instruction &Op, SelectInst *SI, bool FoldWithMultiUse=false)
Given an instruction with a select as one operand and a constant as the other operand,...
Instruction * foldBinOpOfSelectAndCastOfSelectCondition(BinaryOperator &I)
Tries to simplify binops of select and cast of the select condition.
Instruction * foldBinOpIntoSelectOrPhi(BinaryOperator &I)
This is a convenience wrapper function for the above two functions.
Instruction * visitUDiv(BinaryOperator &I)
bool SimplifyAssociativeOrCommutative(BinaryOperator &I)
Performs a few simplifications for operators which are associative or commutative.
Value * foldUsingDistributiveLaws(BinaryOperator &I)
Tries to simplify binary operations which some other binary operation distributes over.
Instruction * visitURem(BinaryOperator &I)
Instruction * foldOpIntoPhi(Instruction &I, PHINode *PN, bool AllowMultipleUses=false)
Given a binary operator, cast instruction, or select which has a PHI node as operand #0,...
Instruction * visitSRem(BinaryOperator &I)
Instruction * visitFDiv(BinaryOperator &I)
bool simplifyDivRemOfSelectWithZeroOp(BinaryOperator &I)
Fold a divide or remainder with a select instruction divisor when one of the select operands is zero.
Constant * getLosslessUnsignedTrunc(Constant *C, Type *TruncTy)
Instruction * commonIDivRemTransforms(BinaryOperator &I)
Common integer divide/remainder transforms.
Instruction * commonIDivTransforms(BinaryOperator &I)
This function implements the transforms common to both integer division instructions (udiv and sdiv).
Instruction * foldBinopWithPhiOperands(BinaryOperator &BO)
For a binary operator with 2 phi operands, try to hoist the binary operation before the phi.
Instruction * visitFRem(BinaryOperator &I)
bool SimplifyDemandedInstructionBits(Instruction &Inst)
Tries to simplify operands to an integer instruction based on its demanded bits.
Instruction * visitFMul(BinaryOperator &I)
Instruction * foldFMulReassoc(BinaryOperator &I)
Instruction * foldVectorBinop(BinaryOperator &Inst)
Canonicalize the position of binops relative to shufflevector.
Value * SimplifySelectsFeedingBinaryOp(BinaryOperator &I, Value *LHS, Value *RHS)
Instruction * foldPowiReassoc(BinaryOperator &I)
Instruction * visitSDiv(BinaryOperator &I)
Instruction * commonIRemTransforms(BinaryOperator &I)
This function implements the transforms common to both integer remainder instructions (urem and srem)...
bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero=false, unsigned Depth=0, const Instruction *CxtI=nullptr)
Instruction * replaceInstUsesWith(Instruction &I, Value *V)
A combiner-aware RAUW-like routine.
void replaceUse(Use &U, Value *NewValue)
Replace use and add the previously used value to the worklist.
InstructionWorklist & Worklist
A worklist of the instructions that need to be simplified.
Instruction * replaceOperand(Instruction &I, unsigned OpNum, Value *V)
Replace operand of instruction and add old operand to the worklist.
void computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth, const Instruction *CxtI) const
bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth=0, const Instruction *CxtI=nullptr) const
void push(Instruction *I)
Push the instruction onto the worklist stack.
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag.
bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag.
bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag.
A wrapper class for inspecting calls to intrinsic functions.
A Module instance is used to store all the information related to an LLVM module.
static Value * Negate(bool LHSIsZero, bool IsNSW, Value *Root, InstCombinerImpl &IC)
Attempt to negate Root.
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
bool hasNoSignedWrap() const
Test whether this operation is known to never undergo signed overflow, aka the nsw property.
bool hasNoUnsignedWrap() const
Test whether this operation is known to never undergo unsigned overflow, aka the nuw property.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
This class represents a sign extension of integer types.
This class represents the LLVM 'select' instruction.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, Instruction *MDFrom=nullptr)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
static UnaryOperator * CreateFNegFMF(Value *Op, Instruction *FMFSource, const Twine &Name="", InsertPosition InsertBefore=nullptr)
A Use represents the edge between a Value definition and its users.
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
bool hasOneUse() const
Return true if there is exactly one use of this value.
bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
This class represents zero extension of integer types.
An efficient, type-erasing, non-owning reference to a callable.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
BinaryOp_match< LHS, RHS, Instruction::FMul, true > m_c_FMul(const LHS &L, const RHS &R)
Matches FMul with LHS and RHS in either order.
cst_pred_ty< is_sign_mask > m_SignMask()
Match an integer or vector with only the sign bit(s) set.
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
AllowReassoc_match< T > m_AllowReassoc(const T &SubPattern)
CastInst_match< OpTy, TruncInst > m_Trunc(const OpTy &Op)
Matches Trunc.
specific_intval< false > m_SpecificInt(const APInt &V)
Match a specific integer value or vector with all elements equal to the value.
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
bool match(Val *V, const Pattern &P)
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
specific_intval< true > m_SpecificIntAllowPoison(const APInt &V)
OverflowingBinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWNeg(const ValTy &V)
Matches a 'Neg' as 'sub nsw 0, V'.
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
specific_fpval m_SpecificFP(double V)
Match a specific floating point value or vector with all elements equal to the value.
m_Intrinsic_Ty< Opnd0 >::Ty m_Sqrt(const Opnd0 &Op0)
BinaryOp_match< LHS, RHS, Instruction::FAdd > m_FAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
deferredval_ty< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
apint_match m_APIntAllowPoison(const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
OneUse_match< T > m_OneUse(const T &SubPattern)
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > m_NSWShl(const LHS &L, const RHS &R)
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
cst_pred_ty< is_negated_power2 > m_NegatedPower2()
Match a integer or vector negated power-of-2.
cst_pred_ty< custom_checkfn< APInt > > m_CheckedInt(function_ref< bool(const APInt &)> CheckFn)
Match an integer or vector where CheckFn(ele) for each element is true.
apfloat_match m_APFloatAllowPoison(const APFloat *&Res)
Match APFloat while allowing poison in splat vector constants.
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > > m_AddLike(const LHS &L, const RHS &R)
Match either "add" or "or disjoint".
CastInst_match< OpTy, UIToFPInst > m_UIToFP(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > > m_NSWAddLike(const LHS &L, const RHS &R)
Match either "add nsw" or "or disjoint".
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > m_ZExtOrSExt(const OpTy &Op)
Exact_match< T > m_Exact(const T &SubPattern)
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
cstfp_pred_ty< is_pos_zero_fp > m_PosZeroFP()
Match a floating-point positive zero.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::FDiv > m_FDiv(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
CastInst_match< OpTy, SExtInst > m_SExt(const OpTy &Op)
Matches SExt.
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > > m_NUWAddLike(const LHS &L, const RHS &R)
Match either "add nuw" or "or disjoint".
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
BinaryOp_match< LHS, RHS, Instruction::Mul, true > m_c_Mul(const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > m_NSWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
This is an optimization pass for GlobalISel generic memory operations.
Value * emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs)
Emit a call to the unary function named 'Name' (e.g.
Value * simplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FMul, fold the result or return null.
Value * simplifySDivInst(Value *LHS, Value *RHS, bool IsExact, const SimplifyQuery &Q)
Given operands for an SDiv, fold the result or return null.
Value * simplifyMulInst(Value *LHS, Value *RHS, bool IsNSW, bool IsNUW, const SimplifyQuery &Q)
Given operands for a Mul, fold the result or return null.
bool hasFloatFn(const Module *M, const TargetLibraryInfo *TLI, Type *Ty, LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn)
Check whether the overloaded floating point function corresponding to Ty is available.
bool isGuaranteedNotToBeUndef(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be undef, but may be poison.
bool matchSimpleRecurrence(const PHINode *P, BinaryOperator *&BO, Value *&Start, Value *&Step)
Attempt to match a simple first order recurrence cycle of the form: iv = phi Ty [Start,...
Constant * ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op, const DataLayout &DL)
Attempt to constant fold a unary operation with the specified operand.
Value * simplifyFRemInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FRem, fold the result or return null.
Value * simplifyICmpInst(CmpPredicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an ICmpInst, fold the result or return null.
Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
Value * simplifyFDivInst(Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, fp::ExceptionBehavior ExBehavior=fp::ebIgnore, RoundingMode Rounding=RoundingMode::NearestTiesToEven)
Given operands for an FDiv, fold the result or return null.
@ Mul
Product of integers.
@ And
Bitwise or logical AND of integers.
Value * simplifyUDivInst(Value *LHS, Value *RHS, bool IsExact, const SimplifyQuery &Q)
Given operands for a UDiv, fold the result or return null.
DWARFExpression::Operation Op
constexpr unsigned BitWidth
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
Value * simplifySRemInst(Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for an SRem, fold the result or return null.
unsigned Log2(Align A)
Returns the log2 of the alignment.
bool isKnownNeverNaN(const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if the floating-point scalar value is not a NaN or if the floating-point vector value has...
bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)
Return true if the two given values are negation.
bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
Value * simplifyURemInst(Value *LHS, Value *RHS, const SimplifyQuery &Q)
Given operands for a URem, fold the result or return null.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
bool isNonNegative() const
Returns true if this value is known to be non-negative.
unsigned countMinTrailingZeros() const
Returns the minimum number of trailing zero bits.
SimplifyQuery getWithInstruction(const Instruction *I) const