ValueTracking.cpp Source File (original) (raw)

59#include "llvm/IR/IntrinsicsAArch64.h"

60#include "llvm/IR/IntrinsicsAMDGPU.h"

61#include "llvm/IR/IntrinsicsRISCV.h"

62#include "llvm/IR/IntrinsicsX86.h"

79#include

80#include

81#include

82#include

83#include

85using namespace llvm;

100 if (unsigned BitWidth = Ty->getScalarSizeInBits())

102

103 return DL.getPointerTypeSizeInBits(Ty);

104}

105

106

107

109

110

112 return CxtI;

113

114

117 return CxtI;

118

119 return nullptr;

120}

121

123 const APInt &DemandedElts,

124 APInt &DemandedLHS, APInt &DemandedRHS) {

127 DemandedLHS = DemandedRHS = DemandedElts;

128 return true;

129 }

130

131 int NumElts =

134 DemandedElts, DemandedLHS, DemandedRHS);

135}

136

140

143

144

145

147 APInt DemandedElts =

150}

151

155 bool UseInstrInfo, unsigned Depth) {

159}

160

164 unsigned Depth) {

167}

168

173 unsigned Depth) {

175 V, DemandedElts,

177}

178

181

182 {

187 return true;

188 }

189

190

193 return true;

194

195

196

202 return true;

203

204

205

209 return true;

210

211

212 {

218 return true;

219 }

220

221

222

223 {

230 R->uge(LHS->getType()->getScalarSizeInBits()))

231 return true;

232 }

233

234 return false;

235}

236

242

243 assert(LHS->getType() == RHS->getType() &&

244 "LHS and RHS should have the same type");

245 assert(LHS->getType()->isIntOrIntVectorTy() &&

246 "LHS and RHS should be integers");

247

250 return true;

251

254}

255

257 return ->user_empty() &&

259}

260

262 return ->user_empty() && all_of(I->users(), [](const User *U) {

263 CmpPredicate P;

264 return match(U, m_ICmp(P, m_Value(), m_Zero())) && ICmpInst::isEquality(P);

265 });

266}

267

272 unsigned Depth) {

273 return ::isKnownToBeAPowerOfTwo(

276}

277

280

282 unsigned Depth) {

284}

285

287 unsigned Depth) {

289 return CI->getValue().isStrictlyPositive();

290

291

292

296}

297

299 unsigned Depth) {

301}

302

306

309

311 return false;

313 APInt DemandedElts =

315 return ::isKnownNonEqual(V1, V2, DemandedElts, Q, Depth);

316}

317

320 KnownBits Known(Mask.getBitWidth());

322 return Mask.isSubsetOf(Known.Zero);

323}

324

327

329 unsigned Depth = 0) {

331 APInt DemandedElts =

334}

335

339 unsigned Depth) {

340 return ::ComputeNumSignBits(

342}

343

348 unsigned Depth) {

350 return V->getType()->getScalarSizeInBits() - SignBits + 1;

351}

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

373 const APInt &DemandedElts,

376 unsigned Depth) {

377

379 const unsigned BitWidth = Ty->getScalarSizeInBits();

380

381

382 if (Ty->isVectorTy())

383 return;

384

385

386

387 const Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr;

389

390 const auto MatchSubBC = [&]() {

391

392

393

394

395

396

397

398

399

400

401

402

405 };

406

407 const auto MatchASubBC = [&]() {

408

409

410

411

413 };

414

415 const auto MatchCD = [&]() {

416

417

418

419

421 };

422

424

425

426

427

428

430 };

431

432 if (!Match(Op0, Op1) && !Match(Op1, Op0))

433 return;

434

435 const auto ComputeKnownBitsOrOne = [&](const Value *V) {

436

437

440 };

441

442

443 const KnownBits KnownA = ComputeKnownBitsOrOne(A);

445 return;

446

447 const KnownBits KnownD = ComputeKnownBitsOrOne(D);

449 return;

450

453 return;

454

457 return;

458

459

460

461

462

463

464 if (SubBC->getOpcode() == Instruction::Xor &&

466 return;

467

472

473

474 bool Overflow;

475 const APInt UpperBound = MaxAD.umul_ov(MaxB, Overflow);

476

477 if (Overflow)

478 return;

479

480

481

482 const unsigned MinimumNumberOfLeadingZeros = UpperBound.countl_zero();

484}

485

487 bool NSW, bool NUW,

488 const APInt &DemandedElts,

492

493

494

495 if (KnownOut.isUnknown() && !NSW && !NUW)

496 return;

497

500

503 .value_or(false))

505

507

509}

510

512 bool NUW, const APInt &DemandedElts,

517

520

521 if (NSW) {

522 if (Op0 == Op1) {

523

525 } else {

526 bool isKnownNonNegativeOp1 = Known.isNonNegative();

527 bool isKnownNonNegativeOp0 = Known2.isNonNegative();

528 bool isKnownNegativeOp1 = Known.isNegative();

529 bool isKnownNegativeOp0 = Known2.isNegative();

530

532 (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);

534

538 }

539

540

541

544 (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&

546 (isKnownNegativeOp0 && isKnownNonNegativeOp1 && Known.isNonZero());

547 }

548 }

549

550 bool SelfMultiply = Op0 == Op1;

551 if (SelfMultiply)

552 SelfMultiply &=

555

556 if (SelfMultiply) {

559 unsigned OutValidBits = 2 * (TyBits - SignBits + 1);

560

561 if (OutValidBits < TyBits) {

562 APInt KnownZeroMask =

564 Known.Zero |= KnownZeroMask;

565 }

566 }

567

568

569

570

571

572

577}

578

582 unsigned NumRanges = Ranges.getNumOperands() / 2;

583 assert(NumRanges >= 1);

584

586

587 for (unsigned i = 0; i < NumRanges; ++i) {

593

594

596 "Known bit width must match range bit width!");

597

598

599 unsigned CommonPrefixBits =

600 (Range.getUnsignedMax() ^ Range.getUnsignedMin()).countl_zero();

603 Known.One &= UnsignedMax & Mask;

604 Known.Zero &= ~UnsignedMax & Mask;

605 }

606}

607

612

613

614

615

617 return true;

618

619 while (!WorkSet.empty()) {

621 if (!Visited.insert(V).second)

622 continue;

623

624

625 if (all_of(V->users(), [&](const User *U) {

626 return EphValues.count(cast(U));

627 })) {

628 if (V == E)

629 return true;

630

631 if (V == I || (!V->mayHaveSideEffects() && !V->isTerminator())) {

633

635 for (const Use &U : U->operands()) {

638 }

639 }

640 }

641 }

642 }

643

644 return false;

645}

646

647

650 return CI->isAssumeLikeIntrinsic();

651

652 return false;

653}

654

658 bool AllowEphemerals) {

659

660

661

662

663

664

665

666

668

669

671 return true;

672

673

674

675

676 if (!AllowEphemerals && Inv == CxtI)

677 return false;

678

679

680

681

682

683

684

687 return false;

688

690 }

691

692

693 if (DT) {

695 return true;

696 } else if (Inv->getParent() == CxtI->getParent()->getSinglePredecessor() ||

697 Inv->getParent()->isEntryBlock()) {

698

699 return true;

700 }

701

702 return false;

703}

704

707

708 auto hasNoFreeCalls = [](auto Range) {

711 return false;

713 if (!CB->hasFnAttr(Attribute::NoFree))

714 return false;

715 }

716 return true;

717 };

718

719

720

722 return false;

723

724

726 const BasicBlock *AssumeBB = Assume->getParent();

728 if (CtxBB != AssumeBB) {

730 return false;

731

732 if (!hasNoFreeCalls(make_range(CtxBB->begin(), CtxIter)))

733 return false;

734

735 CtxIter = AssumeBB->end();

736 } else {

737

738 if (!Assume->comesBefore(CtxI))

739 return false;

740 }

741

742

743

744 return hasNoFreeCalls(make_range(Assume->getIterator(), CtxIter));

745}

746

747

748

749

750

751

753

755 return true;

756

757

760

761

763 auto Zero = APInt::getZero(RHS->getType()->getScalarSizeInBits());

766 return !TrueValues.contains(Zero);

767 }

768

770 if (VC == nullptr)

771 return false;

772

773 for (unsigned ElemIdx = 0, NElem = VC->getNumElements(); ElemIdx < NElem;

774 ++ElemIdx) {

776 Pred, VC->getElementAsAPInt(ElemIdx));

777 if (TrueValues.contains(Zero))

778 return false;

779 }

780 return true;

781}

782

785 const PHINode **PhiOut = nullptr) {

786 ValOut = U->get();

787 if (ValOut == PHI)

788 return;

789 CtxIOut = PHI->getIncomingBlock(*U)->getTerminator();

790 if (PhiOut)

791 *PhiOut = PHI;

793

794

795

798 ValOut = V;

799

800

801

802

803

805 IncPhi && IncPhi->getNumIncomingValues() == 2) {

806 for (int Idx = 0; Idx < 2; ++Idx) {

807 if (IncPhi->getIncomingValue(Idx) == PHI) {

808 ValOut = IncPhi->getIncomingValue(1 - Idx);

809 if (PhiOut)

810 *PhiOut = IncPhi;

811 CtxIOut = IncPhi->getIncomingBlock(1 - Idx)->getTerminator();

812 break;

813 }

814 }

815 }

816}

817

819

820

821 if (!Q.AC || !Q.CxtI)

822 return false;

823

825 if (!Elem.Assume)

826 continue;

827

830 "Got assumption for the wrong function!");

831

833 if (!V->getType()->isPointerTy())

834 continue;

836 *I, I->bundle_op_info_begin()[Elem.Index])) {

837 if (RK.WasOn == V &&

838 (RK.AttrKind == Attribute::NonNull ||

839 (RK.AttrKind == Attribute::Dereferenceable &&

843 return true;

844 }

845 continue;

846 }

847

848

849

850

851

856 continue;

857

859 return true;

860 }

861

862 return false;

863}

864

868 if (RHS->getType()->isPointerTy()) {

869

870

872 switch (Pred) {

875 break;

879 break;

882 break;

883 default:

884 break;

885 }

886 }

887 return;

888 }

889

891 auto m_V =

893

895 const APInt *Mask, *C;

897 return;

898

900 switch (Pred) {

902

905

907

908 Known.One |= *C;

910 Known.Zero |= ~*C & *Mask;

911

913

914 Known.Zero |= ~*C;

916 Known.One |= *C & ~*Mask;

917

920

921

923 RHSKnown >>= ShAmt;

924 Known = Known.unionWith(RHSKnown);

925

928

929

931 RHSKnown <<= ShAmt;

932 Known = Known.unionWith(RHSKnown);

933 }

934 break;

936

937 const APInt *BPow2;

939 Known.One |= *BPow2;

940 break;

941 }

942 default: {

947 LHSRange = LHSRange.sub(*Offset);

949 }

951

952

957 }

959

960

965 }

966 }

967 } break;

968 }

969}

970

975 Invert ? Cmp->getInversePredicate() : Cmp->getPredicate();

976 Value *LHS = Cmp->getOperand(0);

977 Value *RHS = Cmp->getOperand(1);

978

979

981 KnownBits DstKnown(LHS->getType()->getScalarSizeInBits());

985 else

987 return;

988 }

989

991}

992

995 bool Invert, unsigned Depth) {

1005 Known2 = Known2.unionWith(Known3);

1006 else

1008 Known = Known.unionWith(Known2);

1009 return;

1010 }

1011

1014 return;

1015 }

1016

1019 if (Invert) {

1021 } else {

1023 }

1026 return;

1027 }

1029 return;

1030 }

1031

1034}

1035

1038

1041

1042 if (!Q.CxtI)

1043 return;

1044

1045 if (Q.DC && Q.DT) {

1046

1048 BasicBlockEdge Edge0(BI->getParent(), BI->getSuccessor(0));

1051 false, Depth);

1052

1053 BasicBlockEdge Edge1(BI->getParent(), BI->getSuccessor(1));

1056 true, Depth);

1057 }

1058

1061 }

1062

1063 if (!Q.AC)

1064 return;

1065

1067

1068

1069

1070

1072 if (!Elem.Assume)

1073 continue;

1074

1077 "Got assumption for the wrong function!");

1078

1080 if (!V->getType()->isPointerTy())

1081 continue;

1083 *I, I->bundle_op_info_begin()[Elem.Index])) {

1084

1085

1086

1087 if (RK.WasOn == V && RK.AttrKind == Attribute::Alignment &&

1091 }

1092 continue;

1093 }

1094

1095

1096

1097

1098

1099 Value *Arg = I->getArgOperand(0);

1100

1102 assert(BitWidth == 1 && "assume operand is not i1?");

1105 return;

1106 }

1109 assert(BitWidth == 1 && "assume operand is not i1?");

1112 return;

1113 }

1115 if (Trunc && Trunc->getOperand(0) == V &&

1117 if (Trunc->hasNoUnsignedWrap()) {

1119 return;

1120 }

1122 return;

1123 }

1124

1125

1127 continue;

1128

1130 if (!Cmp)

1131 continue;

1132

1134 continue;

1135

1137 }

1138

1139

1140

1143}

1144

1145

1146

1147

1148

1149

1150

1151

1152

1159

1160

1161 bool ShAmtNonZero =

1165 Known = KF(Known2, Known, ShAmtNonZero);

1166}

1167

1174 bool IsAnd = false;

1175 bool HasKnownOne = !KnownLHS.One.isZero() || !KnownRHS.One.isZero();

1176 Value *X = nullptr, *Y = nullptr;

1177

1178 switch (I->getOpcode()) {

1179 case Instruction::And:

1180 KnownOut = KnownLHS & KnownRHS;

1181 IsAnd = true;

1182

1183

1184

1185

1186

1188

1190 KnownOut = KnownLHS.blsi();

1191 else

1192 KnownOut = KnownRHS.blsi();

1193 }

1194 break;

1195 case Instruction::Or:

1196 KnownOut = KnownLHS | KnownRHS;

1197 break;

1198 case Instruction::Xor:

1199 KnownOut = KnownLHS ^ KnownRHS;

1200

1201

1202

1203

1204

1205

1206

1207 if (HasKnownOne &&

1209 const KnownBits &XBits = I->getOperand(0) == X ? KnownLHS : KnownRHS;

1210 KnownOut = XBits.blsmsk();

1211 }

1212 break;

1213 default:

1214 llvm_unreachable("Invalid Op used in 'analyzeKnownBitsFromAndXorOr'");

1215 }

1216

1217

1218

1219

1220

1221

1222

1223 if (!KnownOut.Zero[0] && !KnownOut.One[0] &&

1230 if (IsAnd)

1232 else

1234 }

1235 }

1236 return KnownOut;

1237}

1238

1243 KnownBitsFunc) {

1244 APInt DemandedEltsLHS, DemandedEltsRHS;

1246 DemandedElts, DemandedEltsLHS,

1247 DemandedEltsRHS);

1248

1249 const auto ComputeForSingleOpFunc =

1250 [Depth, &Q, KnownBitsFunc](const Value *Op, APInt &DemandedEltsOp) {

1251 return KnownBitsFunc(

1254 };

1255

1256 if (DemandedEltsRHS.isZero())

1257 return ComputeForSingleOpFunc(I->getOperand(0), DemandedEltsLHS);

1258 if (DemandedEltsLHS.isZero())

1259 return ComputeForSingleOpFunc(I->getOperand(1), DemandedEltsRHS);

1260

1261 return ComputeForSingleOpFunc(I->getOperand(0), DemandedEltsLHS)

1262 .intersectWith(ComputeForSingleOpFunc(I->getOperand(1), DemandedEltsRHS));

1263}

1264

1265

1270 unsigned Depth) {

1272 APInt DemandedElts =

1274

1277}

1278

1280 Attribute Attr = F->getFnAttribute(Attribute::VScaleRange);

1281

1284

1286

1288 return ConstantRange::getEmpty(BitWidth);

1289

1294

1296}

1297

1299 Value *Arm, bool Invert,

1301

1303 return;

1304

1305

1308

1309

1311 return;

1312

1313

1314

1315

1316

1317

1318 CondRes = CondRes.unionWith(Known);

1320 return;

1321

1322

1323

1325 return;

1326

1327

1328

1329 Known = CondRes;

1330}

1331

1332

1333

1335 const APInt *&CLow, const APInt *&CHigh) {

1338 "Input should be a Select!");

1339

1340 const Value *LHS = nullptr, *RHS = nullptr;

1343 return false;

1344

1346 return false;

1347

1348 const Value *LHS2 = nullptr, *RHS2 = nullptr;

1351 return false;

1352

1354 return false;

1355

1358

1359 In = LHS2;

1360 return CLow->sle(*CHigh);

1361}

1362

1364 const APInt *&CLow,

1365 const APInt *&CHigh) {

1366 assert((II->getIntrinsicID() == Intrinsic::smin ||

1367 II->getIntrinsicID() == Intrinsic::smax) &&

1368 "Must be smin/smax");

1369

1372 if (!InnerII || InnerII->getIntrinsicID() != InverseID ||

1374 match (InnerII->getArgOperand(1), m_APInt(CHigh)))

1375 return false;

1376

1377 if (II->getIntrinsicID() == Intrinsic::smin)

1379 return CLow->sle(*CHigh);

1380}

1381

1384 const APInt *CLow, *CHigh;

1388}

1389

1391 const APInt &DemandedElts,

1394 unsigned Depth) {

1396

1398 switch (I->getOpcode()) {

1399 default: break;

1400 case Instruction::Load:

1404 break;

1405 case Instruction::And:

1408

1410 break;

1411 case Instruction::Or:

1414

1416 break;

1417 case Instruction::Xor:

1420

1422 break;

1423 case Instruction::Mul: {

1427 DemandedElts, Known, Known2, Q, Depth);

1428 break;

1429 }

1430 case Instruction::UDiv: {

1433 Known =

1435 break;

1436 }

1437 case Instruction::SDiv: {

1440 Known =

1442 break;

1443 }

1444 case Instruction::Select: {

1445 auto ComputeForArm = [&](Value *Arm, bool Invert) {

1449 return Res;

1450 };

1451

1452 Known =

1453 ComputeForArm(I->getOperand(1), false)

1454 .intersectWith(ComputeForArm(I->getOperand(2), true));

1455 break;

1456 }

1457 case Instruction::FPTrunc:

1458 case Instruction::FPExt:

1459 case Instruction::FPToUI:

1460 case Instruction::FPToSI:

1461 case Instruction::SIToFP:

1462 case Instruction::UIToFP:

1463 break;

1464 case Instruction::PtrToInt:

1465 case Instruction::IntToPtr:

1466

1467 [[fallthrough]];

1468 case Instruction::ZExt:

1469 case Instruction::Trunc: {

1470 Type *SrcTy = I->getOperand(0)->getType();

1471

1472 unsigned SrcBitWidth;

1473

1474

1479

1480 assert(SrcBitWidth && "SrcBitWidth can't be zero");

1484 Inst && Inst->hasNonNeg() && !Known.isNegative())

1487 break;

1488 }

1489 case Instruction::BitCast: {

1490 Type *SrcTy = I->getOperand(0)->getType();

1491 if (SrcTy->isIntOrPtrTy() &&

1492

1493

1494 ->getType()->isVectorTy()) {

1496 break;

1497 }

1498

1500

1502 V->getType()->isFPOrFPVectorTy()) {

1503 Type *FPType = V->getType()->getScalarType();

1506 FPClassTest FPClasses = Result.KnownFPClasses;

1507

1508

1509 if (FPClasses == fcNone)

1510 break;

1511

1514

1515 if (FPClasses & fcInf)

1517 APFloat::getInf(FPType->getFltSemantics()).bitcastToAPInt()));

1518

1519 if (FPClasses & fcZero)

1522

1525 }

1526

1527 if (Result.SignBit) {

1528 if (*Result.SignBit)

1530 else

1532 }

1533

1534 break;

1535 }

1536

1537

1539 if (!SrcVecTy || !SrcVecTy->getElementType()->isIntegerTy() ||

1540 ->getType()->isIntOrIntVectorTy() ||

1542 break;

1543

1544 unsigned NumElts = DemandedElts.getBitWidth();

1546

1547

1548 unsigned SubBitWidth = SrcVecTy->getScalarSizeInBits();

1549 if (BitWidth % SubBitWidth == 0) {

1550

1551

1552

1553

1554

1555

1556

1557

1558

1559

1560

1561

1562

1563

1564 unsigned SubScale = BitWidth / SubBitWidth;

1566 for (unsigned i = 0; i != NumElts; ++i) {

1567 if (DemandedElts[i])

1568 SubDemandedElts.setBit(i * SubScale);

1569 }

1570

1571 KnownBits KnownSrc(SubBitWidth);

1572 for (unsigned i = 0; i != SubScale; ++i) {

1575 unsigned ShiftElt = IsLE ? i : SubScale - 1 - i;

1576 Known.insertBits(KnownSrc, ShiftElt * SubBitWidth);

1577 }

1578 }

1579

1580

1581 if (SubBitWidth % BitWidth == 0) {

1582 unsigned SubScale = SubBitWidth / BitWidth;

1583 KnownBits KnownSrc(SubBitWidth);

1584 APInt SubDemandedElts =

1586 computeKnownBits(I->getOperand(0), SubDemandedElts, KnownSrc, Q,

1588

1590 for (unsigned i = 0; i != NumElts; ++i) {

1591 if (DemandedElts[i]) {

1592 unsigned Shifts = IsLE ? i : NumElts - 1 - i;

1596 break;

1597 }

1598 }

1599 }

1600 break;

1601 }

1602 case Instruction::SExt: {

1603

1604 unsigned SrcBitWidth = I->getOperand(0)->getType()->getScalarSizeInBits();

1605

1606 Known = Known.trunc(SrcBitWidth);

1608

1609

1611 break;

1612 }

1613 case Instruction::Shl: {

1616 auto KF = [NUW, NSW](const KnownBits &KnownVal, const KnownBits &KnownAmt,

1617 bool ShAmtNonZero) {

1618 return KnownBits::shl(KnownVal, KnownAmt, NUW, NSW, ShAmtNonZero);

1619 };

1621 KF);

1622

1626 break;

1627 }

1628 case Instruction::LShr: {

1630 auto KF = [Exact](const KnownBits &KnownVal, const KnownBits &KnownAmt,

1631 bool ShAmtNonZero) {

1632 return KnownBits::lshr(KnownVal, KnownAmt, ShAmtNonZero, Exact);

1633 };

1635 KF);

1636

1640 break;

1641 }

1642 case Instruction::AShr: {

1644 auto KF = [Exact](const KnownBits &KnownVal, const KnownBits &KnownAmt,

1645 bool ShAmtNonZero) {

1646 return KnownBits::ashr(KnownVal, KnownAmt, ShAmtNonZero, Exact);

1647 };

1649 KF);

1650 break;

1651 }

1652 case Instruction::Sub: {

1656 DemandedElts, Known, Known2, Q, Depth);

1657 break;

1658 }

1659 case Instruction::Add: {

1663 DemandedElts, Known, Known2, Q, Depth);

1664 break;

1665 }

1666 case Instruction::SRem:

1670 break;

1671

1672 case Instruction::URem:

1676 break;

1677 case Instruction::Alloca:

1679 break;

1680 case Instruction::GetElementPtr: {

1681

1682

1684

1685

1687 APInt AccConstIndices(IndexWidth, 0);

1688

1689 auto AddIndexToKnown = [&](KnownBits IndexBits) {

1690 if (IndexWidth == BitWidth) {

1691

1692

1694 } else {

1695

1696

1698 "Index width can't be larger than pointer width");

1700 }

1701 };

1702

1704 for (unsigned i = 1, e = I->getNumOperands(); i != e; ++i, ++GTI) {

1705

1707 break;

1708

1709 Value *Index = I->getOperand(i);

1710

1711

1714 continue;

1715

1717

1718

1720 "Access to structure field must be known at compile time");

1721

1724

1728 AccConstIndices += Offset;

1729 continue;

1730 }

1731

1732

1734 if (!IndexedTy->isSized()) {

1736 break;

1737 }

1738

1742

1744 AccConstIndices +=

1745 CI->getValue().sextOrTrunc(IndexWidth) * StrideInBytes;

1746 continue;

1747 }

1748 }

1749

1752 KnownBits ScalingFactor(IndexWidth);

1753

1754

1756

1757

1759 } else {

1760 ScalingFactor =

1762 }

1763 AddIndexToKnown(KnownBits::mul(IndexBits, ScalingFactor));

1764 }

1767 break;

1768 }

1769 case Instruction::PHI: {

1772 Value *R = nullptr, *L = nullptr;

1774

1775

1776

1777 unsigned Opcode = BO->getOpcode();

1778

1779 switch (Opcode) {

1780

1781

1782

1783

1784

1785 case Instruction::LShr:

1786 case Instruction::AShr:

1787 case Instruction::Shl:

1788 case Instruction::UDiv:

1790 break;

1791 [[fallthrough]];

1792

1793

1794

1795 case Instruction::URem: {

1796

1797

1798

1799

1800

1801

1802

1803

1807 switch (Opcode) {

1808 case Instruction::Shl:

1809

1811 break;

1812 case Instruction::LShr:

1813 case Instruction::UDiv:

1814 case Instruction::URem:

1815

1816

1818 break;

1819 case Instruction::AShr:

1820

1823 break;

1824 }

1825 break;

1826 }

1827

1828

1829

1830

1831 case Instruction::Add:

1832 case Instruction::Sub:

1833 case Instruction::And:

1834 case Instruction::Or:

1835 case Instruction::Mul: {

1836

1837

1838

1839

1841

1842 unsigned OpNum = P->getOperand(0) == R ? 0 : 1;

1843 Instruction *RInst = P->getIncomingBlock(OpNum)->getTerminator();

1844 Instruction *LInst = P->getIncomingBlock(1 - OpNum)->getTerminator();

1845

1846

1847

1848 RecQ.CxtI = RInst;

1850

1851

1853 RecQ.CxtI = LInst;

1855

1858

1861 break;

1862

1863 switch (Opcode) {

1864

1865

1866

1867

1868

1869

1870

1871

1872

1873 case Instruction::Add: {

1878 break;

1879 }

1880

1881

1882

1883 case Instruction::Sub: {

1885 break;

1890 break;

1891 }

1892

1893

1894 case Instruction::Mul:

1897 break;

1898

1899 default:

1900 break;

1901 }

1902 break;

1903 }

1904

1905 default:

1906 break;

1907 }

1908 }

1909

1910

1911 if (P->getNumIncomingValues() == 0)

1912 break;

1913

1914

1915

1917

1919 break;

1920

1922 for (const Use &U : P->operands()) {

1923 Value *IncValue;

1927

1928 if (IncValue == P)

1929 continue;

1930

1931

1932

1933

1934

1936

1938

1939

1940

1941

1942

1945

1946

1947

1950 const APInt *RHSC;

1952

1956

1957 if ((TrueSucc == CxtPhi->getParent()) !=

1958 (FalseSucc == CxtPhi->getParent())) {

1959

1960 if (FalseSucc == CxtPhi->getParent())

1962

1965

1966

1968

1969

1970

1972 break;

1973 }

1974 Known2 = KnownUnion;

1975 }

1976 }

1977 }

1978

1980

1981

1983 break;

1984 }

1985 }

1986 break;

1987 }

1988 case Instruction::Call:

1989 case Instruction::Invoke: {

1990

1991

1992

1996

1998

1999 if (std::optional Range = CB->getRange())

2001

2002 if (const Value *RV = CB->getReturnedArgOperand()) {

2003 if (RV->getType() == I->getType()) {

2005 Known = Known.unionWith(Known2);

2006

2007

2008

2009

2012 }

2013 }

2015 switch (II->getIntrinsicID()) {

2016 default:

2017 break;

2018 case Intrinsic::abs: {

2020 bool IntMinIsPoison = match(II->getArgOperand(1), m_One());

2021 Known = Known.unionWith(Known2.abs(IntMinIsPoison));

2022 break;

2023 }

2024 case Intrinsic::bitreverse:

2027 break;

2028 case Intrinsic::bswap:

2031 break;

2032 case Intrinsic::ctlz: {

2034

2036

2038 PossibleLZ = std::min(PossibleLZ, BitWidth - 1);

2041 break;

2042 }

2043 case Intrinsic::cttz: {

2045

2047

2049 PossibleTZ = std::min(PossibleTZ, BitWidth - 1);

2052 break;

2053 }

2054 case Intrinsic::ctpop: {

2056

2057

2061

2062

2063 break;

2064 }

2065 case Intrinsic::fshr:

2066 case Intrinsic::fshl: {

2067 const APInt *SA;

2069 break;

2070

2071

2073 if (II->getIntrinsicID() == Intrinsic::fshr)

2074 ShiftAmt = BitWidth - ShiftAmt;

2075

2079

2080 Known2 <<= ShiftAmt;

2081 Known3 >>= BitWidth - ShiftAmt;

2082 Known = Known2.unionWith(Known3);

2083 break;

2084 }

2085 case Intrinsic::uadd_sat:

2089 break;

2090 case Intrinsic::usub_sat:

2094 break;

2095 case Intrinsic::sadd_sat:

2099 break;

2100 case Intrinsic::ssub_sat:

2104 break;

2105

2106 case Intrinsic::vector_reverse:

2109 break;

2110

2111

2112 case Intrinsic::vector_reduce_and:

2113 case Intrinsic::vector_reduce_or:

2114 case Intrinsic::vector_reduce_umax:

2115 case Intrinsic::vector_reduce_umin:

2116 case Intrinsic::vector_reduce_smax:

2117 case Intrinsic::vector_reduce_smin:

2119 break;

2120 case Intrinsic::vector_reduce_xor: {

2122

2123

2124

2126

2127 bool EvenCnt = VecTy->getElementCount().isKnownEven();

2128 if (EvenCnt)

2129 Known.Zero |= Known.One;

2130

2131 if (VecTy->isScalableTy() || EvenCnt)

2133 break;

2134 }

2135 case Intrinsic::umin:

2139 break;

2140 case Intrinsic::umax:

2144 break;

2145 case Intrinsic::smin:

2150 break;

2151 case Intrinsic::smax:

2156 break;

2157 case Intrinsic::ptrmask: {

2159

2160 const Value *Mask = I->getOperand(1);

2161 Known2 = KnownBits(Mask->getType()->getScalarSizeInBits());

2163

2165 break;

2166 }

2167 case Intrinsic::x86_sse2_pmulh_w:

2168 case Intrinsic::x86_avx2_pmulh_w:

2169 case Intrinsic::x86_avx512_pmulh_w_512:

2173 break;

2174 case Intrinsic::x86_sse2_pmulhu_w:

2175 case Intrinsic::x86_avx2_pmulhu_w:

2176 case Intrinsic::x86_avx512_pmulhu_w_512:

2180 break;

2181 case Intrinsic::x86_sse42_crc32_64_64:

2183 break;

2184 case Intrinsic::x86_ssse3_phadd_d_128:

2185 case Intrinsic::x86_ssse3_phadd_w_128:

2186 case Intrinsic::x86_avx2_phadd_d:

2187 case Intrinsic::x86_avx2_phadd_w: {

2189 I, DemandedElts, Q, Depth,

2192 });

2193 break;

2194 }

2195 case Intrinsic::x86_ssse3_phadd_sw_128:

2196 case Intrinsic::x86_avx2_phadd_sw: {

2199 break;

2200 }

2201 case Intrinsic::x86_ssse3_phsub_d_128:

2202 case Intrinsic::x86_ssse3_phsub_w_128:

2203 case Intrinsic::x86_avx2_phsub_d:

2204 case Intrinsic::x86_avx2_phsub_w: {

2206 I, DemandedElts, Q, Depth,

2209 });

2210 break;

2211 }

2212 case Intrinsic::x86_ssse3_phsub_sw_128:

2213 case Intrinsic::x86_avx2_phsub_sw: {

2216 break;

2217 }

2218 case Intrinsic::riscv_vsetvli:

2219 case Intrinsic::riscv_vsetvlimax: {

2220 bool HasAVL = II->getIntrinsicID() == Intrinsic::riscv_vsetvli;

2229

2230

2231 if (HasAVL)

2233 MaxVL = std::min(MaxVL, CI->getZExtValue());

2234

2235 unsigned KnownZeroFirstBit = Log2_32(MaxVL) + 1;

2236 if (BitWidth > KnownZeroFirstBit)

2238 break;

2239 }

2240 case Intrinsic::vscale: {

2241 if (->getParent() || ->getFunction())

2242 break;

2243

2245 break;

2246 }

2247 }

2248 }

2249 break;

2250 }

2251 case Instruction::ShuffleVector: {

2254 break;

2255 }

2256

2258

2259 if (!Shuf) {

2261 return;

2262 }

2263

2264

2265 APInt DemandedLHS, DemandedRHS;

2268 return;

2269 }

2271 if (!!DemandedLHS) {

2272 const Value *LHS = Shuf->getOperand(0);

2274

2276 break;

2277 }

2278 if (!!DemandedRHS) {

2279 const Value *RHS = Shuf->getOperand(1);

2282 }

2283 break;

2284 }

2285 case Instruction::InsertElement: {

2288 return;

2289 }

2290 const Value *Vec = I->getOperand(0);

2291 const Value *Elt = I->getOperand(1);

2293 unsigned NumElts = DemandedElts.getBitWidth();

2294 APInt DemandedVecElts = DemandedElts;

2295 bool NeedsElt = true;

2296

2297 if (CIdx && CIdx->getValue().ult(NumElts)) {

2298 DemandedVecElts.clearBit(CIdx->getZExtValue());

2299 NeedsElt = DemandedElts[CIdx->getZExtValue()];

2300 }

2301

2303 if (NeedsElt) {

2305

2307 break;

2308 }

2309

2310 if (!DemandedVecElts.isZero()) {

2313 }

2314 break;

2315 }

2316 case Instruction::ExtractElement: {

2317

2318

2319 const Value *Vec = I->getOperand(0);

2320 const Value *Idx = I->getOperand(1);

2323

2325 break;

2326 }

2329 if (CIdx && CIdx->getValue().ult(NumElts))

2332 break;

2333 }

2334 case Instruction::ExtractValue:

2339 switch (II->getIntrinsicID()) {

2340 default: break;

2341 case Intrinsic::uadd_with_overflow:

2342 case Intrinsic::sadd_with_overflow:

2344 true, II->getArgOperand(0), II->getArgOperand(1), false,

2345 false, DemandedElts, Known, Known2, Q, Depth);

2346 break;

2347 case Intrinsic::usub_with_overflow:

2348 case Intrinsic::ssub_with_overflow:

2350 false, II->getArgOperand(0), II->getArgOperand(1), false,

2351 false, DemandedElts, Known, Known2, Q, Depth);

2352 break;

2353 case Intrinsic::umul_with_overflow:

2354 case Intrinsic::smul_with_overflow:

2356 false, DemandedElts, Known, Known2, Q, Depth);

2357 break;

2358 }

2359 }

2360 }

2361 break;

2362 case Instruction::Freeze:

2366 break;

2367 }

2368}

2369

2370

2371

2378

2379

2380

2382 unsigned Depth) {

2385 return Known;

2386}

2387

2388

2389

2390

2391

2392

2393

2394

2395

2396

2397

2398

2399

2400

2401

2402

2405 unsigned Depth) {

2406 if (!DemandedElts) {

2407

2409 return;

2410 }

2411

2412 assert(V && "No Value?");

2414

2415#ifndef NDEBUG

2416 Type *Ty = V->getType();

2418

2419 assert((Ty->isIntOrIntVectorTy(BitWidth) || Ty->isPtrOrPtrVectorTy()) &&

2420 "Not integer or pointer type!");

2421

2424 FVTy->getNumElements() == DemandedElts.getBitWidth() &&

2425 "DemandedElt width should equal the fixed vector number of elements");

2426 } else {

2428 "DemandedElt width should be 1 for scalars or scalable vectors");

2429 }

2430

2434 "V and Known should have same BitWidth");

2435 } else {

2437 "V and Known should have same BitWidth");

2438 }

2439#endif

2440

2443

2445 return;

2446 }

2447

2450 return;

2451 }

2452

2453

2456

2457

2459 for (unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {

2460 if (!DemandedElts[i])

2461 continue;

2462 APInt Elt = CDV->getElementAsAPInt(i);

2463 Known.Zero &= ~Elt;

2464 Known.One &= Elt;

2465 }

2468 return;

2469 }

2470

2473

2474

2476 for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {

2477 if (!DemandedElts[i])

2478 continue;

2481 continue;

2483 if (!ElementCI) {

2485 return;

2486 }

2487 const APInt &Elt = ElementCI->getValue();

2488 Known.Zero &= ~Elt;

2489 Known.One &= Elt;

2490 }

2493 return;

2494 }

2495

2496

2498

2499

2501 return;

2502

2503

2504

2506

2508 if (std::optional Range = A->getRange())

2509 Known = Range->toKnownBits();

2510

2511

2513 return;

2514

2515

2516

2518 if (!GA->isInterposable())

2520 return;

2521 }

2522

2526 if (std::optional CR = GV->getAbsoluteSymbolRange())

2527 Known = CR->toKnownBits();

2528 }

2529

2530

2532 Align Alignment = V->getPointerAlignment(Q.DL);

2534 }

2535

2536

2537

2538

2539

2541}

2542

2543

2544

2548 Value *Start = nullptr, *Step = nullptr;

2550 return false;

2551

2552

2554 if (U.get() == Start) {

2555

2556

2559 return false;

2560 }

2561 }

2562

2563

2564

2566 return false;

2567

2570 case Instruction::Mul:

2571

2575 case Instruction::SDiv:

2576

2577

2579 return false;

2580 [[fallthrough]];

2581 case Instruction::UDiv:

2582

2583

2584

2585 return (OrZero || Q.IIQ.isExact(BO)) &&

2587 case Instruction::Shl:

2589 case Instruction::AShr:

2591 return false;

2592 [[fallthrough]];

2593 case Instruction::LShr:

2595 default:

2596 return false;

2597 }

2598}

2599

2600

2601

2604 bool CondIsTrue) {

2606 const APInt *RHSC;

2609 return false;

2610 if (!CondIsTrue)

2612

2614 return true;

2615

2617}

2618

2619

2620

2621

2622

2626

2629

2630

2631 if (OrZero && V->getType()->getScalarSizeInBits() == 1)

2632 return true;

2633

2634

2635 if (Q.AC && Q.CxtI) {

2637 if (!AssumeVH)

2638 continue;

2641 true) &&

2643 return true;

2644 }

2645 }

2646

2647

2648 if (Q.DC && Q.CxtI && Q.DT) {

2650 Value *Cond = BI->getCondition();

2651

2652 BasicBlockEdge Edge0(BI->getParent(), BI->getSuccessor(0));

2654 true) &&

2656 return true;

2657

2658 BasicBlockEdge Edge1(BI->getParent(), BI->getSuccessor(1));

2660 false) &&

2662 return true;

2663 }

2664 }

2665

2667 if ()

2668 return false;

2669

2672

2673 return F->hasFnAttribute(Attribute::VScaleRange);

2674 }

2675

2676

2677

2679 return true;

2680

2681

2682

2684 return true;

2685

2686

2688 return false;

2689

2690 switch (I->getOpcode()) {

2691 case Instruction::ZExt:

2693 case Instruction::Trunc:

2695 case Instruction::Shl:

2698 return false;

2699 case Instruction::LShr:

2702 return false;

2703 case Instruction::UDiv:

2706 return false;

2707 case Instruction::Mul:

2711 case Instruction::And:

2712

2713 if (OrZero &&

2716 return true;

2717

2721 return false;

2722 case Instruction::Add: {

2723

2724

2728 if (match(I->getOperand(0),

2731 return true;

2732 if (match(I->getOperand(1),

2735 return true;

2736

2737 unsigned BitWidth = V->getType()->getScalarSizeInBits();

2740

2743

2744

2745

2746 if ((~(LHSBits.Zero & RHSBits.Zero)).isPowerOf2())

2747

2748

2750 return true;

2751 }

2752

2753

2756 return true;

2757 return false;

2758 }

2759 case Instruction::Select:

2762 case Instruction::PHI: {

2763

2764

2765

2768

2769

2771 return true;

2772

2773

2774

2777

2778 if (U.get() == PN)

2779 return true;

2780

2781

2782

2783 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();

2784 return isKnownToBeAPowerOfTwo(U.get(), OrZero, RecQ, NewDepth);

2785 });

2786 }

2787 case Instruction::Invoke:

2788 case Instruction::Call: {

2790 switch (II->getIntrinsicID()) {

2791 case Intrinsic::umax:

2792 case Intrinsic::smax:

2793 case Intrinsic::umin:

2794 case Intrinsic::smin:

2797

2798

2799 case Intrinsic::bitreverse:

2800 case Intrinsic::bswap:

2802 case Intrinsic::fshr:

2803 case Intrinsic::fshl:

2804

2805 if (II->getArgOperand(0) == II->getArgOperand(1))

2807 break;

2808 default:

2809 break;

2810 }

2811 }

2812 return false;

2813 }

2814 default:

2815 return false;

2816 }

2817}

2818

2819

2820

2821

2822

2823

2824

2826 unsigned Depth) {

2829 F = I->getFunction();

2830

2831

2832

2833 if ( GEP ->hasNoUnsignedWrap() &&

2834 !(GEP->isInBounds() &&

2836 return false;

2837

2838

2839 assert(GEP->getType()->isPointerTy() && "We only support plain pointer GEP");

2840

2841

2842

2844 return true;

2845

2846

2847

2848

2850 GTI != GTE; ++GTI) {

2851

2852 if (StructType *STy = GTI.getStructTypeOrNull()) {

2857 if (ElementOffset > 0)

2858 return true;

2859 continue;

2860 }

2861

2862

2863 if (GTI.getSequentialElementStride(Q.DL).isZero())

2864 continue;

2865

2866

2867

2869 if (!OpC->isZero())

2870 return true;

2871 continue;

2872 }

2873

2874

2875

2876

2877

2878

2880 continue;

2881

2883 return true;

2884 }

2885

2886 return false;

2887}

2888

2893

2894 if (!CtxI || !DT)

2895 return false;

2896

2897 unsigned NumUsesExplored = 0;

2898 for (auto &U : V->uses()) {

2899

2901 break;

2902 NumUsesExplored++;

2903

2905

2906

2907 if (V->getType()->isPointerTy()) {

2909 if (CB->isArgOperand(&U) &&

2910 CB->paramHasNonNullAttr(CB->getArgOperandNo(&U),

2911 false) &&

2913 return true;

2914 }

2915 }

2916

2917

2922 return true;

2923 }

2924

2928 return true;

2929

2930

2934 continue;

2935

2936 bool NonNullIfTrue;

2938 NonNullIfTrue = true;

2940 NonNullIfTrue = false;

2941 else

2942 continue;

2943

2946 for (const auto *CmpU : UI->users()) {

2947 assert(WorkList.empty() && "Should be!");

2948 if (Visited.insert(CmpU).second)

2950

2951 while (!WorkList.empty()) {

2953

2954

2955

2956

2957

2958 if (NonNullIfTrue)

2960 for (const auto *CurrU : Curr->users())

2961 if (Visited.insert(CurrU).second)

2963 continue;

2964 }

2965

2967 assert(BI->isConditional() && "uses a comparison!");

2968

2970 BI->getSuccessor(NonNullIfTrue ? 0 : 1);

2973 return true;

2974 } else if (NonNullIfTrue && isGuard(Curr) &&

2976 return true;

2977 }

2978 }

2979 }

2980 }

2981

2982 return false;

2983}

2984

2985

2986

2987

2989 const unsigned NumRanges = Ranges->getNumOperands() / 2;

2990 assert(NumRanges >= 1);

2991 for (unsigned i = 0; i < NumRanges; ++i) {

2998 return false;

2999 }

3000 return true;

3001}

3002

3003

3004

3007 Value *Start = nullptr, *Step = nullptr;

3008 const APInt *StartC, *StepC;

3011 return false;

3012

3014 case Instruction::Add:

3015

3016

3020 case Instruction::Mul:

3023 case Instruction::Shl:

3025 case Instruction::AShr:

3026 case Instruction::LShr:

3028 default:

3029 return false;

3030 }

3031}

3032

3039

3042 bool NUW, unsigned Depth) {

3043

3045 return true;

3046

3047 if (NUW)

3050

3053

3054

3055

3059 return true;

3060

3061

3062

3065

3066

3068 return true;

3069

3070

3072 return true;

3073 }

3074

3075

3078 return true;

3081 return true;

3082

3084}

3085

3088 unsigned Depth) {

3089

3090

3092 return true;

3093

3094

3097 return true;

3098

3099 return ::isKnownNonEqual(X, Y, DemandedElts, Q, Depth);

3100}

3101

3104 bool NUW, unsigned Depth) {

3105

3106

3107 if (NSW || NUW)

3110

3111

3112

3114 if (XKnown.One[0])

3116

3118 if (YKnown.One[0])

3120

3121

3122

3123

3124

3125

3128}

3129

3132 unsigned Depth) {

3133 auto ShiftOp = [&](const APInt &Lhs, const APInt &Rhs) {

3134 switch (I->getOpcode()) {

3135 case Instruction::Shl:

3136 return Lhs.shl(Rhs);

3137 case Instruction::LShr:

3138 return Lhs.lshr(Rhs);

3139 case Instruction::AShr:

3140 return Lhs.ashr(Rhs);

3141 default:

3143 }

3144 };

3145

3146 auto InvShiftOp = [&](const APInt &Lhs, const APInt &Rhs) {

3147 switch (I->getOpcode()) {

3148 case Instruction::Shl:

3149 return Lhs.lshr(Rhs);

3150 case Instruction::LShr:

3151 case Instruction::AShr:

3152 return Lhs.shl(Rhs);

3153 default:

3155 }

3156 };

3157

3159 return false;

3160

3164 unsigned NumBits = KnownVal.getBitWidth();

3165 if (MaxShift.uge(NumBits))

3166 return false;

3167

3168 if (!ShiftOp(KnownVal.One, MaxShift).isZero())

3169 return true;

3170

3171

3172

3173 if (InvShiftOp(KnownVal.Zero, NumBits - MaxShift)

3174 .eq(InvShiftOp(APInt::getAllOnes(NumBits), NumBits - MaxShift)) &&

3176 return true;

3177

3178 return false;

3179}

3180

3182 const APInt &DemandedElts,

3185 switch (I->getOpcode()) {

3186 case Instruction::Alloca:

3187

3188 return I->getType()->getPointerAddressSpace() == 0;

3189 case Instruction::GetElementPtr:

3190 if (I->getType()->isPointerTy())

3192 break;

3193 case Instruction::BitCast: {

3194

3195

3196

3197

3198

3199

3200

3201

3202

3203

3204

3205

3206

3207

3208

3209

3210

3211

3212

3213

3214

3215

3216

3217

3218

3219

3220

3221 Type *FromTy = I->getOperand(0)->getType();

3225 } break;

3226 case Instruction::IntToPtr:

3227

3228

3229

3234 break;

3235 case Instruction::PtrToInt:

3236

3237

3242 break;

3243 case Instruction::Trunc:

3244

3246 if (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap())

3248 break;

3249

3250

3251

3252 case Instruction::Xor:

3253 case Instruction::Sub:

3255 I->getOperand(1), Depth);

3256 case Instruction::Or:

3257

3259 return true;

3260

3261 if (isKnownNonEqual(I->getOperand(0), I->getOperand(1), DemandedElts, Q,

3263 return true;

3264

3267 case Instruction::SExt:

3268 case Instruction::ZExt:

3269

3271

3272 case Instruction::Shl: {

3273

3277

3278

3279

3282 if (Known.One[0])

3283 return true;

3284

3286 }

3287 case Instruction::LShr:

3288 case Instruction::AShr: {

3289

3293

3294

3295

3299 return true;

3300

3302 }

3303 case Instruction::UDiv:

3304 case Instruction::SDiv: {

3305

3306

3309

3312

3313

3315 return false;

3316

3319 if (I->getOpcode() == Instruction::SDiv) {

3320

3321 XKnown = XKnown.abs( false);

3322 YKnown = YKnown.abs( false);

3323 }

3324

3325 std::optional XUgeY = KnownBits::uge(XKnown, YKnown);

3326

3327

3328 return XUgeY && *XUgeY;

3329 }

3330 case Instruction::Add: {

3331

3332

3333

3334

3339 }

3340 case Instruction::Mul: {

3345 }

3346 case Instruction::Select: {

3347

3348

3349

3350

3351

3352

3353 auto SelectArmIsNonZero = [&](bool IsTrueArm) {

3355 Op = IsTrueArm ? I->getOperand(1) : I->getOperand(2);

3356

3358 return true;

3359

3360

3361

3365 return false;

3366

3367 if (!IsTrueArm)

3369

3371 };

3372

3373 if (SelectArmIsNonZero( true) &&

3374 SelectArmIsNonZero( false))

3375 return true;

3376 break;

3377 }

3378 case Instruction::PHI: {

3381 return true;

3382

3383

3387 if (U.get() == PN)

3388 return true;

3389 RecQ.CxtI = PN->getIncomingBlock(U)->getTerminator();

3390

3391 CmpPredicate Pred;

3392 Value *X;

3393 BasicBlock *TrueSucc, *FalseSucc;

3394 if (match(RecQ.CxtI,

3395 m_Br(m_c_ICmp(Pred, m_Specific(U.get()), m_Value(X)),

3396 m_BasicBlock(TrueSucc), m_BasicBlock(FalseSucc)))) {

3397

3398 if ((TrueSucc == PN->getParent()) != (FalseSucc == PN->getParent())) {

3399

3400 if (FalseSucc == PN->getParent())

3401 Pred = CmpInst::getInversePredicate(Pred);

3402 if (cmpExcludesZero(Pred, X))

3403 return true;

3404 }

3405 }

3406

3407 return isKnownNonZero(U.get(), DemandedElts, RecQ, NewDepth);

3408 });

3409 }

3410 case Instruction::InsertElement: {

3412 break;

3413

3414 const Value *Vec = I->getOperand(0);

3415 const Value *Elt = I->getOperand(1);

3417

3418 unsigned NumElts = DemandedElts.getBitWidth();

3419 APInt DemandedVecElts = DemandedElts;

3420 bool SkipElt = false;

3421

3422 if (CIdx && CIdx->getValue().ult(NumElts)) {

3423 DemandedVecElts.clearBit(CIdx->getZExtValue());

3424 SkipElt = !DemandedElts[CIdx->getZExtValue()];

3425 }

3426

3427

3428

3430 (DemandedVecElts.isZero() ||

3432 }

3433 case Instruction::ExtractElement:

3435 const Value *Vec = EEI->getVectorOperand();

3436 const Value *Idx = EEI->getIndexOperand();

3439 unsigned NumElts = VecTy->getNumElements();

3441 if (CIdx && CIdx->getValue().ult(NumElts))

3444 }

3445 }

3446 break;

3447 case Instruction::ShuffleVector: {

3449 if (!Shuf)

3450 break;

3451 APInt DemandedLHS, DemandedRHS;

3452

3453

3455 break;

3456

3457 return (DemandedRHS.isZero() ||

3459 (DemandedLHS.isZero() ||

3461 }

3462 case Instruction::Freeze:

3466 case Instruction::Load: {

3468

3469

3471 if (Q.IIQ.getMetadata(LI, LLVMContext::MD_nonnull) ||

3472 (Q.IIQ.getMetadata(LI, LLVMContext::MD_dereferenceable) &&

3474 return true;

3477 }

3478

3479

3480

3481 return false;

3482 }

3483 case Instruction::ExtractValue: {

3487 default:

3488 break;

3489 case Instruction::Add:

3492 false,

3493 false, Depth);

3494 case Instruction::Sub:

3497 case Instruction::Mul:

3500 false, false, Depth);

3501 break;

3502 }

3503 }

3504 break;

3505 }

3506 case Instruction::Call:

3507 case Instruction::Invoke: {

3509 if (I->getType()->isPointerTy()) {

3510 if (Call->isReturnNonNull())

3511 return true;

3514 } else {

3517 if (std::optional Range = Call->getRange()) {

3518 const APInt ZeroValue(Range->getBitWidth(), 0);

3519 if ( Range ->contains(ZeroValue))

3520 return true;

3521 }

3522 if (const Value *RV = Call->getReturnedArgOperand())

3524 return true;

3525 }

3526

3528 switch (II->getIntrinsicID()) {

3529 case Intrinsic::sshl_sat:

3530 case Intrinsic::ushl_sat:

3531 case Intrinsic::abs:

3532 case Intrinsic::bitreverse:

3533 case Intrinsic::bswap:

3534 case Intrinsic::ctpop:

3536

3537

3538 case Intrinsic::ssub_sat:

3540 II->getArgOperand(1), Depth);

3541 case Intrinsic::sadd_sat:

3543 II->getArgOperand(1),

3544 true, false, Depth);

3545

3546 case Intrinsic::vector_reverse:

3549

3550 case Intrinsic::vector_reduce_or:

3551 case Intrinsic::vector_reduce_umax:

3552 case Intrinsic::vector_reduce_umin:

3553 case Intrinsic::vector_reduce_smax:

3554 case Intrinsic::vector_reduce_smin:

3556 case Intrinsic::umax:

3557 case Intrinsic::uadd_sat:

3558

3559

3561 return true;

3562

3565 case Intrinsic::smax: {

3566

3567

3568 auto IsNonZero = [&](Value *Op, std::optional &OpNonZero,

3570 if (!OpNonZero.has_value())

3571 OpNonZero = OpKnown.isNonZero() ||

3573 return *OpNonZero;

3574 };

3575

3576 std::optional Op0NonZero, Op1NonZero;

3580 IsNonZero(II->getArgOperand(1), Op1NonZero, Op1Known))

3581 return true;

3585 IsNonZero(II->getArgOperand(0), Op0NonZero, Op0Known))

3586 return true;

3587 return IsNonZero(II->getArgOperand(1), Op1NonZero, Op1Known) &&

3588 IsNonZero(II->getArgOperand(0), Op0NonZero, Op0Known);

3589 }

3590 case Intrinsic::smin: {

3591

3592

3596 return true;

3600 return true;

3601

3603 return true;

3604 }

3605 [[fallthrough]];

3606 case Intrinsic::umin:

3609 case Intrinsic::cttz:

3611 .Zero[0];

3612 case Intrinsic::ctlz:

3614 .isNonNegative();

3615 case Intrinsic::fshr:

3616 case Intrinsic::fshl:

3617

3618 if (II->getArgOperand(0) == II->getArgOperand(1))

3620 break;

3621 case Intrinsic::vscale:

3622 return true;

3623 case Intrinsic::experimental_get_vector_length:

3625 default:

3626 break;

3627 }

3628 break;

3629 }

3630

3631 return false;

3632 }

3633 }

3634

3637 return Known.One != 0;

3638}

3639

3640

3641

3642

3643

3644

3645

3648 Type *Ty = V->getType();

3649

3650#ifndef NDEBUG

3652

3655 FVTy->getNumElements() == DemandedElts.getBitWidth() &&

3656 "DemandedElt width should equal the fixed vector number of elements");

3657 } else {

3659 "DemandedElt width should be 1 for scalars");

3660 }

3661#endif

3662

3664 if (C->isNullValue())

3665 return false;

3667

3668 return true;

3669

3670

3671

3673 for (unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {

3674 if (!DemandedElts[i])

3675 continue;

3676 Constant *Elt = C->getAggregateElement(i);

3678 return false;

3680 return false;

3681 }

3682 return true;

3683 }

3684

3685

3688

3689

3690

3691

3693 if (!GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&

3694 GV->getType()->getAddressSpace() == 0)

3695 return true;

3696 }

3697

3698

3700 return false;

3701 }

3702

3704 if (std::optional Range = A->getRange()) {

3705 const APInt ZeroValue(Range->getBitWidth(), 0);

3706 if ( Range ->contains(ZeroValue))

3707 return true;

3708 }

3709

3711 return true;

3712

3713

3715 return false;

3716

3717

3718

3720

3721

3723 if (((A->hasPassPointeeByValueCopyAttr() &&

3725 A->hasNonNullAttr()))

3726 return true;

3727 }

3728 }

3729

3732 return true;

3733

3736 return true;

3737

3740

3741 return false;

3742}

3743

3745 unsigned Depth) {

3747 APInt DemandedElts =

3749 return ::isKnownNonZero(V, DemandedElts, Q, Depth);

3750}

3751

3752

3753

3754

3755

3756

3757

3758static std::optional<std::pair<Value*, Value*>>

3762 return std::nullopt;

3763

3764 auto getOperands = [&](unsigned OpNum) -> auto {

3766 };

3767

3769 default:

3770 break;

3771 case Instruction::Or:

3774 break;

3775 [[fallthrough]];

3776 case Instruction::Xor:

3777 case Instruction::Add: {

3783 break;

3784 }

3785 case Instruction::Sub:

3790 break;

3791 case Instruction::Mul: {

3792

3793

3794

3797 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&

3798 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))

3799 break;

3800

3801

3806 break;

3807 }

3808 case Instruction::Shl: {

3809

3810

3813 if ((!OBO1->hasNoUnsignedWrap() || !OBO2->hasNoUnsignedWrap()) &&

3814 (!OBO1->hasNoSignedWrap() || !OBO2->hasNoSignedWrap()))

3815 break;

3816

3819 break;

3820 }

3821 case Instruction::AShr:

3822 case Instruction::LShr: {

3825 if (!PEO1->isExact() || !PEO2->isExact())

3826 break;

3827

3830 break;

3831 }

3832 case Instruction::SExt:

3833 case Instruction::ZExt:

3836 break;

3837 case Instruction::PHI: {

3840

3841

3842

3843

3845 Value *Start1 = nullptr, *Step1 = nullptr;

3847 Value *Start2 = nullptr, *Step2 = nullptr;

3851 break;

3852

3855 if (!Values)

3856 break;

3857

3858

3859

3860

3861

3862

3863 if (Values->first != PN1 || Values->second != PN2)

3864 break;

3865

3866 return std::make_pair(Start1, Start2);

3867 }

3868 }

3869 return std::nullopt;

3870}

3871

3872

3873

3874

3876 const APInt &DemandedElts,

3879 if (!BO)

3880 return false;

3882 default:

3883 break;

3884 case Instruction::Or:

3886 break;

3887 [[fallthrough]];

3888 case Instruction::Xor:

3889 case Instruction::Add:

3895 else

3896 return false;

3898 }

3899 return false;

3900}

3901

3902

3903

3906 unsigned Depth) {

3910 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&

3911 ->isZero() && ->isOne() &&

3913 }

3914 return false;

3915}

3916

3917

3918

3921 unsigned Depth) {

3925 (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) &&

3927 }

3928 return false;

3929}

3930

3933 unsigned Depth) {

3934

3936 return false;

3937

3939 bool UsedFullRecursion = false;

3941 if (!VisitedBBs.insert(IncomBB).second)

3942 continue;

3945 const APInt *C1, *C2;

3947 continue;

3948

3949

3950 if (UsedFullRecursion)

3951 return false;

3952

3954 RecQ.CxtI = IncomBB->getTerminator();

3956 return false;

3957 UsedFullRecursion = true;

3958 }

3959 return true;

3960}

3961

3964 unsigned Depth) {

3966 if (!SI1)

3967 return false;

3968

3971 const Value *Cond2 = SI2->getCondition();

3972 if (Cond1 == Cond2)

3974 DemandedElts, Q, Depth + 1) &&

3976 DemandedElts, Q, Depth + 1);

3977 }

3980}

3981

3982

3983

3984

3985

3986

3989 if (->getType()->isPointerTy() || ->getType()->isPointerTy())

3990 return false;

3991

3993 if (!GEPA || GEPA->getNumIndices() != 1 || isa<Constant> (GEPA->idx_begin()))

3994 return false;

3995

3996

3998 if (!PN || PN->getNumIncomingValues() != 2)

3999 return false;

4000

4001

4002

4003 Value *Start = nullptr;

4005 if (PN->getIncomingValue(0) == Step)

4006 Start = PN->getIncomingValue(1);

4007 else if (PN->getIncomingValue(1) == Step)

4008 Start = PN->getIncomingValue(0);

4009 else

4010 return false;

4011

4012

4013

4014

4015

4016

4017

4019 APInt StartOffset(IndexWidth, 0);

4020 Start = Start->stripAndAccumulateInBoundsConstantOffsets(Q.DL, StartOffset);

4021 APInt StepOffset(IndexWidth, 0);

4023

4024

4025 if (Step != PN)

4026 return false;

4027 APInt OffsetB(IndexWidth, 0);

4028 B = B->stripAndAccumulateInBoundsConstantOffsets(Q.DL, OffsetB);

4029 return Start == B &&

4031 (StartOffset.sle(OffsetB) && StepOffset.isNegative()));

4032}

4033

4036 if (!Q.CxtI)

4037 return false;

4038

4039

4040 if (Q.DC && Q.DT) {

4041 auto IsKnownNonEqualFromDominatingCondition = [&](const Value *V) {

4043 Value *Cond = BI->getCondition();

4044 BasicBlockEdge Edge0(BI->getParent(), BI->getSuccessor(0));

4047 true, Depth)

4048 .value_or(false))

4049 return true;

4050

4051 BasicBlockEdge Edge1(BI->getParent(), BI->getSuccessor(1));

4054 false, Depth)

4055 .value_or(false))

4056 return true;

4057 }

4058

4059 return false;

4060 };

4061

4062 if (IsKnownNonEqualFromDominatingCondition(V1) ||

4063 IsKnownNonEqualFromDominatingCondition(V2))

4064 return true;

4065 }

4066

4067 if (!Q.AC)

4068 return false;

4069

4070

4072 if (!AssumeVH)

4073 continue;

4075

4077 "Got assumption for the wrong function!");

4078 assert(I->getIntrinsicID() == Intrinsic::assume &&

4079 "must be an assume intrinsic");

4080

4082 true, Depth)

4083 .value_or(false) &&

4085 return true;

4086 }

4087

4088 return false;

4089}

4090

4091

4094 unsigned Depth) {

4095 if (V1 == V2)

4096 return false;

4098

4099 return false;

4100

4102 return false;

4103

4104

4105

4106

4109 if (O1 && O2 && O1->getOpcode() == O2->getOpcode()) {

4111 return isKnownNonEqual(Values->first, Values->second, DemandedElts, Q,

4113

4116

4117

4119 return true;

4120 };

4121 }

4122

4125 return true;

4126

4129 return true;

4130

4133 return true;

4134

4136

4137

4143 return true;

4144 }

4145 }

4146

4149 return true;

4150

4153 return true;

4154

4156

4157

4161

4163 return true;

4164

4165 return false;

4166}

4167

4168

4169

4170

4171

4173 const APInt &DemandedElts,

4174 unsigned TyBits) {

4177 return 0;

4178

4179 unsigned MinSignBits = TyBits;

4181 for (unsigned i = 0; i != NumElts; ++i) {

4182 if (!DemandedElts[i])

4183 continue;

4184

4186 if (!Elt)

4187 return 0;

4188

4189 MinSignBits = std::min(MinSignBits, Elt->getValue().getNumSignBits());

4190 }

4191

4192 return MinSignBits;

4193}

4194

4196 const APInt &DemandedElts,

4198

4202 assert(Result > 0 && "At least one sign bit needs to be present!");

4203 return Result;

4204}

4205

4206

4207

4208

4209

4210

4211

4212

4214 const APInt &DemandedElts,

4216 Type *Ty = V->getType();

4217#ifndef NDEBUG

4219

4222 FVTy->getNumElements() == DemandedElts.getBitWidth() &&

4223 "DemandedElt width should equal the fixed vector number of elements");

4224 } else {

4226 "DemandedElt width should be 1 for scalars");

4227 }

4228#endif

4229

4230

4231

4232

4233

4235 unsigned TyBits = ScalarTy->isPointerTy() ?

4238

4239 unsigned Tmp, Tmp2;

4240 unsigned FirstAnswer = 1;

4241

4242

4243

4244

4246 return 1;

4247

4250 default: break;

4251 case Instruction::BitCast: {

4252 Value *Src = U->getOperand(0);

4253 Type *SrcTy = Src->getType();

4254

4255

4256

4257 if (!SrcTy->isIntOrIntVectorTy())

4258 break;

4259

4261

4262

4263 if ((SrcBits % TyBits) != 0)

4264 break;

4265

4266

4268

4269

4271 if (Tmp == SrcBits)

4272 return TyBits;

4273 }

4274 break;

4275 }

4276 case Instruction::SExt:

4277 Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();

4279 Tmp;

4280

4281 case Instruction::SDiv: {

4282 const APInt *Denominator;

4283

4284 if (match(U->getOperand(1), m_APInt(Denominator))) {

4285

4286

4288 break;

4289

4290

4291 unsigned NumBits =

4293

4294

4295 return std::min(TyBits, NumBits + Denominator->logBase2());

4296 }

4297 break;

4298 }

4299

4300 case Instruction::SRem: {

4302

4303 const APInt *Denominator;

4304

4305

4306

4307 if (match(U->getOperand(1), m_APInt(Denominator))) {

4308

4309

4311

4312

4313

4314

4315

4316

4317

4318

4319

4320

4321

4322

4323

4324 unsigned ResBits = TyBits - Denominator->ceilLogBase2();

4325 Tmp = std::max(Tmp, ResBits);

4326 }

4327 }

4328 return Tmp;

4329 }

4330

4331 case Instruction::AShr: {

4333

4334 const APInt *ShAmt;

4335 if (match(U->getOperand(1), m_APInt(ShAmt))) {

4336 if (ShAmt->uge(TyBits))

4337 break;

4338 unsigned ShAmtLimited = ShAmt->getZExtValue();

4339 Tmp += ShAmtLimited;

4340 if (Tmp > TyBits) Tmp = TyBits;

4341 }

4342 return Tmp;

4343 }

4344 case Instruction::Shl: {

4345 const APInt *ShAmt;

4347 if (match(U->getOperand(1), m_APInt(ShAmt))) {

4348

4349 if (ShAmt->uge(TyBits))

4350 break;

4351

4352

4354 ShAmt->uge(TyBits - X->getType()->getScalarSizeInBits())) {

4356 Tmp += TyBits - X->getType()->getScalarSizeInBits();

4357 } else

4358 Tmp =

4360 if (ShAmt->uge(Tmp))

4361 break;

4363 return Tmp - Tmp2;

4364 }

4365 break;

4366 }

4367 case Instruction::And:

4368 case Instruction::Or:

4369 case Instruction::Xor:

4370

4372 if (Tmp != 1) {

4374 FirstAnswer = std::min(Tmp, Tmp2);

4375

4376

4377

4378 }

4379 break;

4380

4381 case Instruction::Select: {

4382

4383

4385 const APInt *CLow, *CHigh;

4388

4390 if (Tmp == 1)

4391 break;

4393 return std::min(Tmp, Tmp2);

4394 }

4395

4396 case Instruction::Add:

4397

4398

4400 if (Tmp == 1) break;

4401

4402

4404 if (CRHS->isAllOnesValue()) {

4407

4408

4409

4410 if ((Known.Zero | 1).isAllOnes())

4411 return TyBits;

4412

4413

4414

4416 return Tmp;

4417 }

4418

4420 if (Tmp2 == 1)

4421 break;

4422 return std::min(Tmp, Tmp2) - 1;

4423

4424 case Instruction::Sub:

4426 if (Tmp2 == 1)

4427 break;

4428

4429

4431 if (CLHS->isNullValue()) {

4434

4435

4436 if ((Known.Zero | 1).isAllOnes())

4437 return TyBits;

4438

4439

4440

4441

4443 return Tmp2;

4444

4445

4446 }

4447

4448

4449

4451 if (Tmp == 1)

4452 break;

4453 return std::min(Tmp, Tmp2) - 1;

4454

4455 case Instruction::Mul: {

4456

4457

4458 unsigned SignBitsOp0 =

4460 if (SignBitsOp0 == 1)

4461 break;

4462 unsigned SignBitsOp1 =

4464 if (SignBitsOp1 == 1)

4465 break;

4466 unsigned OutValidBits =

4467 (TyBits - SignBitsOp0 + 1) + (TyBits - SignBitsOp1 + 1);

4468 return OutValidBits > TyBits ? 1 : TyBits - OutValidBits + 1;

4469 }

4470

4471 case Instruction::PHI: {

4474

4475 if (NumIncomingValues > 4) break;

4476

4477 if (NumIncomingValues == 0) break;

4478

4479

4480

4482 Tmp = TyBits;

4483 for (unsigned i = 0, e = NumIncomingValues; i != e; ++i) {

4484 if (Tmp == 1) return Tmp;

4487 DemandedElts, RecQ, Depth + 1));

4488 }

4489 return Tmp;

4490 }

4491

4492 case Instruction::Trunc: {

4493

4494

4495

4497 unsigned OperandTyBits = U->getOperand(0)->getType()->getScalarSizeInBits();

4498 if (Tmp > (OperandTyBits - TyBits))

4499 return Tmp - (OperandTyBits - TyBits);

4500

4501 return 1;

4502 }

4503

4504 case Instruction::ExtractElement:

4505

4506

4507

4508

4510

4511 case Instruction::ShuffleVector: {

4512

4513

4515 if (!Shuf) {

4516

4517 return 1;

4518 }

4519 APInt DemandedLHS, DemandedRHS;

4520

4521

4523 return 1;

4524 Tmp = std::numeric_limits::max();

4525 if (!!DemandedLHS) {

4526 const Value *LHS = Shuf->getOperand(0);

4528 }

4529

4530

4531 if (Tmp == 1)

4532 break;

4533 if (!!DemandedRHS) {

4534 const Value *RHS = Shuf->getOperand(1);

4536 Tmp = std::min(Tmp, Tmp2);

4537 }

4538

4539

4540 if (Tmp == 1)

4541 break;

4542 assert(Tmp <= TyBits && "Failed to determine minimum sign bits");

4543 return Tmp;

4544 }

4545 case Instruction::Call: {

4547 switch (II->getIntrinsicID()) {

4548 default:

4549 break;

4550 case Intrinsic::abs:

4551 Tmp =

4553 if (Tmp == 1)

4554 break;

4555

4556

4557 return Tmp - 1;

4558 case Intrinsic::smin:

4559 case Intrinsic::smax: {

4560 const APInt *CLow, *CHigh;

4563 }

4564 }

4565 }

4566 }

4567 }

4568 }

4569

4570

4571

4572

4573

4574

4575 if (unsigned VecSignBits =

4577 return VecSignBits;

4578

4581

4582

4583

4585}

4586

4590 if ()

4592

4593 if (F->isIntrinsic())

4594 return F->getIntrinsicID();

4595

4596

4597

4598

4599 LibFunc Func;

4600 if (F->hasLocalLinkage() || !TLI || !TLI->getLibFunc(CB, Func) ||

4603

4604 switch (Func) {

4605 default:

4606 break;

4607 case LibFunc_sin:

4608 case LibFunc_sinf:

4609 case LibFunc_sinl:

4610 return Intrinsic::sin;

4611 case LibFunc_cos:

4612 case LibFunc_cosf:

4613 case LibFunc_cosl:

4614 return Intrinsic::cos;

4615 case LibFunc_tan:

4616 case LibFunc_tanf:

4617 case LibFunc_tanl:

4618 return Intrinsic::tan;

4619 case LibFunc_asin:

4620 case LibFunc_asinf:

4621 case LibFunc_asinl:

4622 return Intrinsic::asin;

4623 case LibFunc_acos:

4624 case LibFunc_acosf:

4625 case LibFunc_acosl:

4626 return Intrinsic::acos;

4627 case LibFunc_atan:

4628 case LibFunc_atanf:

4629 case LibFunc_atanl:

4630 return Intrinsic::atan;

4631 case LibFunc_atan2:

4632 case LibFunc_atan2f:

4633 case LibFunc_atan2l:

4634 return Intrinsic::atan2;

4635 case LibFunc_sinh:

4636 case LibFunc_sinhf:

4637 case LibFunc_sinhl:

4638 return Intrinsic::sinh;

4639 case LibFunc_cosh:

4640 case LibFunc_coshf:

4641 case LibFunc_coshl:

4642 return Intrinsic::cosh;

4643 case LibFunc_tanh:

4644 case LibFunc_tanhf:

4645 case LibFunc_tanhl:

4646 return Intrinsic::tanh;

4647 case LibFunc_exp:

4648 case LibFunc_expf:

4649 case LibFunc_expl:

4650 return Intrinsic::exp;

4651 case LibFunc_exp2:

4652 case LibFunc_exp2f:

4653 case LibFunc_exp2l:

4654 return Intrinsic::exp2;

4655 case LibFunc_exp10:

4656 case LibFunc_exp10f:

4657 case LibFunc_exp10l:

4658 return Intrinsic::exp10;

4659 case LibFunc_log:

4660 case LibFunc_logf:

4661 case LibFunc_logl:

4662 return Intrinsic::log;

4663 case LibFunc_log10:

4664 case LibFunc_log10f:

4665 case LibFunc_log10l:

4666 return Intrinsic::log10;

4667 case LibFunc_log2:

4668 case LibFunc_log2f:

4669 case LibFunc_log2l:

4670 return Intrinsic::log2;

4671 case LibFunc_fabs:

4672 case LibFunc_fabsf:

4673 case LibFunc_fabsl:

4674 return Intrinsic::fabs;

4675 case LibFunc_fmin:

4676 case LibFunc_fminf:

4677 case LibFunc_fminl:

4678 return Intrinsic::minnum;

4679 case LibFunc_fmax:

4680 case LibFunc_fmaxf:

4681 case LibFunc_fmaxl:

4682 return Intrinsic::maxnum;

4683 case LibFunc_copysign:

4684 case LibFunc_copysignf:

4685 case LibFunc_copysignl:

4686 return Intrinsic::copysign;

4687 case LibFunc_floor:

4688 case LibFunc_floorf:

4689 case LibFunc_floorl:

4690 return Intrinsic::floor;

4691 case LibFunc_ceil:

4692 case LibFunc_ceilf:

4693 case LibFunc_ceill:

4694 return Intrinsic::ceil;

4695 case LibFunc_trunc:

4696 case LibFunc_truncf:

4697 case LibFunc_truncl:

4698 return Intrinsic::trunc;

4699 case LibFunc_rint:

4700 case LibFunc_rintf:

4701 case LibFunc_rintl:

4702 return Intrinsic::rint;

4703 case LibFunc_nearbyint:

4704 case LibFunc_nearbyintf:

4705 case LibFunc_nearbyintl:

4706 return Intrinsic::nearbyint;

4707 case LibFunc_round:

4708 case LibFunc_roundf:

4709 case LibFunc_roundl:

4710 return Intrinsic::round;

4711 case LibFunc_roundeven:

4712 case LibFunc_roundevenf:

4713 case LibFunc_roundevenl:

4714 return Intrinsic::roundeven;

4715 case LibFunc_pow:

4716 case LibFunc_powf:

4717 case LibFunc_powl:

4718 return Intrinsic::pow;

4719 case LibFunc_sqrt:

4720 case LibFunc_sqrtf:

4721 case LibFunc_sqrtl:

4722 return Intrinsic::sqrt;

4723 }

4724

4726}

4727

4729 Ty = Ty->getScalarType();

4733}

4734

4735

4736

4738 bool &TrueIfSigned) {

4739 switch (Pred) {

4741 TrueIfSigned = true;

4742 return RHS.isZero();

4744 TrueIfSigned = true;

4745 return RHS.isAllOnes();

4747 TrueIfSigned = false;

4748 return RHS.isAllOnes();

4750 TrueIfSigned = false;

4751 return RHS.isZero();

4753

4754 TrueIfSigned = true;

4755 return RHS.isMaxSignedValue();

4757

4758 TrueIfSigned = true;

4759 return RHS.isMinSignedValue();

4761

4762 TrueIfSigned = false;

4763 return RHS.isMinSignedValue();

4765

4766 TrueIfSigned = false;

4767 return RHS.isMaxSignedValue();

4768 default:

4769 return false;

4770 }

4771}

4772

4774 bool CondIsTrue,

4777 unsigned Depth = 0) {

4786 return;

4787 }

4791 return;

4792 }

4800 Pred, *CxtI->getParent()->getParent(), LHS, *CRHS, LHS != V);

4801 if (CmpVal == V)

4802 KnownFromContext.knownNot(~(CondIsTrue ? MaskIfTrue : MaskIfFalse));

4806 KnownFromContext.knownNot(CondIsTrue ? ~Mask : Mask);

4809 bool TrueIfSigned;

4811 return;

4812 if (TrueIfSigned == CondIsTrue)

4814 else

4816 }

4817}

4818

4822

4825 KnownFromContext);

4826

4827 if (!Q.CxtI)

4828 return KnownFromContext;

4829

4830 if (Q.DC && Q.DT) {

4831

4833 Value *Cond = BI->getCondition();

4834

4835 BasicBlockEdge Edge0(BI->getParent(), BI->getSuccessor(0));

4838 KnownFromContext);

4839

4840 BasicBlockEdge Edge1(BI->getParent(), BI->getSuccessor(1));

4843 KnownFromContext);

4844 }

4845 }

4846

4847 if (!Q.AC)

4848 return KnownFromContext;

4849

4850

4851

4853 if (!AssumeVH)

4854 continue;

4856

4858 "Got assumption for the wrong function!");

4859 assert(I->getIntrinsicID() == Intrinsic::assume &&

4860 "must be an assume intrinsic");

4861

4863 continue;

4864

4866 true, Q.CxtI, KnownFromContext);

4867 }

4868

4869 return KnownFromContext;

4870}

4871

4875

4880 APInt DemandedElts =

4883}

4884

4886 const APInt &DemandedElts,

4890 unsigned Depth) {

4891 if ((InterestedClasses &

4893 return;

4894

4897 KnownSrc, Q, Depth + 1);

4898

4899

4900

4903

4905

4906

4907}

4908

4912 assert(Known.isUnknown() && "should not be called with known information");

4913

4914 if (!DemandedElts) {

4915

4917 return;

4918 }

4919

4921

4923 Known.KnownFPClasses = CFP->getValueAPF().classify();

4924 Known.SignBit = CFP->isNegative();

4925 return;

4926 }

4927

4931 return;

4932 }

4933

4937 return;

4938 }

4939

4940

4943 if (VFVTy && CV) {

4945 bool SignBitAllZero = true;

4946 bool SignBitAllOne = true;

4947

4948

4949 unsigned NumElts = VFVTy->getNumElements();

4950 for (unsigned i = 0; i != NumElts; ++i) {

4951 if (!DemandedElts[i])

4952 continue;

4953

4955 if (!Elt) {

4957 return;

4958 }

4960 continue;

4962 if (!CElt) {

4964 return;

4965 }

4966

4967 const APFloat &C = CElt->getValueAPF();

4969 if (C.isNegative())

4970 SignBitAllZero = false;

4971 else

4972 SignBitAllOne = false;

4973 }

4974 if (SignBitAllOne != SignBitAllZero)

4975 Known.SignBit = SignBitAllOne;

4976 return;

4977 }

4978

4981 KnownNotFromFlags |= CB->getRetNoFPClass();

4983 KnownNotFromFlags |= Arg->getNoFPClass();

4984

4987 if (FPOp->hasNoNaNs())

4988 KnownNotFromFlags |= fcNan;

4989 if (FPOp->hasNoInfs())

4990 KnownNotFromFlags |= fcInf;

4991 }

4992

4994 KnownNotFromFlags |= ~AssumedClasses.KnownFPClasses;

4995

4996

4997

4998 InterestedClasses &= ~KnownNotFromFlags;

4999

5000 auto ClearClassesFromFlags = make_scope_exit([=, &Known] {

5001 Known.knownNot(KnownNotFromFlags);

5003 if (*AssumedClasses.SignBit)

5005 else

5007 }

5008 });

5009

5010 if ()

5011 return;

5012

5013

5015 return;

5016

5017 const unsigned Opc = Op->getOpcode();

5018 switch (Opc) {

5019 case Instruction::FNeg: {

5021 Known, Q, Depth + 1);

5022 Known.fneg();

5023 break;

5024 }

5025 case Instruction::Select: {

5029

5032

5033 Value *TestedValue = nullptr;

5039 Value *CmpLHS, *CmpRHS;

5041

5042

5043

5044

5045

5046 bool LookThroughFAbsFNeg = CmpLHS != LHS && CmpLHS != RHS;

5047 std::tie(TestedValue, MaskIfTrue, MaskIfFalse) =

5048 fcmpImpliesClass(Pred, *F, CmpLHS, CmpRHS, LookThroughFAbsFNeg);

5053 MaskIfTrue = TestedMask;

5054 MaskIfFalse = ~TestedMask;

5055 }

5056

5057 if (TestedValue == LHS) {

5058

5059 FilterLHS = MaskIfTrue;

5060 } else if (TestedValue == RHS) {

5061

5062 FilterRHS = MaskIfFalse;

5063 }

5064

5069

5071 Known2, Q, Depth + 1);

5073

5074 Known |= Known2;

5075 break;

5076 }

5077 case Instruction::Call: {

5080 switch (IID) {

5081 case Intrinsic::fabs: {

5083

5084

5086 InterestedClasses, Known, Q, Depth + 1);

5087 }

5088

5089 Known.fabs();

5090 break;

5091 }

5092 case Intrinsic::copysign: {

5094

5096 Known, Q, Depth + 1);

5098 KnownSign, Q, Depth + 1);

5100 break;

5101 }

5102 case Intrinsic::fma:

5103 case Intrinsic::fmuladd: {

5105 break;

5106

5107 if (II->getArgOperand(0) != II->getArgOperand(1))

5108 break;

5109

5110

5112

5113

5116 KnownAddend, Q, Depth + 1);

5117

5120 break;

5121 }

5122 case Intrinsic::sqrt:

5123 case Intrinsic::experimental_constrained_sqrt: {

5125 FPClassTest InterestedSrcs = InterestedClasses;

5126 if (InterestedClasses & fcNan)

5128

5130 KnownSrc, Q, Depth + 1);

5131

5136

5137

5140

5141

5143

5144

5145

5148 II->getType()->getScalarType()->getFltSemantics();

5149

5151 (F &&

5154

5155 break;

5156 }

5157 case Intrinsic::sin:

5158 case Intrinsic::cos: {

5159

5162 KnownSrc, Q, Depth + 1);

5166 break;

5167 }

5168 case Intrinsic::maxnum:

5169 case Intrinsic::minnum:

5170 case Intrinsic::minimum:

5171 case Intrinsic::maximum:

5172 case Intrinsic::minimumnum:

5173 case Intrinsic::maximumnum: {

5176 KnownLHS, Q, Depth + 1);

5178 KnownRHS, Q, Depth + 1);

5179

5181 Known = KnownLHS | KnownRHS;

5182

5183

5184 if (NeverNaN &&

5185 (IID == Intrinsic::minnum || IID == Intrinsic::maxnum ||

5186 IID == Intrinsic::minimumnum || IID == Intrinsic::maximumnum))

5188

5189 if (IID == Intrinsic::maxnum || IID == Intrinsic::maximumnum) {

5190

5191

5197 } else if (IID == Intrinsic::maximum) {

5198

5199

5203 } else if (IID == Intrinsic::minnum || IID == Intrinsic::minimumnum) {

5204

5205

5211 } else if (IID == Intrinsic::minimum) {

5212

5213

5217 } else

5219

5220

5221

5222

5223

5224

5225

5226

5229 const Function *Parent = II->getFunction();

5230 if (!Parent)

5231 break;

5232

5234 II->getType()->getScalarType()->getFltSemantics());

5237 }

5238

5244 else

5246 } else if ((IID == Intrinsic::maximum || IID == Intrinsic::minimum ||

5247 IID == Intrinsic::maximumnum ||

5248 IID == Intrinsic::minimumnum) ||

5249

5254

5256 KnownLHS.SignBit = std::nullopt;

5258 KnownRHS.SignBit = std::nullopt;

5259 if ((IID == Intrinsic::maximum || IID == Intrinsic::maximumnum ||

5260 IID == Intrinsic::maxnum) &&

5261 (KnownLHS.SignBit == false || KnownRHS.SignBit == false))

5263 else if ((IID == Intrinsic::minimum || IID == Intrinsic::minimumnum ||

5264 IID == Intrinsic::minnum) &&

5265 (KnownLHS.SignBit == true || KnownRHS.SignBit == true))

5267 }

5268 }

5269 break;

5270 }

5271 case Intrinsic::canonicalize: {

5274 KnownSrc, Q, Depth + 1);

5275

5276

5277

5278

5279

5280

5281

5283

5284

5285

5288 else

5290

5292 if ()

5293 break;

5294

5295

5296

5298 II->getType()->getScalarType()->getFltSemantics();

5299 DenormalMode DenormMode = F->getDenormalMode(FPType);

5305 break;

5306 }

5307

5310

5315

5316 break;

5317 }

5318 case Intrinsic::vector_reduce_fmax:

5319 case Intrinsic::vector_reduce_fmin:

5320 case Intrinsic::vector_reduce_fmaximum:

5321 case Intrinsic::vector_reduce_fminimum: {

5322

5323

5325 InterestedClasses, Q, Depth + 1);

5326

5329 break;

5330 }

5331

5332 case Intrinsic::vector_reverse:

5334 II->getArgOperand(0), DemandedElts.reverseBits(),

5335 II->getFastMathFlags(), InterestedClasses, Q, Depth + 1);

5336 break;

5337 case Intrinsic::trunc:

5338 case Intrinsic:🤣

5339 case Intrinsic::ceil:

5340 case Intrinsic::rint:

5341 case Intrinsic::nearbyint:

5342 case Intrinsic::round:

5343 case Intrinsic::roundeven: {

5345 FPClassTest InterestedSrcs = InterestedClasses;

5351 KnownSrc, Q, Depth + 1);

5352

5353

5355

5357

5358

5359

5360 if (IID == Intrinsic::trunc || !V->getType()->isMultiUnitFPType()) {

5365 }

5366

5367

5372

5373 break;

5374 }

5375 case Intrinsic::exp:

5376 case Intrinsic::exp2:

5377 case Intrinsic::exp10: {

5379 if ((InterestedClasses & fcNan) == fcNone)

5380 break;

5381

5384 KnownSrc, Q, Depth + 1);

5388 }

5389

5390 break;

5391 }

5392 case Intrinsic::fptrunc_round: {

5395 break;

5396 }

5397 case Intrinsic:🪵

5398 case Intrinsic::log10:

5399 case Intrinsic::log2:

5400 case Intrinsic::experimental_constrained_log:

5401 case Intrinsic::experimental_constrained_log10:

5402 case Intrinsic::experimental_constrained_log2: {

5403

5404

5405

5406

5408 break;

5409

5410 FPClassTest InterestedSrcs = InterestedClasses;

5413 if ((InterestedClasses & fcNan) != fcNone)

5415

5418 KnownSrc, Q, Depth + 1);

5419

5422

5425

5427

5428 if ()

5429 break;

5430

5432 II->getType()->getScalarType()->getFltSemantics();

5434

5437

5438 break;

5439 }

5440 case Intrinsic::powi: {

5442 break;

5443

5444 const Value *Exp = II->getArgOperand(1);

5445 Type *ExpTy = Exp->getType();

5449 ExponentKnownBits, Q, Depth + 1);

5450

5451 if (ExponentKnownBits.Zero[0]) {

5453 break;

5454 }

5455

5456

5457

5458

5459

5460

5461

5462

5463

5466 KnownSrc, Q, Depth + 1);

5469 break;

5470 }

5471 case Intrinsic::ldexp: {

5474 KnownSrc, Q, Depth + 1);

5475 Known.propagateNaN(KnownSrc, true);

5476

5477

5482

5487

5488

5490 if ((InterestedClasses & ExpInfoMask) == fcNone)

5491 break;

5493 break;

5494

5496 II->getType()->getScalarType()->getFltSemantics();

5498 const Value *ExpArg = II->getArgOperand(1);

5501

5502 const int MantissaBits = Precision - 1;

5503 if (ExpRange.getSignedMin().sge(static_cast<int64_t>(MantissaBits)))

5505

5509 II->getType()->getScalarType()->getFltSemantics();

5510 if (ConstVal && ConstVal->isZero()) {

5511

5514

5520

5525 if (F &&

5528 if (F &&

5531 }

5532

5533 break;

5534 }

5535 case Intrinsic::arithmetic_fence: {

5537 Known, Q, Depth + 1);

5538 break;

5539 }

5540 case Intrinsic::experimental_constrained_sitofp:

5541 case Intrinsic::experimental_constrained_uitofp:

5542

5544

5545

5547

5548

5550

5551 if (IID == Intrinsic::experimental_constrained_uitofp)

5553

5554

5555 break;

5556 default:

5557 break;

5558 }

5559

5560 break;

5561 }

5562 case Instruction::FAdd:

5563 case Instruction::FSub: {

5565 bool WantNegative =

5566 Op->getOpcode() == Instruction::FAdd &&

5568 bool WantNaN = (InterestedClasses & fcNan) != fcNone;

5569 bool WantNegZero = (InterestedClasses & fcNegZero) != fcNone;

5570

5571 if (!WantNaN && !WantNegative && !WantNegZero)

5572 break;

5573

5574 FPClassTest InterestedSrcs = InterestedClasses;

5575 if (WantNegative)

5577 if (InterestedClasses & fcNan)

5578 InterestedSrcs |= fcInf;

5580 KnownRHS, Q, Depth + 1);

5581

5584 WantNegZero || Opc == Instruction::FSub) {

5585

5586

5587

5589 KnownLHS, Q, Depth + 1);

5590

5591

5595

5596

5598

5599 if (Op->getOpcode() == Instruction::FAdd) {

5603 if ()

5604 break;

5605

5607 Op->getType()->getScalarType()->getFltSemantics();

5609

5610

5613

5616 } else {

5617 if ()

5618 break;

5619

5621 Op->getType()->getScalarType()->getFltSemantics();

5623

5624

5627

5630 }

5631 }

5632

5633 break;

5634 }

5635 case Instruction::FMul: {

5636

5637 if (Op->getOperand(0) == Op->getOperand(1))

5639

5640 if ((InterestedClasses & fcNan) != fcNan)

5641 break;

5642

5643

5645

5650 break;

5651

5655 break;

5656

5660 else

5662 }

5663

5664

5667 break;

5668 }

5669

5671 if ()

5672 break;

5673

5674 Type *OpTy = Op->getType()->getScalarType();

5677

5683

5684 break;

5685 }

5686 case Instruction::FDiv:

5687 case Instruction::FRem: {

5688 if (Op->getOperand(0) == Op->getOperand(1)) {

5689

5690 if (Op->getOpcode() == Instruction::FDiv) {

5691

5693 } else {

5694

5696 }

5697

5698 break;

5699 }

5700

5701 const bool WantNan = (InterestedClasses & fcNan) != fcNone;

5702 const bool WantNegative = (InterestedClasses & fcNegative) != fcNone;

5703 const bool WantPositive =

5705 if (!WantNan && !WantNegative && !WantPositive)

5706 break;

5707

5709

5713

5714 bool KnowSomethingUseful =

5716

5717 if (KnowSomethingUseful || WantPositive) {

5721

5723 InterestedClasses & InterestedLHS, KnownLHS, Q,

5725 }

5726

5729 Op->getType()->getScalarType()->getFltSemantics();

5730

5731 if (Op->getOpcode() == Instruction::FDiv) {

5732

5736 ((F &&

5738 (F &&

5741 }

5742

5743

5744

5747 } else {

5748

5753 }

5754

5755

5760

5761

5766 }

5767

5768 break;

5769 }

5770 case Instruction::FPExt: {

5771

5773 Known, Q, Depth + 1);

5774

5776 Op->getType()->getScalarType()->getFltSemantics();

5778 Op->getOperand(0)->getType()->getScalarType()->getFltSemantics();

5779

5780

5787 }

5788

5789

5791 Known.SignBit = std::nullopt;

5792 break;

5793 }

5794 case Instruction::FPTrunc: {

5797 break;

5798 }

5799 case Instruction::SIToFP:

5800 case Instruction::UIToFP: {

5801

5803

5804

5806

5807

5809 if (Op->getOpcode() == Instruction::UIToFP)

5811

5812 if (InterestedClasses & fcInf) {

5813

5814

5815

5816 int IntSize = Op->getOperand(0)->getType()->getScalarSizeInBits();

5817 if (Op->getOpcode() == Instruction::SIToFP)

5818 --IntSize;

5819

5820

5821

5822 Type *FPTy = Op->getType()->getScalarType();

5825 }

5826

5827 break;

5828 }

5829 case Instruction::ExtractElement: {

5830

5831

5832 const Value *Vec = Op->getOperand(0);

5833

5834 APInt DemandedVecElts;

5836 unsigned NumElts = VecTy->getNumElements();

5839 if (CIdx && CIdx->getValue().ult(NumElts))

5841 } else {

5842 DemandedVecElts = APInt(1, 1);

5843 }

5844

5845 return computeKnownFPClass(Vec, DemandedVecElts, InterestedClasses, Known,

5847 }

5848 case Instruction::InsertElement: {

5850 return;

5851

5852 const Value *Vec = Op->getOperand(0);

5853 const Value *Elt = Op->getOperand(1);

5855 unsigned NumElts = DemandedElts.getBitWidth();

5856 APInt DemandedVecElts = DemandedElts;

5857 bool NeedsElt = true;

5858

5859 if (CIdx && CIdx->getValue().ult(NumElts)) {

5860 DemandedVecElts.clearBit(CIdx->getZExtValue());

5861 NeedsElt = DemandedElts[CIdx->getZExtValue()];

5862 }

5863

5864

5865 if (NeedsElt) {

5867

5869 break;

5870 } else {

5872 }

5873

5874

5875 if (!DemandedVecElts.isZero()) {

5879 Known |= Known2;

5880 }

5881

5882 break;

5883 }

5884 case Instruction::ShuffleVector: {

5885

5888 break;

5889 }

5890

5891

5892

5893 APInt DemandedLHS, DemandedRHS;

5896 return;

5897

5898 if (!!DemandedLHS) {

5899 const Value *LHS = Shuf->getOperand(0);

5902

5903

5905 break;

5906 } else {

5908 }

5909

5910 if (!!DemandedRHS) {

5912 const Value *RHS = Shuf->getOperand(1);

5915 Known |= Known2;

5916 }

5917

5918 break;

5919 }

5920 case Instruction::ExtractValue: {

5925 Indices[0] == 0) {

5927 switch (II->getIntrinsicID()) {

5928 case Intrinsic::frexp: {

5930

5933 InterestedClasses, KnownSrc, Q, Depth + 1);

5934

5937 Op->getType()->getScalarType()->getFltSemantics();

5938

5941 else {

5942 if (F &&

5947 }

5948

5951 else {

5952 if (F &&

5957 }

5958

5960 return;

5961 }

5962 default:

5963 break;

5964 }

5965 }

5966 }

5967

5970 break;

5971 }

5972 case Instruction::PHI: {

5974

5975 if (P->getNumIncomingValues() == 0)

5976 break;

5977

5978

5979

5981

5982 if (Depth < PhiRecursionLimit) {

5983

5985 break;

5986

5987 bool First = true;

5988

5989 for (const Use &U : P->operands()) {

5990 Value *IncValue;

5993

5994 if (IncValue == P)

5995 continue;

5996

5998

5999

6000

6001 computeKnownFPClass(IncValue, DemandedElts, InterestedClasses, KnownSrc,

6003 PhiRecursionLimit);

6004

6006 Known = KnownSrc;

6008 } else {

6009 Known |= KnownSrc;

6010 }

6011

6013 break;

6014 }

6015 }

6016

6017 break;

6018 }

6019 case Instruction::BitCast: {

6020 const Value *Src;

6022 !Src->getType()->isIntOrIntVectorTy())

6023 break;

6024

6025 const Type *Ty = Op->getType()->getScalarType();

6026 KnownBits Bits(Ty->getScalarSizeInBits());

6028

6029

6030 if (Bits.isNonNegative())

6032 else if (Bits.isNegative())

6034

6035 if (Ty->isIEEELikeFPTy()) {

6036

6037

6038

6039

6040

6041

6042

6043 if (APFloat(Ty->getFltSemantics(), Bits.One).isNaN())

6045 else if ( APFloat (Ty->getFltSemantics(), ~Bits.Zero).isNaN())

6047

6048

6049

6051 APFloat::getInf(Ty->getFltSemantics()).bitcastToAPInt());

6052 InfKB.Zero.clearSignBit();

6053 if (const auto InfResult = KnownBits::eq(Bits, InfKB)) {

6054 assert(!InfResult.value());

6056 } else if (Bits == InfKB) {

6058 }

6059

6060

6061

6064 ZeroKB.Zero.clearSignBit();

6065 if (const auto ZeroResult = KnownBits::eq(Bits, ZeroKB)) {

6066 assert(!ZeroResult.value());

6068 } else if (Bits == ZeroKB) {

6070 }

6071 }

6072

6073 break;

6074 }

6075 default:

6076 break;

6077 }

6078}

6079

6081 const APInt &DemandedElts,

6084 unsigned Depth) {

6088 return KnownClasses;

6089}

6090

6094 unsigned Depth) {

6097 return Known;

6098}

6099

6108

6114 InterestedClasses &= ~fcNan;

6116 InterestedClasses &= ~fcInf;

6117

6120

6122 Result.KnownFPClasses &= ~fcNan;

6124 Result.KnownFPClasses &= ~fcInf;

6125 return Result;

6126}

6127

6131 unsigned Depth) {

6133 APInt DemandedElts =

6137}

6138

6140 unsigned Depth) {

6143}

6144

6146 unsigned Depth) {

6150}

6151

6153 unsigned Depth) {

6156}

6157

6158

6160 unsigned Depth) {

6163}

6164

6165

6166

6167

6169 unsigned Depth) {

6172}

6173

6174

6175

6176

6179 unsigned Depth) {

6182}

6183

6187 if (FPOp->hasNoSignedZeros())

6188 return true;

6189 }

6190

6191 switch (User->getOpcode()) {

6192 case Instruction::FPToSI:

6193 case Instruction::FPToUI:

6194 return true;

6195 case Instruction::FCmp:

6196

6197 return true;

6198 case Instruction::Call:

6200 switch (II->getIntrinsicID()) {

6201 case Intrinsic::fabs:

6202 return true;

6203 case Intrinsic::copysign:

6204 return U.getOperandNo() == 0;

6205 case Intrinsic::is_fpclass:

6206 case Intrinsic::vp_is_fpclass: {

6212 }

6213 default:

6214 return false;

6215 }

6216 }

6217 return false;

6218 default:

6219 return false;

6220 }

6221}

6222

6226 if (FPOp->hasNoNaNs())

6227 return true;

6228 }

6229

6230 switch (User->getOpcode()) {

6231 case Instruction::FPToSI:

6232 case Instruction::FPToUI:

6233 return true;

6234

6235 case Instruction::FAdd:

6236 case Instruction::FSub:

6237 case Instruction::FMul:

6238 case Instruction::FDiv:

6239 case Instruction::FRem:

6240 case Instruction::FPTrunc:

6241 case Instruction::FPExt:

6242 case Instruction::FCmp:

6243 return true;

6244

6245 case Instruction::FNeg:

6246 case Instruction::Select:

6247 case Instruction::PHI:

6248 return false;

6249 case Instruction::Ret:

6250 return User->getFunction()->getAttributes().getRetNoFPClass() &

6252 case Instruction::Call:

6253 case Instruction::Invoke: {

6255 switch (II->getIntrinsicID()) {

6256 case Intrinsic::fabs:

6257 return true;

6258 case Intrinsic::copysign:

6259 return U.getOperandNo() == 0;

6260

6261 case Intrinsic::maxnum:

6262 case Intrinsic::minnum:

6263 case Intrinsic::maximum:

6264 case Intrinsic::minimum:

6265 case Intrinsic::maximumnum:

6266 case Intrinsic::minimumnum:

6267 case Intrinsic::canonicalize:

6268 case Intrinsic::fma:

6269 case Intrinsic::fmuladd:

6270 case Intrinsic::sqrt:

6271 case Intrinsic::pow:

6272 case Intrinsic::powi:

6273 case Intrinsic::fptoui_sat:

6274 case Intrinsic::fptosi_sat:

6275 case Intrinsic::is_fpclass:

6276 case Intrinsic::vp_is_fpclass:

6277 return true;

6278 default:

6279 return false;

6280 }

6281 }

6282

6286 }

6287 default:

6288 return false;

6289 }

6290}

6291

6293

6294

6295 if (V->getType()->isIntegerTy(8))

6296 return V;

6297

6299

6300

6303 return UndefInt8;

6304

6305

6306 if (DL.getTypeStoreSize(V->getType()).isZero())

6308

6310 if () {

6311

6312

6313

6314

6315

6316

6317 return nullptr;

6318 }

6319

6320

6321 if (C->isNullValue())

6323

6324

6325

6327 Type *Ty = nullptr;

6328 if (CFP->getType()->isHalfTy())

6330 else if (CFP->getType()->isFloatTy())

6332 else if (CFP->getType()->isDoubleTy())

6334

6336 : nullptr;

6337 }

6338

6339

6341 if (CI->getBitWidth() % 8 == 0) {

6342 assert(CI->getBitWidth() > 8 && "8 bits should be handled above!");

6343 if (!CI->getValue().isSplat(8))

6344 return nullptr;

6345 return ConstantInt::get(Ctx, CI->getValue().trunc(8));

6346 }

6347 }

6348

6350 if (CE->getOpcode() == Instruction::IntToPtr) {

6352 unsigned BitWidth = DL.getPointerSizeInBits(PtrTy->getAddressSpace());

6356 }

6357 }

6358 }

6359

6361 if (LHS == RHS)

6362 return LHS;

6363 if (!LHS || !RHS)

6364 return nullptr;

6365 if (LHS == UndefInt8)

6366 return RHS;

6367 if (RHS == UndefInt8)

6368 return LHS;

6369 return nullptr;

6370 };

6371

6373 Value *Val = UndefInt8;

6374 for (uint64_t I = 0, E = CA->getNumElements(); I != E; ++I)

6376 return nullptr;

6377 return Val;

6378 }

6379

6381 Value *Val = UndefInt8;

6382 for (Value *Op : C->operands())

6384 return nullptr;

6385 return Val;

6386 }

6387

6388

6389 return nullptr;

6390}

6391

6392

6393

6394

6395

6396

6397

6400 unsigned IdxSkip,

6403 if (STy) {

6404

6405 Value *OrigTo = To;

6406

6407 for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {

6408

6410 Value *PrevTo = To;

6412 InsertBefore);

6414 if (!To) {

6415

6416 while (PrevTo != OrigTo) {

6420 }

6421

6422 break;

6423 }

6424 }

6425

6426 if (To)

6427 return To;

6428 }

6429

6430

6431

6432

6433

6434

6436

6437 if (!V)

6438 return nullptr;

6439

6440

6442 InsertBefore);

6443}

6444

6445

6446

6447

6448

6449

6450

6451

6452

6453

6454

6455

6456

6460 idx_range);

6463 unsigned IdxSkip = Idxs.size();

6464

6465 return BuildSubAggregate(From, To, IndexedType, Idxs, IdxSkip, InsertBefore);

6466}

6467

6468

6469

6470

6471

6472

6473

6476 std::optionalBasicBlock::iterator InsertBefore) {

6477

6478

6479 if (idx_range.empty())

6480 return V;

6481

6482 assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&

6483 "Not looking at a struct or array?");

6485 "Invalid indices for type?");

6486

6488 C = C->getAggregateElement(idx_range[0]);

6489 if () return nullptr;

6491 }

6492

6494

6495

6496 const unsigned *req_idx = idx_range.begin();

6497 for (const unsigned *i = I->idx_begin(), *e = I->idx_end();

6498 i != e; ++i, ++req_idx) {

6499 if (req_idx == idx_range.end()) {

6500

6501 if (!InsertBefore)

6502 return nullptr;

6503

6504

6505

6506

6507

6508

6509

6510

6511

6512

6513

6515 *InsertBefore);

6516 }

6517

6518

6519

6520

6521 if (*req_idx != *i)

6523 InsertBefore);

6524 }

6525

6526

6527

6529 ArrayRef(req_idx, idx_range.end()), InsertBefore);

6530 }

6531

6533

6534

6535

6536

6537

6538 unsigned size = I->getNumIndices() + idx_range.size();

6539

6542

6543 Idxs.append(I->idx_begin(), I->idx_end());

6544

6545

6547

6549 && "Number of indices added not correct?");

6550

6551 return FindInsertedValue(I->getAggregateOperand(), Idxs, InsertBefore);

6552 }

6553

6554

6555 return nullptr;

6556}

6557

6558

6559

6560

6561

6562

6566 assert(V && "V should not be null.");

6567 assert((ElementSize % 8) == 0 &&

6568 "ElementSize expected to be a multiple of the size of a byte.");

6569 unsigned ElementSizeInBytes = ElementSize / 8;

6570

6571

6572

6573

6577

6578 return false;

6579

6581 APInt Off(DL.getIndexTypeSizeInBits(V->getType()), 0);

6582

6584 true))

6585

6586 return false;

6587

6588 uint64_t StartIdx = Off.getLimitedValue();

6590

6591 return false;

6592

6593

6594

6595 if ((StartIdx % ElementSizeInBytes) != 0)

6596 return false;

6597

6598 Offset += StartIdx / ElementSizeInBytes;

6601

6604 uint64_t SizeInBytes = DL.getTypeStoreSize(GVTy).getFixedValue();

6606

6607 Slice.Array = nullptr;

6608 Slice.Offset = 0;

6609

6610

6611

6612

6614 return true;

6615 }

6616

6619 Type *InitElTy = ArrayInit->getElementType();

6620 if (InitElTy->isIntegerTy(ElementSize)) {

6621

6622

6623 Array = ArrayInit;

6624 ArrayTy = ArrayInit->getType();

6625 }

6626 }

6627

6628 if (!Array) {

6629 if (ElementSize != 8)

6630

6631 return false;

6632

6633

6634

6637 return false;

6638

6642 }

6643

6645 if (Offset > NumElts)

6646 return false;

6647

6648 Slice.Array = Array;

6649 Slice.Offset = Offset;

6650 Slice.Length = NumElts - Offset;

6651 return true;

6652}

6653

6654

6655

6656

6657

6659 bool TrimAtNul) {

6662 return false;

6663

6664 if (Slice.Array == nullptr) {

6665 if (TrimAtNul) {

6666

6667

6668

6669

6670

6671

6673 return true;

6674 }

6675 if (Slice.Length == 1) {

6677 return true;

6678 }

6679

6680

6681 return false;

6682 }

6683

6684

6686

6687 Str = Str.substr(Slice.Offset);

6688

6689 if (TrimAtNul) {

6690

6691

6692

6693 Str = Str.substr(0, Str.find('\0'));

6694 }

6695 return true;

6696}

6697

6698

6699

6700

6701

6702

6703

6706 unsigned CharSize) {

6707

6708 V = V->stripPointerCasts();

6709

6710

6711

6713 if (!PHIs.insert(PN).second)

6714 return ~0ULL;

6715

6716

6718 for (Value *IncValue : PN->incoming_values()) {

6720 if (Len == 0) return 0;

6721

6722 if (Len == ~0ULL) continue;

6723

6724 if (Len != LenSoFar && LenSoFar != ~0ULL)

6725 return 0;

6726 LenSoFar = Len;

6727 }

6728

6729

6730 return LenSoFar;

6731 }

6732

6733

6736 if (Len1 == 0) return 0;

6738 if (Len2 == 0) return 0;

6739 if (Len1 == ~0ULL) return Len2;

6740 if (Len2 == ~0ULL) return Len1;

6741 if (Len1 != Len2) return 0;

6742 return Len1;

6743 }

6744

6745

6748 return 0;

6749

6750 if (Slice.Array == nullptr)

6751

6752 return 1;

6753

6754

6755

6756

6757

6758 unsigned NullIndex = 0;

6759 for (unsigned E = Slice.Length; NullIndex < E; ++NullIndex) {

6760 if (Slice.Array->getElementAsInteger(Slice.Offset + NullIndex) == 0)

6761 break;

6762 }

6763

6764 return NullIndex + 1;

6765}

6766

6767

6768

6770 if (!V->getType()->isPointerTy())

6771 return 0;

6772

6775

6776

6777 return Len == ~0ULL ? 1 : Len;

6778}

6779

6782 bool MustPreserveNullness) {

6784 "getArgumentAliasingToReturnedPointer only works on nonnull calls");

6785 if (const Value *RV = Call->getReturnedArgOperand())

6786 return RV;

6787

6789 Call, MustPreserveNullness))

6790 return Call->getArgOperand(0);

6791 return nullptr;

6792}

6793

6795 const CallBase *Call, bool MustPreserveNullness) {

6796 switch (Call->getIntrinsicID()) {

6797 case Intrinsic::launder_invariant_group:

6798 case Intrinsic::strip_invariant_group:

6799 case Intrinsic::aarch64_irg:

6800 case Intrinsic::aarch64_tagp:

6801

6802

6803

6804

6805

6806

6807

6808

6809

6810 case Intrinsic::amdgcn_make_buffer_rsrc:

6811 return true;

6812 case Intrinsic::ptrmask:

6813 return !MustPreserveNullness;

6814 case Intrinsic::threadlocal_address:

6815

6816

6817 return Call ->getParent()->getParent()->isPresplitCoroutine();

6818 default:

6819 return false;

6820 }

6821}

6822

6823

6824

6827

6830 return true;

6831

6832

6834 if (!PrevValue || LI->getLoopFor(PrevValue->getParent()) != L)

6836 if (!PrevValue || LI->getLoopFor(PrevValue->getParent()) != L)

6837 return true;

6838

6839

6840

6841

6842

6843

6845 if (!L->isLoopInvariant(Load->getPointerOperand()))

6846 return false;

6847 return true;

6848}

6849

6851 for (unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {

6853 const Value *PtrOp = GEP->getPointerOperand();

6854 if (!PtrOp->getType()->isPointerTy())

6855 return V;

6856 V = PtrOp;

6861 return V;

6862 V = NewV;

6864 if (GA->isInterposable())

6865 return V;

6866 V = GA->getAliasee();

6867 } else {

6869

6870 if (PHI->getNumIncomingValues() == 1) {

6871 V = PHI->getIncomingValue(0);

6872 continue;

6873 }

6875

6876

6877

6878

6879

6880

6881

6882

6883

6885 V = RP;

6886 continue;

6887 }

6888 }

6889

6890 return V;

6891 }

6892 assert(V->getType()->isPointerTy() && "Unexpected operand type!");

6893 }

6894 return V;

6895}

6896

6899 const LoopInfo *LI, unsigned MaxLookup) {

6903 do {

6906

6907 if (!Visited.insert(P).second)

6908 continue;

6909

6912 Worklist.push_back(SI->getFalseValue());

6913 continue;

6914 }

6915

6917

6918

6919

6920

6921

6922

6923

6924

6925

6926

6927 if (!LI || !LI->isLoopHeader(PN->getParent()) ||

6929 append_range(Worklist, PN->incoming_values());

6930 else

6932 continue;

6933 }

6934

6936 } while (!Worklist.empty());

6937}

6938

6940 const unsigned MaxVisited = 8;

6941

6945 const Value *Object = nullptr;

6946

6947

6948 bool First = true;

6950 do {

6954

6955 if (!Visited.insert(P).second)

6956 continue;

6957

6958 if (Visited.size() == MaxVisited)

6959 return FirstObject;

6960

6963 Worklist.push_back(SI->getFalseValue());

6964 continue;

6965 }

6966

6968 append_range(Worklist, PN->incoming_values());

6969 continue;

6970 }

6971

6972 if (!Object)

6973 Object = P;

6974 else if (Object != P)

6975 return FirstObject;

6976 } while (!Worklist.empty());

6977

6978 return Object ? Object : FirstObject;

6979}

6980

6981

6982

6984 do {

6986

6987

6988 if (U->getOpcode() == Instruction::PtrToInt)

6989 return U->getOperand(0);

6990

6991

6992

6993

6994

6995

6996 if (U->getOpcode() != Instruction::Add ||

7000 return V;

7001 V = U->getOperand(0);

7002 } else {

7003 return V;

7004 }

7005 assert(V->getType()->isIntegerTy() && "Unexpected operand type!");

7006 } while (true);

7007}

7008

7009

7010

7011

7016 do {

7018

7021

7022 for (const Value *V : Objs) {

7023 if (!Visited.insert(V).second)

7024 continue;

7026 const Value *O =

7028 if (O->getType()->isPointerTy()) {

7030 continue;

7031 }

7032 }

7033

7034

7036 Objects.clear();

7037 return false;

7038 }

7040 }

7041 } while (!Working.empty());

7042 return true;

7043}

7044

7049

7050 auto AddWork = [&](Value *V) {

7051 if (Visited.insert(V).second)

7053 };

7054

7055 AddWork(V);

7056 do {

7059

7061 if (Result && Result != AI)

7062 return nullptr;

7063 Result = AI;

7065 AddWork(CI->getOperand(0));

7067 for (Value *IncValue : PN->incoming_values())

7068 AddWork(IncValue);

7070 AddWork(SI->getTrueValue());

7071 AddWork(SI->getFalseValue());

7073 if (OffsetZero && GEP ->hasAllZeroIndices())

7074 return nullptr;

7075 AddWork(GEP->getPointerOperand());

7077 Value *Returned = CB->getReturnedArgOperand();

7078 if (Returned)

7079 AddWork(Returned);

7080 else

7081 return nullptr;

7082 } else {

7083 return nullptr;

7084 }

7085 } while (!Worklist.empty());

7086

7087 return Result;

7088}

7089

7091 const Value *V, bool AllowLifetime, bool AllowDroppable) {

7092 for (const User *U : V->users()) {

7094 if ()

7095 return false;

7096

7097 if (AllowLifetime && II->isLifetimeStartOrEnd())

7098 continue;

7099

7100 if (AllowDroppable && II->isDroppable())

7101 continue;

7102

7103 return false;

7104 }

7105 return true;

7106}

7107

7110 V, true, false);

7111}

7114 V, true, true);

7115}

7116

7121 return (!Shuffle || Shuffle->isSelect()) &&

7123}

7124

7128 bool IgnoreUBImplyingAttrs) {

7130 AC, DT, TLI, UseVariableInfo,

7131 IgnoreUBImplyingAttrs);

7132}

7133

7137 bool UseVariableInfo, bool IgnoreUBImplyingAttrs) {

7138#ifndef NDEBUG

7139 if (Inst->getOpcode() != Opcode) {

7140

7141 auto hasEqualReturnAndLeadingOperandTypes =

7142 [](const Instruction *Inst, unsigned NumLeadingOperands) {

7144 return false;

7145 const Type *ExpectedType = Inst->getType();

7146 for (unsigned ItOp = 0; ItOp < NumLeadingOperands; ++ItOp)

7148 return false;

7149 return true;

7150 };

7152 hasEqualReturnAndLeadingOperandTypes(Inst, 2));

7154 hasEqualReturnAndLeadingOperandTypes(Inst, 1));

7155 }

7156#endif

7157

7158 switch (Opcode) {

7159 default:

7160 return true;

7161 case Instruction::UDiv:

7162 case Instruction::URem: {

7163

7166 return *V != 0;

7167 return false;

7168 }

7169 case Instruction::SDiv:

7170 case Instruction::SRem: {

7171

7172 const APInt *Numerator, *Denominator;

7174 return false;

7175

7176 if (*Denominator == 0)

7177 return false;

7178

7180 return true;

7181

7182

7185

7186 return false;

7187 }

7188 case Instruction::Load: {

7189 if (!UseVariableInfo)

7190 return false;

7191

7193 if (!LI)

7194 return false;

7196 return false;

7200 CtxI, AC, DT, TLI);

7201 }

7202 case Instruction::Call: {

7204 if (!CI)

7205 return false;

7206 const Function *Callee = CI->getCalledFunction();

7207

7208

7209

7210 if (!Callee || !Callee->isSpeculatable())

7211 return false;

7212

7213

7214 return IgnoreUBImplyingAttrs || !CI->hasUBImplyingAttrs();

7215 }

7216 case Instruction::VAArg:

7217 case Instruction::Alloca:

7218 case Instruction::Invoke:

7219 case Instruction::CallBr:

7220 case Instruction::PHI:

7221 case Instruction::Store:

7222 case Instruction::Ret:

7223 case Instruction::Br:

7224 case Instruction::IndirectBr:

7225 case Instruction::Switch:

7226 case Instruction::Unreachable:

7227 case Instruction::Fence:

7228 case Instruction::AtomicRMW:

7229 case Instruction::AtomicCmpXchg:

7230 case Instruction::LandingPad:

7231 case Instruction::Resume:

7232 case Instruction::CatchSwitch:

7233 case Instruction::CatchPad:

7234 case Instruction::CatchRet:

7235 case Instruction::CleanupPad:

7236 case Instruction::CleanupRet:

7237 return false;

7238 }

7239}

7240

7242 if (I.mayReadOrWriteMemory())

7243

7244 return true;

7246

7247

7248 return true;

7250

7251

7252

7253 return true;

7254 return false;

7255}

7256

7257

7259 switch (OR) {

7268 }

7270}

7271

7272

7275 bool ForSigned,

7283}

7284

7286 const Value *RHS,

7288 bool IsNSW) {

7291

7292

7295

7299}

7300

7302 const Value *RHS,

7304

7305

7306

7307

7308

7309

7310 unsigned BitWidth = LHS->getType()->getScalarSizeInBits();

7311

7312

7313

7314 unsigned SignBits =

7316

7317

7318

7319 if (SignBits > BitWidth + 1)

7321

7322

7323

7324

7325

7326

7327 if (SignBits == BitWidth + 1) {

7328

7329

7330

7331

7336 }

7338}

7339

7350

7355 if (Add && Add->hasNoSignedWrap()) {

7357 }

7358

7359

7360

7361

7362

7363

7364

7365

7366

7367

7368

7369

7370

7371

7372

7375

7383 return OR;

7384

7385

7386 if ( Add )

7388

7389

7390

7391

7392

7393

7394 bool LHSOrRHSKnownNonNegative =

7396 bool LHSOrRHSKnownNegative =

7398 if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {

7401 if ((AddKnown.isNonNegative() && LHSOrRHSKnownNonNegative) ||

7402 (AddKnown.isNegative() && LHSOrRHSKnownNegative))

7404 }

7405

7407}

7408

7410 const Value *RHS,

7412

7413

7414

7415

7416

7417

7418

7419

7420

7421

7422

7427

7429 SQ.DL)) {

7430 if (*C)

7433 }

7434

7440}

7441

7443 const Value *RHS,

7445

7446

7447

7448

7449

7450

7451

7452

7457

7458

7459

7462

7468}

7469

7474

7475 for (const User *U : WO->users()) {

7477 assert(EVI->getNumIndices() == 1 && "Obvious from CI's type");

7478

7479 if (EVI->getIndices()[0] == 0)

7481 else {

7482 assert(EVI->getIndices()[0] == 1 && "Obvious from CI's type");

7483

7484 for (const auto *U : EVI->users())

7486 assert(B->isConditional() && "How else is it using an i1?");

7488 }

7489 }

7490 } else {

7491

7492

7493 return false;

7494 }

7495 }

7496

7497 auto AllUsesGuardedByBranch = [&](const BranchInst *BI) {

7498 BasicBlockEdge NoWrapEdge(BI->getParent(), BI->getSuccessor(1));

7500 return false;

7501

7502

7503 for (const auto *Result : Results) {

7504

7505

7506 if (DT.dominates(NoWrapEdge, Result->getParent()))

7507 continue;

7508

7509 for (const auto &RU : Result->uses())

7510 if (!DT.dominates(NoWrapEdge, RU))

7511 return false;

7512 }

7513

7514 return true;

7515 };

7516

7517 return llvm::any_of(GuardingBranches, AllUsesGuardedByBranch);

7518}

7519

7520

7523 if ()

7524 return false;

7525

7526

7529 unsigned NumElts = FVTy->getNumElements();

7530 for (unsigned i = 0; i < NumElts; ++i)

7531 ShiftAmounts.push_back(C->getAggregateElement(i));

7533 return false;

7534 else

7536

7539 return CI && CI->getValue().ult(C->getType()->getIntegerBitWidth());

7540 });

7541

7542 return Safe;

7543}

7544

7550

7554

7558

7560 bool ConsiderFlagsAndMetadata) {

7561

7562 if (ConsiderFlagsAndMetadata && includesPoison(Kind) &&

7563 Op->hasPoisonGeneratingAnnotations())

7564 return true;

7565

7566 unsigned Opcode = Op->getOpcode();

7567

7568

7569 switch (Opcode) {

7570 case Instruction::Shl:

7571 case Instruction::AShr:

7572 case Instruction::LShr:

7574 case Instruction::FPToSI:

7575 case Instruction::FPToUI:

7576

7577

7578 return true;

7579 case Instruction::Call:

7581 switch (II->getIntrinsicID()) {

7582

7583 case Intrinsic::ctlz:

7584 case Intrinsic::cttz:

7585 case Intrinsic::abs:

7587 return false;

7588 break;

7589 case Intrinsic::sshl_sat:

7590 case Intrinsic::ushl_sat:

7593 return false;

7594 break;

7595 }

7596 }

7597 [[fallthrough]];

7598 case Instruction::CallBr:

7599 case Instruction::Invoke: {

7601 return !CB->hasRetAttr(Attribute::NoUndef) &&

7602 !CB->hasFnAttr(Attribute::NoCreateUndefOrPoison);

7603 }

7604 case Instruction::InsertElement:

7605 case Instruction::ExtractElement: {

7606

7608 unsigned IdxOp = Op->getOpcode() == Instruction::InsertElement ? 2 : 1;

7611 return !Idx ||

7612 Idx->getValue().uge(VTy->getElementCount().getKnownMinValue());

7613 return false;

7614 }

7615 case Instruction::ShuffleVector: {

7620 }

7621 case Instruction::FNeg:

7622 case Instruction::PHI:

7623 case Instruction::Select:

7624 case Instruction::ExtractValue:

7625 case Instruction::InsertValue:

7626 case Instruction::Freeze:

7627 case Instruction::ICmp:

7628 case Instruction::FCmp:

7629 case Instruction::GetElementPtr:

7630 return false;

7631 case Instruction::AddrSpaceCast:

7632 return true;

7633 default: {

7636 return false;

7638 return false;

7639

7640 return true;

7641 }

7642 }

7643}

7644

7646 bool ConsiderFlagsAndMetadata) {

7648 ConsiderFlagsAndMetadata);

7649}

7650

7653 ConsiderFlagsAndMetadata);

7654}

7655

7657 unsigned Depth) {

7658 if (ValAssumedPoison == V)

7659 return true;

7660

7661 const unsigned MaxDepth = 2;

7662 if (Depth >= MaxDepth)

7663 return false;

7664

7666 if (any_of(I->operands(), [=](const Use &Op) {

7667 return propagatesPoison(Op) &&

7668 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);

7669 }))

7670 return true;

7671

7672

7673

7674

7679 return true;

7680 }

7681 return false;

7682}

7683

7685 unsigned Depth) {

7687 return true;

7688

7690 return true;

7691

7692 const unsigned MaxDepth = 2;

7693 if (Depth >= MaxDepth)

7694 return false;

7695

7699 return impliesPoison(Op, V, Depth + 1);

7700 });

7701 }

7702 return false;

7703}

7704

7706 return ::impliesPoison(ValAssumedPoison, V, 0);

7707}

7708

7710

7715 return false;

7716

7718 return false;

7719

7721 if (A->hasAttribute(Attribute::NoUndef) ||

7722 A->hasAttribute(Attribute::Dereferenceable) ||

7723 A->hasAttribute(Attribute::DereferenceableOrNull))

7724 return true;

7725 }

7726

7730

7733

7736 return true;

7737

7738 if (C->getType()->isVectorTy()) {

7740

7741 if (Constant *SplatC = C->getSplatValue())

7743 return true;

7744 } else {

7745 if (includesUndef(Kind) && C->containsUndefElement())

7746 return false;

7748 return false;

7749 return ->containsConstantExpression();

7750 }

7751 }

7752 }

7753

7754

7755

7756

7757

7758

7759

7760

7761

7762 auto *StrippedV = V->stripPointerCastsSameRepresentation();

7765 return true;

7766

7767 auto OpCheck = [&](const Value *V) {

7769 };

7770

7772

7773

7775 return true;

7776

7778 if (CB->hasRetAttr(Attribute::NoUndef) ||

7779 CB->hasRetAttr(Attribute::Dereferenceable) ||

7780 CB->hasRetAttr(Attribute::DereferenceableOrNull))

7781 return true;

7782 }

7783

7785 true)) {

7787 unsigned Num = PN->getNumIncomingValues();

7788 bool IsWellDefined = true;

7789 for (unsigned i = 0; i < Num; ++i) {

7790 if (PN == PN->getIncomingValue(i))

7791 continue;

7792 auto *TI = PN->getIncomingBlock(i)->getTerminator();

7794 DT, Depth + 1, Kind)) {

7795 IsWellDefined = false;

7796 break;

7797 }

7798 }

7799 if (IsWellDefined)

7800 return true;

7802 : nullptr) {

7803

7804 if (OpCheck(Splat))

7805 return true;

7806 } else if (all_of(Opr->operands(), OpCheck))

7807 return true;

7808 }

7809 }

7810

7812 if (I->hasMetadata(LLVMContext::MD_noundef) ||

7813 I->hasMetadata(LLVMContext::MD_dereferenceable) ||

7814 I->hasMetadata(LLVMContext::MD_dereferenceable_or_null))

7815 return true;

7816

7818 return true;

7819

7820

7821 if (!CtxI || !CtxI->getParent() || !DT)

7822 return false;

7823

7825 if (!DNode)

7826

7827 return false;

7828

7829

7830

7831

7832

7833

7834 auto *Dominator = DNode->getIDom();

7835

7836

7837 if ( includesUndef (Kind) || V->getType()->isIntegerTy())

7838 while (Dominator) {

7839 auto *TI = Dominator->getBlock()->getTerminator();

7840

7843 if (BI->isConditional())

7844 Cond = BI->getCondition();

7846 Cond = SI->getCondition();

7847 }

7848

7850 if (Cond == V)

7851 return true;

7853

7855 if (any_of(Opr->operands(), [V](const Use &U) {

7856 return V == U && propagatesPoison(U);

7857 }))

7858 return true;

7859 }

7860 }

7861

7862 Dominator = Dominator->getIDom();

7863 }

7864

7866 return true;

7867

7868 return false;

7869}

7870

7874 unsigned Depth) {

7875 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth,

7877}

7878

7882 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth,

7884}

7885

7889 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth,

7891}

7892

7893

7894

7895

7896

7897

7898

7899

7903

7904

7905

7906

7907

7908

7909

7913 while (!Worklist.empty()) {

7915

7916

7918 return true;

7919

7920

7921

7922 if (I != Root && $any\_of$ (I->operands(), [&KnownPoison](const Use &U) {

7923 return KnownPoison.contains(U) && propagatesPoison(U);

7924 }))

7925 continue;

7926

7927 if (KnownPoison.insert(I).second)

7928 for (const User *User : I->users())

7930 }

7931

7932

7933

7934 return false;

7935}

7936

7939 return ::computeOverflowForSignedAdd(Add->getOperand(0), Add->getOperand(1),

7940 Add, SQ);

7941}

7942

7947 return ::computeOverflowForSignedAdd(LHS, RHS, nullptr, SQ);

7948}

7949

7951

7952

7953

7954

7955

7957 return false;

7959 return false;

7960

7961

7962

7963

7964

7967 default:

7968

7969

7970 return false;

7972

7973 return true;

7974 }

7975 }

7976

7977

7978

7979 return ->mayThrow() && I->willReturn();

7980}

7981

7983

7984

7987 return false;

7988 return true;

7989}

7990

7993 unsigned ScanLimit) {

7995 ScanLimit);

7996}

7997

8000 assert(ScanLimit && "scan limit must be non-zero");

8002 if (--ScanLimit == 0)

8003 return false;

8005 return false;

8006 }

8007 return true;

8008}

8009

8011 const Loop *L) {

8012

8013

8014

8015

8016 if (I->getParent() != L->getHeader()) return false;

8017

8018 for (const Instruction &LI : *L->getHeader()) {

8019 if (&LI == I) return true;

8021 }

8022 llvm_unreachable("Instruction not contained in its own parent basic block.");

8023}

8024

8026 switch (IID) {

8027

8028 case Intrinsic::sadd_with_overflow:

8029 case Intrinsic::ssub_with_overflow:

8030 case Intrinsic::smul_with_overflow:

8031 case Intrinsic::uadd_with_overflow:

8032 case Intrinsic::usub_with_overflow:

8033 case Intrinsic::umul_with_overflow:

8034

8035

8036

8037 return true;

8038 case Intrinsic::ctpop:

8039 case Intrinsic::ctlz:

8040 case Intrinsic::cttz:

8041 case Intrinsic::abs:

8042 case Intrinsic::smax:

8043 case Intrinsic::smin:

8044 case Intrinsic::umax:

8045 case Intrinsic::umin:

8046 case Intrinsic::scmp:

8047 case Intrinsic::is_fpclass:

8048 case Intrinsic::ptrmask:

8049 case Intrinsic::ucmp:

8050 case Intrinsic::bitreverse:

8051 case Intrinsic::bswap:

8052 case Intrinsic::sadd_sat:

8053 case Intrinsic::ssub_sat:

8054 case Intrinsic::sshl_sat:

8055 case Intrinsic::uadd_sat:

8056 case Intrinsic::usub_sat:

8057 case Intrinsic::ushl_sat:

8058 case Intrinsic::smul_fix:

8059 case Intrinsic::smul_fix_sat:

8060 case Intrinsic::umul_fix:

8061 case Intrinsic::umul_fix_sat:

8062 case Intrinsic::pow:

8063 case Intrinsic::powi:

8064 case Intrinsic::sin:

8065 case Intrinsic::sinh:

8066 case Intrinsic::cos:

8067 case Intrinsic::cosh:

8068 case Intrinsic::sincos:

8069 case Intrinsic::sincospi:

8070 case Intrinsic::tan:

8071 case Intrinsic::tanh:

8072 case Intrinsic::asin:

8073 case Intrinsic::acos:

8074 case Intrinsic::atan:

8075 case Intrinsic::atan2:

8076 case Intrinsic::canonicalize:

8077 case Intrinsic::sqrt:

8078 case Intrinsic::exp:

8079 case Intrinsic::exp2:

8080 case Intrinsic::exp10:

8081 case Intrinsic:🪵

8082 case Intrinsic::log2:

8083 case Intrinsic::log10:

8084 case Intrinsic::modf:

8085 case Intrinsic:🤣

8086 case Intrinsic::ceil:

8087 case Intrinsic::trunc:

8088 case Intrinsic::rint:

8089 case Intrinsic::nearbyint:

8090 case Intrinsic::round:

8091 case Intrinsic::roundeven:

8092 case Intrinsic::lrint:

8093 case Intrinsic::llrint:

8094 return true;

8095 default:

8096 return false;

8097 }

8098}

8099

8102 switch (I->getOpcode()) {

8103 case Instruction::Freeze:

8104 case Instruction::PHI:

8105 case Instruction::Invoke:

8106 return false;

8107 case Instruction::Select:

8109 case Instruction::Call:

8112 return false;

8113 case Instruction::ICmp:

8114 case Instruction::FCmp:

8115 case Instruction::GetElementPtr:

8116 return true;

8117 default:

8119 return true;

8120

8121

8122 return false;

8123 }

8124}

8125

8126

8127

8128

8129template

8131 const CallableT &Handle) {

8132 switch (I->getOpcode()) {

8133 case Instruction::Store:

8135 return true;

8136 break;

8137

8138 case Instruction::Load:

8140 return true;

8141 break;

8142

8143

8144

8145 case Instruction::AtomicCmpXchg:

8147 return true;

8148 break;

8149

8150 case Instruction::AtomicRMW:

8152 return true;

8153 break;

8154

8155 case Instruction::Call:

8156 case Instruction::Invoke: {

8159 return true;

8160 for (unsigned i = 0; i < CB->arg_size(); ++i)

8161 if ((CB->paramHasAttr(i, Attribute::NoUndef) ||

8162 CB->paramHasAttr(i, Attribute::Dereferenceable) ||

8163 CB->paramHasAttr(i, Attribute::DereferenceableOrNull)) &&

8165 return true;

8166 break;

8167 }

8168 case Instruction::Ret:

8169 if (I->getFunction()->hasRetAttribute(Attribute::NoUndef) &&

8170 Handle(I->getOperand(0)))

8171 return true;

8172 break;

8173 case Instruction::Switch:

8175 return true;

8176 break;

8177 case Instruction::Br: {

8179 if (BR->isConditional() && Handle(BR->getCondition()))

8180 return true;

8181 break;

8182 }

8183 default:

8184 break;

8185 }

8186

8187 return false;

8188}

8189

8190

8191template

8193 const CallableT &Handle) {

8195 return true;

8196 switch (I->getOpcode()) {

8197

8198 case Instruction::UDiv:

8199 case Instruction::SDiv:

8200 case Instruction::URem:

8201 case Instruction::SRem:

8202 return Handle(I->getOperand(1));

8203 default:

8204 return false;

8205 }

8206}

8207

8211 I, [&](const Value *V) { return KnownPoison.count(V); });

8212}

8213

8216

8217

8218

8219

8220

8221

8222

8228 Begin++;

8230 if (Arg->getParent()->isDeclaration())

8231 return false;

8233 Begin = BB->begin();

8234 } else {

8235 return false;

8236 }

8237

8238

8239

8240 unsigned ScanLimit = 32;

8242

8244

8245

8246

8247

8248 for (const auto &I : make_range(Begin, End)) {

8249 if (--ScanLimit == 0)

8250 break;

8251

8253 return WellDefinedOp == V;

8254 }))

8255 return true;

8256

8258 break;

8259 }

8260 return false;

8261 }

8262

8263

8264

8267

8268 YieldsPoison.insert(V);

8270

8271 while (true) {

8272 for (const auto &I : make_range(Begin, End)) {

8273 if (--ScanLimit == 0)

8274 return false;

8276 return true;

8278 return false;

8279

8280

8281 for (const Use &Op : I.operands()) {

8283 YieldsPoison.insert(&I);

8284 break;

8285 }

8286 }

8287

8288

8289

8290

8291 if (I.getOpcode() == Instruction::Select &&

8292 YieldsPoison.count(I.getOperand(1)) &&

8293 YieldsPoison.count(I.getOperand(2))) {

8294 YieldsPoison.insert(&I);

8295 }

8296 }

8297

8299 if (!BB || !Visited.insert(BB).second)

8300 break;

8301

8303 End = BB->end();

8304 }

8305 return false;

8306}

8307

8309 return ::programUndefinedIfUndefOrPoison(Inst, false);

8310}

8311

8313 return ::programUndefinedIfUndefOrPoison(Inst, true);

8314}

8315

8318 return true;

8319

8321 return ->isNaN();

8322

8324 if (->getElementType()->isFloatingPointTy())

8325 return false;

8326 for (unsigned I = 0, E = C->getNumElements(); I < E; ++I) {

8327 if (C->getElementAsAPFloat(I).isNaN())

8328 return false;

8329 }

8330 return true;

8331 }

8332

8334 return true;

8335

8336 return false;

8337}

8338

8341 return ->isZero();

8342

8344 if (->getElementType()->isFloatingPointTy())

8345 return false;

8346 for (unsigned I = 0, E = C->getNumElements(); I < E; ++I) {

8347 if (C->getElementAsAPFloat(I).isZero())

8348 return false;

8349 }

8350 return true;

8351 }

8352

8353 return false;

8354}

8355

8356

8357

8358

8359

8364

8365

8366

8367

8368

8369

8370 if (CmpRHS == FalseVal) {

8373 }

8374

8375

8376 LHS = TrueVal;

8377 RHS = FalseVal;

8378

8382

8384 switch (Pred) {

8390 *FC1 < *FC2)

8392 break;

8398 *FC1 > *FC2)

8400 break;

8401 default:

8402 break;

8403 }

8404

8406}

8407

8408

8409

8413

8414 if (CmpRHS != TrueVal) {

8417 }

8418 const APInt *C1;

8419 if (CmpRHS == TrueVal && match(CmpRHS, m_APInt(C1))) {

8420 const APInt *C2;

8421

8425

8426

8430

8431

8435

8436

8440 }

8442}

8443

8444

8445

8449 unsigned Depth) {

8450

8452

8453 Value *A = nullptr, *B = nullptr;

8457

8458 Value *C = nullptr, *D = nullptr;

8460 if (L.Flavor != R.Flavor)

8462

8463

8464

8465

8466 switch (L.Flavor) {

8471 }

8473 break;

8479 }

8481 break;

8487 }

8489 break;

8495 }

8497 break;

8499 default:

8501 }

8502

8503

8504

8505

8506

8507

8508

8509 if (D == B) {

8512 return {L.Flavor, SPNB_NA, false};

8513 }

8514

8515

8516 if (C == B) {

8519 return {L.Flavor, SPNB_NA, false};

8520 }

8521

8522

8523 if (D == A) {

8526 return {L.Flavor, SPNB_NA, false};

8527 }

8528

8529

8530 if (C == A) {

8533 return {L.Flavor, SPNB_NA, false};

8534 }

8535

8537}

8538

8539

8540

8541

8545 return NotV;

8546

8549 return ConstantInt::get(V->getType(), ~(*C));

8550

8551 return nullptr;

8552}

8553

8554

8559 unsigned Depth) {

8560

8561 LHS = TrueVal;

8562 RHS = FalseVal;

8563

8566 return SPR;

8567

8570 return SPR;

8571

8572

8573

8574

8576 switch (Pred) {

8581 default: break;

8582 }

8583 }

8584

8585

8586

8588 switch (Pred) {

8593 default: break;

8594 }

8595 }

8596

8599

8600 const APInt *C1;

8603

8604

8605 const APInt *C2;

8606 if ((CmpLHS == TrueVal && match(FalseVal, m_APInt(C2))) ||

8607 (CmpLHS == FalseVal && match(TrueVal, m_APInt(C2)))) {

8608

8609

8610

8613

8614

8615

8616

8619 }

8620

8622}

8623

8625 bool AllowPoison) {

8626 assert(X && Y && "Invalid operand");

8627

8628 auto IsNegationOf = [&](const Value *X, const Value *Y) {

8630 return false;

8631

8633 if (NeedNSW && !BO->hasNoSignedWrap())

8634 return false;

8635

8637 if (!AllowPoison && !Zero->isNullValue())

8638 return false;

8639

8640 return true;

8641 };

8642

8643

8644 if (IsNegationOf(X, Y) || IsNegationOf(Y, X))

8645 return true;

8646

8647

8653}

8654

8656

8661 return false;

8662

8663

8665 return false;

8666

8667 if (B == C)

8669

8670

8671 const APInt *RHSC1, *RHSC2;

8673 return false;

8674

8675

8677 return false;

8678

8681

8682 return CR1.inverse() == CR2;

8683}

8684

8687 bool Ordered) {

8688 switch (Pred) {

8689 default:

8707 return {SPF_FMAXNUM, NaNBehavior, Ordered};

8712 return {SPF_FMINNUM, NaNBehavior, Ordered};

8713 }

8714}

8715

8716std::optional<std::pair<CmpPredicate, Constant *>>

8719 "Only for relational integer predicates.");

8721 return std::nullopt;

8722

8725

8727 bool WillIncrement =

8729

8730

8731

8732 auto ConstantIsOk = [WillIncrement, IsSigned](ConstantInt *C) {

8733 return WillIncrement ? ->isMaxValue(IsSigned) : ->isMinValue(IsSigned);

8734 };

8735

8736 Constant *SafeReplacementConstant = nullptr;

8738

8739 if (!ConstantIsOk(CI))

8740 return std::nullopt;

8742 unsigned NumElts = FVTy->getNumElements();

8743 for (unsigned i = 0; i != NumElts; ++i) {

8744 Constant *Elt = C->getAggregateElement(i);

8745 if (!Elt)

8746 return std::nullopt;

8747

8749 continue;

8750

8751

8752

8754 if (!CI || !ConstantIsOk(CI))

8755 return std::nullopt;

8756

8757 if (!SafeReplacementConstant)

8758 SafeReplacementConstant = CI;

8759 }

8761

8762 Value *SplatC = C->getSplatValue();

8764

8765 if (!CI || !ConstantIsOk(CI))

8766 return std::nullopt;

8767 } else {

8768

8769 return std::nullopt;

8770 }

8771

8772

8773

8774

8775

8776 if (C->containsUndefOrPoisonElement()) {

8777 assert(SafeReplacementConstant && "Replacement constant not set");

8779 }

8780

8782

8783

8784 Constant *OneOrNegOne = ConstantInt::get(Type, WillIncrement ? 1 : -1, true);

8786

8787 return std::make_pair(NewPred, NewC);

8788}

8789

8795 unsigned Depth) {

8796 bool HasMismatchedZeros = false;

8798

8799

8800

8801

8802 Value *OutputZeroVal = nullptr;

8804 cast<Constant> (TrueVal)->containsUndefOrPoisonElement())

8805 OutputZeroVal = TrueVal;

8807 cast<Constant> (FalseVal)->containsUndefOrPoisonElement())

8808 OutputZeroVal = FalseVal;

8809

8810 if (OutputZeroVal) {

8811 if (match(CmpLHS, m_AnyZeroFP()) && CmpLHS != OutputZeroVal) {

8812 HasMismatchedZeros = true;

8813 CmpLHS = OutputZeroVal;

8814 }

8815 if (match(CmpRHS, m_AnyZeroFP()) && CmpRHS != OutputZeroVal) {

8816 HasMismatchedZeros = true;

8817 CmpRHS = OutputZeroVal;

8818 }

8819 }

8820 }

8821

8822 LHS = CmpLHS;

8823 RHS = CmpRHS;

8824

8825

8826

8827

8828

8829

8830 switch (Pred) {

8831 default: break;

8834 if (!HasMismatchedZeros)

8835 break;

8836 [[fallthrough]];

8842 }

8843

8845 bool Ordered = false;

8846

8847

8848

8849

8850

8851

8855

8856 if (LHSSafe && RHSSafe) {

8857

8861

8862

8863 Ordered = true;

8864 if (LHSSafe)

8865

8867 else if (RHSSafe)

8869 else

8870

8872 } else {

8873 Ordered = false;

8874

8875

8876 if (LHSSafe)

8877

8879 else if (RHSSafe)

8881 else

8882

8884 }

8885 }

8886

8887 if (TrueVal == CmpRHS && FalseVal == CmpLHS) {

8894 Ordered = !Ordered;

8895 }

8896

8897

8898 if (TrueVal == CmpLHS && FalseVal == CmpRHS)

8900

8902

8903

8904 auto MaybeSExtCmpLHS =

8908 if (match(TrueVal, MaybeSExtCmpLHS)) {

8909

8910

8911 LHS = TrueVal;

8912 RHS = FalseVal;

8915

8916

8917

8920

8921

8924

8925

8926

8929 }

8930 else if (match(FalseVal, MaybeSExtCmpLHS)) {

8931

8932

8933 LHS = FalseVal;

8934 RHS = TrueVal;

8937

8938

8939

8942

8943

8944

8947 }

8948 }

8949

8952

8953

8954

8955

8960

8962}

8963

8967

8968 Constant *CastedTo = nullptr;

8969 switch (*CastOp) {

8970 case Instruction::ZExt:

8973 break;

8974 case Instruction::SExt:

8977 break;

8978 case Instruction::Trunc:

8981 CmpConst->getType() == SrcTy) {

8982

8983

8984

8985

8986

8987

8988

8989

8990

8991

8992

8993

8994

8995

8996

8997

8998

8999

9000

9001

9002

9003 CastedTo = CmpConst;

9004 } else {

9005 unsigned ExtOp = CmpI->isSigned() ? Instruction::SExt : Instruction::ZExt;

9007 }

9008 break;

9009 case Instruction::FPTrunc:

9011 break;

9012 case Instruction::FPExt:

9014 break;

9015 case Instruction::FPToUI:

9017 break;

9018 case Instruction::FPToSI:

9020 break;

9021 case Instruction::UIToFP:

9023 break;

9024 case Instruction::SIToFP:

9026 break;

9027 default:

9028 break;

9029 }

9030

9031 if (!CastedTo)

9032 return nullptr;

9033

9034

9037 if (CastedBack && CastedBack != C)

9038 return nullptr;

9039

9040 return CastedTo;

9041}

9042

9043

9044

9045

9046

9047

9048

9049

9050

9051

9052

9053

9054

9055

9056

9057

9058

9062 if (!Cast1)

9063 return nullptr;

9064

9065 *CastOp = Cast1->getOpcode();

9066 Type *SrcTy = Cast1->getSrcTy();

9068

9069 if (*CastOp == Cast2->getOpcode() && SrcTy == Cast2->getSrcTy())

9070 return Cast2->getOperand(0);

9071 return nullptr;

9072 }

9073

9075 if (C)

9077

9078 Value *CastedTo = nullptr;

9079 if (*CastOp == Instruction::Trunc) {

9081

9082

9083

9084

9085

9086

9087

9088

9089

9090

9091

9093 "V2 and Cast1 should be the same type.");

9095 }

9096 }

9097

9098 return CastedTo;

9099}

9102 unsigned Depth) {

9105

9108

9111

9112 Value *TrueVal = SI->getTrueValue();

9113 Value *FalseVal = SI->getFalseValue();

9114

9116 CmpI, TrueVal, FalseVal, LHS, RHS,

9119}

9120

9129

9130

9133

9134

9135 if (CastOp && CmpLHS->getType() != TrueVal->getType()) {

9137

9138

9139 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)

9141 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,

9143 LHS, RHS, Depth);

9144 }

9146

9147

9148 if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)

9150 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,

9152 LHS, RHS, Depth);

9153 }

9154 }

9155 return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal,

9156 LHS, RHS, Depth);

9157}

9158

9170

9172 switch (SPF) {

9174 return Intrinsic::umin;

9176 return Intrinsic::umax;

9178 return Intrinsic::smin;

9180 return Intrinsic::smax;

9181 default:

9183 }

9184}

9185

9193

9195 switch (MinMaxID) {

9196 case Intrinsic::smax: return Intrinsic::smin;

9197 case Intrinsic::smin: return Intrinsic::smax;

9198 case Intrinsic::umax: return Intrinsic::umin;

9199 case Intrinsic::umin: return Intrinsic::umax;

9200

9201

9202 case Intrinsic::maximum: return Intrinsic::minimum;

9203 case Intrinsic::minimum: return Intrinsic::maximum;

9204 case Intrinsic::maxnum: return Intrinsic::minnum;

9205 case Intrinsic::minnum: return Intrinsic::maxnum;

9206 case Intrinsic::maximumnum:

9207 return Intrinsic::minimumnum;

9208 case Intrinsic::minimumnum:

9209 return Intrinsic::maximumnum;

9211 }

9212}

9213

9215 switch (SPF) {

9221 }

9222}

9223

9224std::pair<Intrinsic::ID, bool>

9226

9227

9228

9229 bool AllCmpSingleUse = true;

9232 if (all_of(VL, [&SelectPattern, &AllCmpSingleUse](Value *I) {

9233 Value *LHS, *RHS;

9236 return false;

9238 SelectPattern.Flavor != CurrentPattern.Flavor)

9239 return false;

9240 SelectPattern = CurrentPattern;

9241 AllCmpSingleUse &=

9243 return true;

9244 })) {

9245 switch (SelectPattern.Flavor) {

9247 return {Intrinsic::smin, AllCmpSingleUse};

9249 return {Intrinsic::umin, AllCmpSingleUse};

9251 return {Intrinsic::smax, AllCmpSingleUse};

9253 return {Intrinsic::umax, AllCmpSingleUse};

9255 return {Intrinsic::maxnum, AllCmpSingleUse};

9257 return {Intrinsic::minnum, AllCmpSingleUse};

9258 default:

9260 }

9261 }

9263}

9264

9265template

9268

9269

9270

9271

9273 return false;

9274

9275 for (unsigned I = 0; I != 2; ++I) {

9280 if (LHS != PN && RHS != PN)

9281 continue;

9282

9285 OtherOp = (LHS == PN) ? RHS : LHS;

9286 return true;

9287 }

9288 }

9289 return false;

9290}

9291

9294

9295

9296

9297

9298

9299

9301}

9302

9311

9314 Value *&OtherOp) {

9315

9316 if (I->arg_size() != 2 || I->getType() != I->getArgOperand(0)->getType() ||

9317 I->getType() != I->getArgOperand(1)->getType())

9318 return false;

9319

9322 if ()

9324

9326}

9327

9328

9332 return true;

9333

9334 switch (Pred) {

9335 default:

9336 return false;

9337

9340

9341

9342

9345 return ->isNegative();

9346

9347

9349 return true;

9350

9351

9353 return true;

9354

9355

9357 const APInt *CLHS, *CRHS;

9360 return CLHS->sle(*CRHS);

9361

9362 return false;

9363 }

9364

9366

9369 return true;

9370

9371

9373 return true;

9374

9375

9377 return true;

9378

9379

9381 return true;

9382

9383

9386 return true;

9387

9388

9390 return true;

9391

9392

9394 return true;

9395

9396

9398 const APInt *CLHS, *CRHS;

9401 return CLHS->ule(*CRHS);

9402

9403 return false;

9404 }

9405 }

9406}

9407

9408

9409

9410static std::optional

9412 const Value *ARHS, const Value *BLHS, const Value *BRHS) {

9413 switch (Pred) {

9414 default:

9415 return std::nullopt;

9416

9421 return true;

9422 return std::nullopt;

9423

9428 return true;

9429 return std::nullopt;

9430

9435 return true;

9436 return std::nullopt;

9437

9442 return true;

9443 return std::nullopt;

9444 }

9445}

9446

9447

9448

9449

9450static std::optional

9455

9456 if (CR.icmp(Pred, RCR))

9457 return true;

9458

9459

9461 return false;

9462

9463 return std::nullopt;

9464 };

9466 RPred))

9467 return Res;

9474 RPred);

9475 }

9476 return std::nullopt;

9477}

9478

9479

9480

9481

9482static std::optional

9486

9487

9488 if (!LHSIsTrue)

9490

9491

9492

9493 if (L0 == R1) {

9496 }

9497 if (R0 == L1) {

9500 }

9501 if (L1 == R1) {

9502

9508 }

9509 }

9510

9511

9512

9513 const APInt *Unused;

9515

9516

9517

9518

9520 L1, ICmpInst::isSigned(LPred), true, nullptr,

9523 R1, ICmpInst::isSigned(RPred), true, nullptr,

9525

9526

9528 return R;

9529

9530

9532 return std::nullopt;

9533 }

9534

9535

9536 if (L0 == R0 && L1 == R1)

9538

9539

9540

9541

9542

9549 return false;

9550 }

9551

9552

9553

9559 return true;

9560 }

9561

9562

9563

9564 const APInt *L1C;

9569 ((A == R0 && B == R1) || (A == R1 && B == R0) ||

9575 }

9576

9577

9578 if (L0 == R0 &&

9583

9586

9587 return std::nullopt;

9588}

9589

9590

9591

9592

9593static std::optional

9597

9598

9599 if (!LHSIsTrue)

9601

9602

9603

9604 if (L0 == R1) {

9607 }

9608 if (R0 == L1) {

9611 }

9612 if (L1 == R1) {

9613

9619 }

9620 }

9621

9622

9623 if (L0 == R0 && L1 == R1) {

9624 if ((LPred & RPred) == LPred)

9625 return true;

9626 if ((LPred & ~RPred) == LPred)

9627 return false;

9628 }

9629

9630

9631

9632 const APFloat *L1C, *R1C;

9634 if (std::optional DomCR =

9636 if (std::optional ImpliedCR =

9638 if (ImpliedCR->contains(*DomCR))

9639 return true;

9640 }

9641 if (std::optional ImpliedCR =

9644 if (ImpliedCR->contains(*DomCR))

9645 return false;

9646 }

9647 }

9648 }

9649

9650 return std::nullopt;

9651}

9652

9653

9654

9655

9656

9657static std::optional

9659 const Value *RHSOp0, const Value *RHSOp1,

9661

9662 assert((LHS->getOpcode() == Instruction::And ||

9663 LHS->getOpcode() == Instruction::Or ||

9664 LHS->getOpcode() == Instruction::Select) &&

9665 "Expected LHS to be 'and', 'or', or 'select'.");

9666

9668

9669

9670

9671

9672 const Value *ALHS, *ARHS;

9675

9677 ALHS, RHSPred, RHSOp0, RHSOp1, DL, LHSIsTrue, Depth + 1))

9678 return Implication;

9680 ARHS, RHSPred, RHSOp0, RHSOp1, DL, LHSIsTrue, Depth + 1))

9681 return Implication;

9682 return std::nullopt;

9683 }

9684 return std::nullopt;

9685}

9686

9687std::optional

9689 const Value *RHSOp0, const Value *RHSOp1,

9691

9693 return std::nullopt;

9694

9695

9696

9697 if (RHSOp0->getType()->isVectorTy() != LHS->getType()->isVectorTy())

9698 return std::nullopt;

9699

9700 assert(LHS->getType()->isIntOrIntVectorTy(1) &&

9701 "Expected integer type only!");

9702

9703

9705 LHSIsTrue = !LHSIsTrue;

9706

9707

9711 LHSCmp->getOperand(0), LHSCmp->getOperand(1),

9712 RHSPred, RHSOp0, RHSOp1, DL, LHSIsTrue);

9716 ConstantInt::get(V->getType(), 0), RHSPred,

9717 RHSOp0, RHSOp1, DL, LHSIsTrue);

9718 } else {

9720 "Expected floating point type only!");

9722 return isImpliedCondFCmps(LHSCmp->getPredicate(), LHSCmp->getOperand(0),

9723 LHSCmp->getOperand(1), RHSPred, RHSOp0, RHSOp1,

9724 DL, LHSIsTrue);

9725 }

9726

9727

9728

9729

9731 if ((LHSI->getOpcode() == Instruction::And ||

9732 LHSI->getOpcode() == Instruction::Or ||

9733 LHSI->getOpcode() == Instruction::Select))

9736 }

9737 return std::nullopt;

9738}

9739

9742 bool LHSIsTrue, unsigned Depth) {

9743

9744 if (LHS == RHS)

9745 return LHSIsTrue;

9746

9747

9748 bool InvertRHS = false;

9750 if (LHS == RHS)

9751 return !LHSIsTrue;

9752 InvertRHS = true;

9753 }

9754

9757 LHS, RHSCmp->getCmpPredicate(), RHSCmp->getOperand(0),

9758 RHSCmp->getOperand(1), DL, LHSIsTrue, Depth))

9759 return InvertRHS ? !*Implied : *Implied;

9760 return std::nullopt;

9761 }

9764 LHS, RHSCmp->getPredicate(), RHSCmp->getOperand(0),

9765 RHSCmp->getOperand(1), DL, LHSIsTrue, Depth))

9766 return InvertRHS ? !*Implied : *Implied;

9767 return std::nullopt;

9768 }

9769

9773 ConstantInt::get(V->getType(), 0), DL,

9774 LHSIsTrue, Depth))

9775 return InvertRHS ? !*Implied : *Implied;

9776 return std::nullopt;

9777 }

9778

9780 return std::nullopt;

9781

9782

9783

9784 const Value *RHS1, *RHS2;

9786 if (std::optional Imp =

9788 if (*Imp == true)

9789 return !InvertRHS;

9790 if (std::optional Imp =

9792 if (*Imp == true)

9793 return !InvertRHS;

9794 }

9796 if (std::optional Imp =

9798 if (*Imp == false)

9799 return InvertRHS;

9800 if (std::optional Imp =

9802 if (*Imp == false)

9803 return InvertRHS;

9804 }

9805

9806 return std::nullopt;

9807}

9808

9809

9810

9811static std::pair<Value *, bool>

9813 if (!ContextI || !ContextI->getParent())

9814 return {nullptr, false};

9815

9816

9817

9820 if (!PredBB)

9821 return {nullptr, false};

9822

9823

9824 Value *PredCond;

9827 return {nullptr, false};

9828

9829

9830 if (TrueBB == FalseBB)

9831 return {nullptr, false};

9832

9833 assert((TrueBB == ContextBB || FalseBB == ContextBB) &&

9834 "Predecessor block does not point to successor?");

9835

9836

9837 return {PredCond, TrueBB == ContextBB};

9838}

9839

9843 assert(Cond->getType()->isIntOrIntVectorTy(1) && "Condition must be bool");

9845 if (PredCond.first)

9847 return std::nullopt;

9848}

9849

9851 const Value *LHS,

9852 const Value *RHS,

9856 if (PredCond.first)

9858 PredCond.second);

9859 return std::nullopt;

9860}

9861

9864 bool PreferSignedRange) {

9865 unsigned Width = Lower.getBitWidth();

9868 case Instruction::Sub:

9872

9873

9874

9875

9876

9877

9878 if (PreferSignedRange && HasNSW && HasNUW)

9879 HasNUW = false;

9880

9881 if (HasNUW) {

9882

9884 } else if (HasNSW) {

9885 if (C->isNegative()) {

9886

9889 } else {

9890

9891

9894 }

9895 }

9896 }

9897 break;

9898 case Instruction::Add:

9902

9903

9904

9905

9906

9907 if (PreferSignedRange && HasNSW && HasNUW)

9908 HasNUW = false;

9909

9910 if (HasNUW) {

9911

9913 } else if (HasNSW) {

9914 if (C->isNegative()) {

9915

9918 } else {

9919

9922 }

9923 }

9924 }

9925 break;

9926

9927 case Instruction::And:

9929

9931

9932

9936 break;

9937

9938 case Instruction::Or:

9940

9942 break;

9943

9944 case Instruction::AShr:

9946

9950 unsigned ShiftAmount = Width - 1;

9951 if (->isZero() && IIQ.isExact(&BO))

9952 ShiftAmount = C->countr_zero();

9953 if (C->isNegative()) {

9954

9956 Upper = C->ashr(ShiftAmount) + 1;

9957 } else {

9958

9959 Lower = C->ashr(ShiftAmount);

9961 }

9962 }

9963 break;

9964

9965 case Instruction::LShr:

9967

9970

9971 unsigned ShiftAmount = Width - 1;

9972 if (->isZero() && IIQ.isExact(&BO))

9973 ShiftAmount = C->countr_zero();

9974 Lower = C->lshr(ShiftAmount);

9976 }

9977 break;

9978

9979 case Instruction::Shl:

9982

9985 } else if (BO.hasNoSignedWrap()) {

9986 if (C->isNegative()) {

9987

9988 unsigned ShiftAmount = C->countl_one() - 1;

9989 Lower = C->shl(ShiftAmount);

9991 } else {

9992

9993 unsigned ShiftAmount = C->countl_zero() - 1;

9995 Upper = C->shl(ShiftAmount) + 1;

9996 }

9997 } else {

9998

9999 if ((*C)[0])

10001

10002

10003

10004

10005

10006

10008 }

10011 }

10012 break;

10013

10014 case Instruction::SDiv:

10018 if (C->isAllOnes()) {

10019

10020

10021 Lower = IntMin + 1;

10022 Upper = IntMax + 1;

10023 } else if (C->countl_zero() < Width - 1) {

10024

10025

10031 assert(Upper != Lower && "Upper part of range has wrapped!");

10032 }

10034 if (C->isMinSignedValue()) {

10035

10038 } else {

10039

10040 Upper = C->abs() + 1;

10042 }

10043 }

10044 break;

10045

10046 case Instruction::UDiv:

10048

10051

10053 }

10054 break;

10055

10056 case Instruction::SRem:

10058

10062 if (C->isNegative()) {

10063

10066 } else {

10067

10069 }

10070 }

10071 break;

10072

10073 case Instruction::URem:

10075

10078

10080 break;

10081

10082 default:

10083 break;

10084 }

10085}

10086

10088 bool UseInstrInfo) {

10089 unsigned Width = II.getType()->getScalarSizeInBits();

10091 switch (II.getIntrinsicID()) {

10092 case Intrinsic::ctlz:

10093 case Intrinsic::cttz: {

10095 if (!UseInstrInfo || match (II.getArgOperand(1), m_One()))

10097

10099 }

10100 case Intrinsic::ctpop:

10101

10103 APInt(Width, Width) + 1);

10104 case Intrinsic::uadd_sat:

10105

10109 break;

10110 case Intrinsic::sadd_sat:

10113 if (C->isNegative())

10114

10117 1);

10118

10119

10122 }

10123 break;

10124 case Intrinsic::usub_sat:

10125

10128

10129

10133 break;

10134 case Intrinsic::ssub_sat:

10136 if (C->isNegative())

10137

10140 1);

10141

10142

10146 if (C->isNegative())

10147

10150

10151

10154 1);

10155 }

10156 break;

10157 case Intrinsic::umin:

10158 case Intrinsic::umax:

10159 case Intrinsic::smin:

10160 case Intrinsic::smax:

10163 break;

10164

10165 switch (II.getIntrinsicID()) {

10166 case Intrinsic::umin:

10168 case Intrinsic::umax:

10170 case Intrinsic::smin:

10172 *C + 1);

10173 case Intrinsic::smax:

10176 default:

10178 }

10179 break;

10180 case Intrinsic::abs:

10181

10182

10186

10189 case Intrinsic::vscale:

10190 if (.getParent() || .getFunction())

10191 break;

10193 default:

10194 break;

10195 }

10196

10197 return ConstantRange::getFull(Width);

10198}

10199

10202 unsigned BitWidth = SI.getType()->getScalarSizeInBits();

10203 const Value *LHS = nullptr, *RHS = nullptr;

10206 return ConstantRange::getFull(BitWidth);

10207

10209

10210

10211

10216

10219 }

10220

10222

10225 }

10226

10229 return ConstantRange::getFull(BitWidth);

10230

10231 switch (R.Flavor) {

10238 *C + 1);

10242 default:

10243 return ConstantRange::getFull(BitWidth);

10244 }

10245}

10246

10248

10249

10250 unsigned BitWidth = I->getType()->getScalarSizeInBits();

10251 if (->getOperand(0)->getType()->getScalarType()->isHalfTy())

10252 return;

10256 }

10257

10259

10261 }

10262}

10263

10268 unsigned Depth) {

10269 assert(V->getType()->isIntOrIntVectorTy() && "Expected integer instruction");

10270

10272 return ConstantRange::getFull(V->getType()->getScalarSizeInBits());

10273

10275 return C->toConstantRange();

10276

10277 unsigned BitWidth = V->getType()->getScalarSizeInBits();

10283

10290 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT, Depth + 1);

10292 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT, Depth + 1);

10293 CR = CRTrue.unionWith(CRFalse);

10298

10302 if (std::optional Range = A->getRange())

10304

10308

10310 if (std::optional Range = CB->getRange())

10312 }

10313

10314 if (CtxI && AC) {

10315

10317 if (!AssumeVH)

10318 continue;

10320 assert(I->getParent()->getParent() == CtxI->getParent()->getParent() &&

10321 "Got assumption for the wrong function!");

10322 assert(I->getIntrinsicID() == Intrinsic::assume &&

10323 "must be an assume intrinsic");

10324

10326 continue;

10327 Value *Arg = I->getArgOperand(0);

10329

10330 if (!Cmp || Cmp->getOperand(0) != V)

10331 continue;

10332

10335 UseInstrInfo, AC, I, DT, Depth + 1);

10338 }

10339 }

10340

10341 return CR;

10342}

10343

10344static void

10347 assert(V != nullptr);

10349 InsertAffected(V);

10351 InsertAffected(V);

10352

10353

10357 InsertAffected(Op);

10358 }

10359 }

10360}

10361

10364 auto AddAffected = [&InsertAffected](Value *V) {

10366 };

10367

10368 auto AddCmpOperands = [&AddAffected, IsAssume](Value *LHS, Value *RHS) {

10369 if (IsAssume) {

10370 AddAffected(LHS);

10371 AddAffected(RHS);

10373 AddAffected(LHS);

10374 };

10375

10379 while (!Worklist.empty()) {

10381 if (!Visited.insert(V).second)

10382 continue;

10383

10386

10387 if (IsAssume) {

10388 AddAffected(V);

10390 AddAffected(X);

10391 }

10392

10394

10395

10396

10397

10398

10399 if (!IsAssume) {

10402 }

10406 AddAffected(A);

10407 if (IsAssume)

10408 AddAffected(B);

10409 if (HasRHSC) {

10411

10413 AddAffected(X);

10414

10417 AddAffected(X);

10418 AddAffected(Y);

10419 }

10420

10422 AddAffected(X);

10423 AddAffected(Y);

10424 }

10425 }

10426 } else {

10427 AddCmpOperands(A, B);

10428 if (HasRHSC) {

10429

10430

10432 AddAffected(X);

10433

10436

10437

10438

10442 AddAffected(X);

10443 AddAffected(Y);

10444 }

10445

10447 AddAffected(X);

10448 }

10449 }

10450

10451

10452

10455 InsertAffected(X);

10457 InsertAffected(X);

10458 }

10459 }

10460

10462 AddAffected(X);

10464 AddCmpOperands(A, B);

10465

10466

10467

10468

10470 AddAffected(A);

10472 AddAffected(A);

10473

10476

10477 AddAffected(A);

10479

10480

10481 AddAffected(X);

10483

10485 }

10486 }

10487}

10488

10490

10492 if (BO->getOpcode() == Instruction::Add ||

10493 BO->getOpcode() == Instruction::Or) {

10495 const APInt *C1, *C2;

10502 return X;

10503 }

10504 }

10505 return nullptr;

10506}

10507

10511

10514 unsigned MaxCount, bool AllowUndefOrPoison) {

10517 auto Push = [&](const Value *V) -> bool {

10521 return false;

10522

10523 if (Constants.contains(C))

10524 return true;

10525 if (Constants.size() == MaxCount)

10526 return false;

10527 Constants.insert(C);

10528 return true;

10529 }

10530

10532 if (Visited.insert(Inst).second)

10534 return true;

10535 }

10536 return false;

10537 };

10538 if (!Push(V))

10539 return false;

10540 while (!Worklist.empty()) {

10542 switch (CurInst->getOpcode()) {

10543 case Instruction::Select:

10545 return false;

10547 return false;

10548 break;

10549 case Instruction::PHI:

10550 for (Value *IncomingValue : cast(CurInst)->incoming_values()) {

10551

10552 if (IncomingValue == CurInst)

10553 continue;

10554 if (!Push(IncomingValue))

10555 return false;

10556 }

10557 break;

10558 default:

10559 return false;

10560 }

10561 }

10562 return true;

10563}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

AMDGPU Register Bank Select

This file declares a class to represent arbitrary precision floating point values and provide a varie...

This file implements a class to represent arbitrary precision integral constant values and operations...

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Function Alias Analysis Results

This file contains the simple types necessary to represent the attributes associated with functions a...

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

This file contains the declarations for the subclasses of Constant, which represent the different fla...

Utilities for dealing with flags related to floating point properties and mode controls.

static Value * getCondition(Instruction *I)

Module.h This file contains the declarations for the Module class.

static bool hasNoUnsignedWrap(BinaryOperator &I)

ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))

uint64_t IntrinsicInst * II

PowerPC Reduce CR logical Operation

const SmallVectorImpl< MachineOperand > & Cond

static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))

std::pair< BasicBlock *, BasicBlock * > Edge

This file defines the make_scope_exit function, which executes user-defined cleanup logic at scope ex...

This file defines the SmallPtrSet class.

This file defines the SmallVector class.

static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")

static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")

static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)

Returns the opcode of Values or ~0 if they do not all agree.

static SmallVector< VPValue *, 4 > getOperands(ArrayRef< VPValue * > Values, unsigned OperandIndex)

static void computeKnownFPClassFromCond(const Value *V, Value *Cond, bool CondIsTrue, const Instruction *CxtI, KnownFPClass &KnownFromContext, unsigned Depth=0)

Definition ValueTracking.cpp:4773

static bool isPowerOfTwoRecurrence(const PHINode *PN, bool OrZero, SimplifyQuery &Q, unsigned Depth)

Try to detect a recurrence that the value of the induction variable is always a power of two (or zero...

Definition ValueTracking.cpp:2545

static cl::opt< unsigned > DomConditionsMaxUses("dom-conditions-max-uses", cl::Hidden, cl::init(20))

static unsigned computeNumSignBitsVectorConstant(const Value *V, const APInt &DemandedElts, unsigned TyBits)

For vector constants, loop over the elements and find the constant with the minimum number of sign bi...

Definition ValueTracking.cpp:4172

static bool isTruePredicate(CmpInst::Predicate Pred, const Value *LHS, const Value *RHS)

Return true if "icmp Pred LHS RHS" is always true.

Definition ValueTracking.cpp:9329

static bool isModifyingBinopOfNonZero(const Value *V1, const Value *V2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)

Return true if V1 == (binop V2, X), where X is known non-zero.

Definition ValueTracking.cpp:3875

static bool isGEPKnownNonNull(const GEPOperator *GEP, const SimplifyQuery &Q, unsigned Depth)

Test whether a GEP's result is known to be non-null.

Definition ValueTracking.cpp:2825

static bool isNonEqualShl(const Value *V1, const Value *V2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)

Return true if V2 == V1 << C, where V1 is known non-zero, C is not 0 and the shift is nuw or nsw.

Definition ValueTracking.cpp:3919

static bool isKnownNonNullFromDominatingCondition(const Value *V, const Instruction *CtxI, const DominatorTree *DT)

Definition ValueTracking.cpp:2889

static const Value * getUnderlyingObjectFromInt(const Value *V)

This is the function that does the work of looking through basic ptrtoint+arithmetic+inttoptr sequenc...

Definition ValueTracking.cpp:6983

static bool isNonZeroMul(const APInt &DemandedElts, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW, unsigned Depth)

Definition ValueTracking.cpp:3102

static bool rangeMetadataExcludesValue(const MDNode *Ranges, const APInt &Value)

Does the 'Range' metadata (which must be a valid MD_range operand list) ensure that the value it's at...

Definition ValueTracking.cpp:2988

static bool outputDenormalIsIEEEOrPosZero(const Function &F, const Type *Ty)

Definition ValueTracking.cpp:4728

static KnownBits getKnownBitsFromAndXorOr(const Operator *I, const APInt &DemandedElts, const KnownBits &KnownLHS, const KnownBits &KnownRHS, const SimplifyQuery &Q, unsigned Depth)

Definition ValueTracking.cpp:1169

static void breakSelfRecursivePHI(const Use *U, const PHINode *PHI, Value *&ValOut, Instruction *&CtxIOut, const PHINode **PhiOut=nullptr)

Definition ValueTracking.cpp:783

static bool isNonZeroSub(const APInt &DemandedElts, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, unsigned Depth)

Definition ValueTracking.cpp:3086

static OverflowResult mapOverflowResult(ConstantRange::OverflowResult OR)

Convert ConstantRange OverflowResult into ValueTracking OverflowResult.

Definition ValueTracking.cpp:7258

static void addValueAffectedByCondition(Value *V, function_ref< void(Value *)> InsertAffected)

Definition ValueTracking.cpp:10345

static unsigned getBitWidth(Type *Ty, const DataLayout &DL)

Returns the bitwidth of the given scalar or pointer type.

Definition ValueTracking.cpp:99

static bool haveNoCommonBitsSetSpecialCases(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)

Definition ValueTracking.cpp:179

static void setLimitsForBinOp(const BinaryOperator &BO, APInt &Lower, APInt &Upper, const InstrInfoQuery &IIQ, bool PreferSignedRange)

Definition ValueTracking.cpp:9862

static Value * lookThroughCast(CmpInst *CmpI, Value *V1, Value *V2, Instruction::CastOps *CastOp)

Helps to match a select pattern in case of a type mismatch.

Definition ValueTracking.cpp:9059

static std::pair< Value *, bool > getDomPredecessorCondition(const Instruction *ContextI)

Definition ValueTracking.cpp:9812

static constexpr unsigned MaxInstrsToCheckForFree

Maximum number of instructions to check between assume and context instruction.

Definition ValueTracking.cpp:95

static bool isNonZeroShift(const Operator *I, const APInt &DemandedElts, const SimplifyQuery &Q, const KnownBits &KnownVal, unsigned Depth)

Definition ValueTracking.cpp:3130

static std::optional< bool > isImpliedCondFCmps(FCmpInst::Predicate LPred, const Value *L0, const Value *L1, FCmpInst::Predicate RPred, const Value *R0, const Value *R1, const DataLayout &DL, bool LHSIsTrue)

Return true if LHS implies RHS (expanded to its components as "R0 RPred R1") is true.

Definition ValueTracking.cpp:9594

UndefPoisonKind

Definition ValueTracking.cpp:7545

@ UndefOnly

Definition ValueTracking.cpp:7547

@ UndefOrPoison

Definition ValueTracking.cpp:7548

@ PoisonOnly

Definition ValueTracking.cpp:7546

static bool isKnownNonEqualFromContext(const Value *V1, const Value *V2, const SimplifyQuery &Q, unsigned Depth)

Definition ValueTracking.cpp:4034

static bool includesPoison(UndefPoisonKind Kind)

Definition ValueTracking.cpp:7551

static SelectPatternResult matchFastFloatClamp(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS)

Match clamp pattern for float types without care about NaNs or signed zeros.

Definition ValueTracking.cpp:8360

static std::optional< bool > isImpliedCondICmps(CmpPredicate LPred, const Value *L0, const Value *L1, CmpPredicate RPred, const Value *R0, const Value *R1, const DataLayout &DL, bool LHSIsTrue)

Return true if LHS implies RHS (expanded to its components as "R0 RPred R1") is true.

Definition ValueTracking.cpp:9483

static bool includesUndef(UndefPoisonKind Kind)

Definition ValueTracking.cpp:7555

static std::optional< bool > isImpliedCondCommonOperandWithCR(CmpPredicate LPred, const ConstantRange &LCR, CmpPredicate RPred, const ConstantRange &RCR)

Return true if "icmp LPred X, LCR" implies "icmp RPred X, RCR" is true.

Definition ValueTracking.cpp:9451

static ConstantRange getRangeForSelectPattern(const SelectInst &SI, const InstrInfoQuery &IIQ)

Definition ValueTracking.cpp:10200

static void computeKnownBitsFromOperator(const Operator *I, const APInt &DemandedElts, KnownBits &Known, const SimplifyQuery &Q, unsigned Depth)

Definition ValueTracking.cpp:1390

static uint64_t GetStringLengthH(const Value *V, SmallPtrSetImpl< const PHINode * > &PHIs, unsigned CharSize)

If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.

Definition ValueTracking.cpp:6704

static void computeKnownBitsFromShiftOperator(const Operator *I, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, const SimplifyQuery &Q, unsigned Depth, function_ref< KnownBits(const KnownBits &, const KnownBits &, bool)> KF)

Compute known bits from a shift operator, including those with a non-constant shift amount.

Definition ValueTracking.cpp:1153

static bool onlyUsedByLifetimeMarkersOrDroppableInstsHelper(const Value *V, bool AllowLifetime, bool AllowDroppable)

Definition ValueTracking.cpp:7090

static std::optional< bool > isImpliedCondAndOr(const Instruction *LHS, CmpPredicate RHSPred, const Value *RHSOp0, const Value *RHSOp1, const DataLayout &DL, bool LHSIsTrue, unsigned Depth)

Return true if LHS implies RHS is true.

Definition ValueTracking.cpp:9658

static bool isSignedMinMaxClamp(const Value *Select, const Value *&In, const APInt *&CLow, const APInt *&CHigh)

Definition ValueTracking.cpp:1334

static bool isNonZeroAdd(const APInt &DemandedElts, const SimplifyQuery &Q, unsigned BitWidth, Value *X, Value *Y, bool NSW, bool NUW, unsigned Depth)

Definition ValueTracking.cpp:3040

static bool directlyImpliesPoison(const Value *ValAssumedPoison, const Value *V, unsigned Depth)

Definition ValueTracking.cpp:7656

static bool isNonEqualSelect(const Value *V1, const Value *V2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)

Definition ValueTracking.cpp:3962

static bool matchTwoInputRecurrence(const PHINode *PN, InstTy *&Inst, Value *&Init, Value *&OtherOp)

Definition ValueTracking.cpp:9266

static bool isNonEqualPHIs(const PHINode *PN1, const PHINode *PN2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)

Definition ValueTracking.cpp:3931

static void computeKnownBitsFromCmp(const Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS, KnownBits &Known, const SimplifyQuery &Q)

Definition ValueTracking.cpp:865

static SelectPatternResult matchMinMaxOfMinMax(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TVal, Value *FVal, unsigned Depth)

Recognize variations of: a < c ?

Definition ValueTracking.cpp:8446

static void unionWithMinMaxIntrinsicClamp(const IntrinsicInst *II, KnownBits &Known)

Definition ValueTracking.cpp:1382

static void setLimitForFPToI(const Instruction *I, APInt &Lower, APInt &Upper)

Definition ValueTracking.cpp:10247

static bool isSameUnderlyingObjectInLoop(const PHINode *PN, const LoopInfo *LI)

PN defines a loop-variant pointer to an object.

Definition ValueTracking.cpp:6825

static bool isNonEqualPointersWithRecursiveGEP(const Value *A, const Value *B, const SimplifyQuery &Q)

Definition ValueTracking.cpp:3987

static bool isSignedMinMaxIntrinsicClamp(const IntrinsicInst *II, const APInt *&CLow, const APInt *&CHigh)

Definition ValueTracking.cpp:1363

static Value * lookThroughCastConst(CmpInst *CmpI, Type *SrcTy, Constant *C, Instruction::CastOps *CastOp)

Definition ValueTracking.cpp:8964

static bool handleGuaranteedWellDefinedOps(const Instruction *I, const CallableT &Handle)

Enumerates all operands of I that are guaranteed to not be undef or poison.

Definition ValueTracking.cpp:8130

static void computeKnownBitsFromLerpPattern(const Value *Op0, const Value *Op1, const APInt &DemandedElts, KnownBits &KnownOut, const SimplifyQuery &Q, unsigned Depth)

Try to detect the lerp pattern: a * (b - c) + c * d where a >= 0, b >= 0, c >= 0, d >= 0,...

Definition ValueTracking.cpp:372

static KnownFPClass computeKnownFPClassFromContext(const Value *V, const SimplifyQuery &Q)

Definition ValueTracking.cpp:4819

static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1, bool NSW, bool NUW, const APInt &DemandedElts, KnownBits &KnownOut, KnownBits &Known2, const SimplifyQuery &Q, unsigned Depth)

Definition ValueTracking.cpp:486

static Value * getNotValue(Value *V)

If the input value is the result of a 'not' op, constant integer, or vector splat of a constant integ...

Definition ValueTracking.cpp:8542

static unsigned ComputeNumSignBitsImpl(const Value *V, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)

Return the number of times the sign bit of the register is replicated into the other bits.

Definition ValueTracking.cpp:4213

static void computeKnownBitsFromICmpCond(const Value *V, ICmpInst *Cmp, KnownBits &Known, const SimplifyQuery &SQ, bool Invert)

Definition ValueTracking.cpp:971

static bool isKnownNonZeroFromOperator(const Operator *I, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)

Definition ValueTracking.cpp:3181

static bool matchOpWithOpEqZero(Value *Op0, Value *Op1)

Definition ValueTracking.cpp:3033

static bool isNonZeroRecurrence(const PHINode *PN)

Try to detect a recurrence that monotonically increases/decreases from a non-zero starting value.

Definition ValueTracking.cpp:3005

static SelectPatternResult matchClamp(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal)

Recognize variations of: CLAMP(v,l,h) ==> ((v) < (l) ?

Definition ValueTracking.cpp:8410

static bool shiftAmountKnownInRange(const Value *ShiftAmount)

Shifts return poison if shiftwidth is larger than the bitwidth.

Definition ValueTracking.cpp:7521

static bool isEphemeralValueOf(const Instruction *I, const Value *E)

Definition ValueTracking.cpp:608

static SelectPatternResult matchMinMax(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, unsigned Depth)

Match non-obvious integer minimum and maximum sequences.

Definition ValueTracking.cpp:8555

static KnownBits computeKnownBitsForHorizontalOperation(const Operator *I, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth, const function_ref< KnownBits(const KnownBits &, const KnownBits &)> KnownBitsFunc)

Definition ValueTracking.cpp:1239

static bool handleGuaranteedNonPoisonOps(const Instruction *I, const CallableT &Handle)

Enumerates all operands of I that are guaranteed to not be poison.

Definition ValueTracking.cpp:8192

static std::optional< std::pair< Value *, Value * > > getInvertibleOperands(const Operator *Op1, const Operator *Op2)

If the pair of operators are the same invertible function, return the the operands of the function co...

Definition ValueTracking.cpp:3759

static bool cmpExcludesZero(CmpInst::Predicate Pred, const Value *RHS)

Definition ValueTracking.cpp:752

static void computeKnownBitsFromCond(const Value *V, Value *Cond, KnownBits &Known, const SimplifyQuery &SQ, bool Invert, unsigned Depth)

Definition ValueTracking.cpp:993

static bool isKnownNonZeroFromAssume(const Value *V, const SimplifyQuery &Q)

Definition ValueTracking.cpp:818

static std::optional< bool > isImpliedCondOperands(CmpInst::Predicate Pred, const Value *ALHS, const Value *ARHS, const Value *BLHS, const Value *BRHS)

Return true if "icmp Pred BLHS BRHS" is true whenever "icmp PredALHS ARHS" is true.

Definition ValueTracking.cpp:9411

static const Instruction * safeCxtI(const Value *V, const Instruction *CxtI)

Definition ValueTracking.cpp:108

static bool isNonEqualMul(const Value *V1, const Value *V2, const APInt &DemandedElts, const SimplifyQuery &Q, unsigned Depth)

Return true if V2 == V1 * C, where V1 is known non-zero, C is not 0/1 and the multiplication is nuw o...

Definition ValueTracking.cpp:3904

static bool isImpliedToBeAPowerOfTwoFromCond(const Value *V, bool OrZero, const Value *Cond, bool CondIsTrue)

Return true if we can infer that V is known to be a power of 2 from dominating condition Cond (e....

Definition ValueTracking.cpp:2602

static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW, bool NUW, const APInt &DemandedElts, KnownBits &Known, KnownBits &Known2, const SimplifyQuery &Q, unsigned Depth)

Definition ValueTracking.cpp:511

static bool isKnownNonNaN(const Value *V, FastMathFlags FMF)

Definition ValueTracking.cpp:8316

static ConstantRange getRangeForIntrinsic(const IntrinsicInst &II, bool UseInstrInfo)

Definition ValueTracking.cpp:10087

static void computeKnownFPClassForFPTrunc(const Operator *Op, const APInt &DemandedElts, FPClassTest InterestedClasses, KnownFPClass &Known, const SimplifyQuery &Q, unsigned Depth)

Definition ValueTracking.cpp:4885

static Value * BuildSubAggregate(Value *From, Value *To, Type *IndexedType, SmallVectorImpl< unsigned > &Idxs, unsigned IdxSkip, BasicBlock::iterator InsertBefore)

Definition ValueTracking.cpp:6398

static LLVM_ABI unsigned int semanticsPrecision(const fltSemantics &)

static LLVM_ABI bool isRepresentableAsNormalIn(const fltSemantics &Src, const fltSemantics &Dst)

static APFloat getLargest(const fltSemantics &Sem, bool Negative=false)

Returns the largest finite number in the given semantics.

static APFloat getInf(const fltSemantics &Sem, bool Negative=false)

Factory for Positive and Negative Infinity.

static APFloat getZero(const fltSemantics &Sem, bool Negative=false)

Factory for Positive and Negative Zero.

Class for arbitrary precision integers.

LLVM_ABI APInt umul_ov(const APInt &RHS, bool &Overflow) const

LLVM_ABI APInt udiv(const APInt &RHS) const

Unsigned division operation.

static APInt getAllOnes(unsigned numBits)

Return an APInt of a specified width with all bits set.

void clearBit(unsigned BitPosition)

Set a given bit to 0.

bool isMinSignedValue() const

Determine if this is the smallest signed value.

uint64_t getZExtValue() const

Get zero extended value.

void setHighBits(unsigned hiBits)

Set the top hiBits bits.

unsigned popcount() const

Count the number of bits set.

void setBitsFrom(unsigned loBit)

Set the top bits starting from loBit.

static APInt getMaxValue(unsigned numBits)

Gets maximum unsigned value of APInt for specific bit width.

void setBit(unsigned BitPosition)

Set the given bit to 1 whose position is given as "bitPosition".

unsigned ceilLogBase2() const

bool sgt(const APInt &RHS) const

Signed greater than comparison.

bool isAllOnes() const

Determine if all bits are set. This is true for zero-width values.

bool ugt(const APInt &RHS) const

Unsigned greater than comparison.

bool isZero() const

Determine if this value is zero, i.e. all bits are clear.

LLVM_ABI APInt urem(const APInt &RHS) const

Unsigned remainder operation.

unsigned getBitWidth() const

Return the number of bits in the APInt.

bool ult(const APInt &RHS) const

Unsigned less than comparison.

static APInt getSignedMaxValue(unsigned numBits)

Gets maximum signed value of APInt for a specific bit width.

static APInt getMinValue(unsigned numBits)

Gets minimum unsigned value of APInt for a specific bit width.

bool isNegative() const

Determine sign of this APInt.

bool intersects(const APInt &RHS) const

This operation tests if there are any pairs of corresponding bits between this APInt and RHS that are...

LLVM_ABI APInt sdiv(const APInt &RHS) const

Signed division function for APInt.

void clearAllBits()

Set every bit to 0.

LLVM_ABI APInt reverseBits() const

bool sle(const APInt &RHS) const

Signed less or equal comparison.

unsigned getNumSignBits() const

Computes the number of leading bits of this APInt that are equal to its sign bit.

unsigned countl_zero() const

The APInt version of std::countl_zero.

static APInt getSignedMinValue(unsigned numBits)

Gets minimum signed value of APInt for a specific bit width.

LLVM_ABI APInt sextOrTrunc(unsigned width) const

Sign extend or truncate to width.

bool isStrictlyPositive() const

Determine if this APInt Value is positive.

unsigned logBase2() const

APInt ashr(unsigned ShiftAmt) const

Arithmetic right-shift function.

bool getBoolValue() const

Convert APInt to a boolean value.

bool isMaxSignedValue() const

Determine if this is the largest signed value.

bool isNonNegative() const

Determine if this APInt Value is non-negative (>= 0)

bool ule(const APInt &RHS) const

Unsigned less or equal comparison.

APInt shl(unsigned shiftAmt) const

Left-shift function.

bool isSubsetOf(const APInt &RHS) const

This operation checks that all bits set in this APInt are also set in RHS.

bool slt(const APInt &RHS) const

Signed less than comparison.

static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)

Constructs an APInt value that has the top hiBitsSet bits set.

static APInt getZero(unsigned numBits)

Get the '0' value for the specified bit-width.

void setLowBits(unsigned loBits)

Set the bottom loBits bits.

bool sge(const APInt &RHS) const

Signed greater or equal comparison.

static APInt getBitsSetFrom(unsigned numBits, unsigned loBit)

Constructs an APInt value that has a contiguous range of bits set.

static APInt getOneBitSet(unsigned numBits, unsigned BitNo)

Return an APInt with exactly one bit set in the result.

APInt lshr(unsigned shiftAmt) const

Logical right-shift function.

bool uge(const APInt &RHS) const

Unsigned greater or equal comparison.

void clearSignBit()

Set the sign bit to 0.

an instruction to allocate memory on the stack

This class represents an incoming formal argument to a Function.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

size_t size() const

size - Get the array size.

bool empty() const

empty - Check if the array is empty.

ArrayRef< T > slice(size_t N, size_t M) const

slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.

Class to represent array types.

This represents the llvm.assume intrinsic.

A cache of @llvm.assume calls within a function.

MutableArrayRef< ResultElem > assumptionsFor(const Value *V)

Access the list of assumptions which affect this value.

Functions, function parameters, and return types can have attributes to indicate how they should be t...

LLVM_ABI std::optional< unsigned > getVScaleRangeMax() const

Returns the maximum value for the vscale_range attribute or std::nullopt when unknown.

LLVM_ABI unsigned getVScaleRangeMin() const

Returns the minimum value for the vscale_range attribute.

bool isValid() const

Return true if the attribute is any kind of attribute.

LLVM_ABI bool isSingleEdge() const

Check if this is the only edge between Start and End.

LLVM Basic Block Representation.

iterator begin()

Instruction iterator methods.

const Function * getParent() const

Return the enclosing method, or null if none.

LLVM_ABI InstListType::const_iterator getFirstNonPHIIt() const

Returns an iterator to the first instruction in this block that is not a PHINode instruction.

InstListType::const_iterator const_iterator

LLVM_ABI const BasicBlock * getSinglePredecessor() const

Return the predecessor of this block if it has a single predecessor block.

LLVM_ABI const BasicBlock * getSingleSuccessor() const

Return the successor of this block if it has a single successor.

InstListType::iterator iterator

Instruction iterators...

const Instruction * getTerminator() const LLVM_READONLY

Returns the terminator instruction if the block is well formed or null if the block is not well forme...

LLVM_ABI Instruction::BinaryOps getBinaryOp() const

Returns the binary operation underlying the intrinsic.

BinaryOps getOpcode() const

Conditional or Unconditional Branch instruction.

Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...

Function * getCalledFunction() const

Returns the function called, or null if this is an indirect function invocation or the function signa...

LLVM_ABI bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const

Determine whether the argument or parameter has the given attribute.

LLVM_ABI bool isIndirectCall() const

Return true if the callsite is an indirect call.

bool onlyReadsMemory(unsigned OpNo) const

Value * getCalledOperand() const

Value * getArgOperand(unsigned i) const

unsigned arg_size() const

This class represents a function call, abstracting a target machine's calling convention.

This is the base class for all instructions that perform data casts.

This class is the base class for the comparison instructions.

Predicate

This enumeration lists the possible predicates for CmpInst subclasses.

@ ICMP_SLT

signed less than

@ ICMP_SLE

signed less or equal

@ FCMP_OLT

0 1 0 0 True if ordered and less than

@ FCMP_ULE

1 1 0 1 True if unordered, less than, or equal

@ FCMP_OGT

0 0 1 0 True if ordered and greater than

@ FCMP_OGE

0 0 1 1 True if ordered and greater than or equal

@ ICMP_UGE

unsigned greater or equal

@ ICMP_UGT

unsigned greater than

@ ICMP_SGT

signed greater than

@ FCMP_ULT

1 1 0 0 True if unordered or less than

@ ICMP_ULT

unsigned less than

@ FCMP_UGT

1 0 1 0 True if unordered or greater than

@ FCMP_OLE

0 1 0 1 True if ordered and less than or equal

@ ICMP_SGE

signed greater or equal

@ ICMP_ULE

unsigned less or equal

@ FCMP_UGE

1 0 1 1 True if unordered, greater than, or equal

static LLVM_ABI bool isEquality(Predicate pred)

Determine if this is an equals/not equals predicate.

Predicate getSwappedPredicate() const

For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.

bool isTrueWhenEqual() const

This is just a convenience.

static bool isFPPredicate(Predicate P)

Predicate getInversePredicate() const

For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...

Predicate getPredicate() const

Return the predicate for this instruction.

Predicate getFlippedStrictnessPredicate() const

For predicate of kind "is X or equal to 0" returns the predicate "is X".

static bool isIntPredicate(Predicate P)

static LLVM_ABI bool isOrdered(Predicate predicate)

Determine if the predicate is an ordered operation.

An abstraction over a floating-point predicate, and a pack of an integer predicate with samesign info...

static LLVM_ABI std::optional< CmpPredicate > getMatching(CmpPredicate A, CmpPredicate B)

Compares two CmpPredicates taking samesign into account and returns the canonicalized CmpPredicate if...

LLVM_ABI CmpInst::Predicate getPreferredSignedPredicate() const

Attempts to return a signed CmpInst::Predicate from the CmpPredicate.

CmpInst::Predicate dropSameSign() const

Drops samesign information.

bool hasSameSign() const

Query samesign information, for optimizations.

An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...

ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...

StringRef getAsString() const

If this array is isString(), then this method returns the array as a StringRef.

A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...

static LLVM_ABI Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)

static LLVM_ABI Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)

static LLVM_ABI Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)

static LLVM_ABI std::optional< ConstantFPRange > makeExactFCmpRegion(FCmpInst::Predicate Pred, const APFloat &Other)

Produce the exact range such that all values in the returned range satisfy the given predicate with a...

ConstantFP - Floating Point Values [float, double].

This is the shared class of boolean and integer constants.

static LLVM_ABI ConstantInt * getTrue(LLVMContext &Context)

uint64_t getZExtValue() const

Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...

This class represents a range of values.

PreferredRangeType

If represented precisely, the result of some range operations may consist of multiple disjoint ranges...

const APInt * getSingleElement() const

If this set contains a single element, return it, otherwise return null.

static LLVM_ABI ConstantRange fromKnownBits(const KnownBits &Known, bool IsSigned)

Initialize a range based on a known bits constraint.

LLVM_ABI OverflowResult unsignedSubMayOverflow(const ConstantRange &Other) const

Return whether unsigned sub of the two ranges always/never overflows.

LLVM_ABI bool isAllNegative() const

Return true if all values in this range are negative.

LLVM_ABI OverflowResult unsignedAddMayOverflow(const ConstantRange &Other) const

Return whether unsigned add of the two ranges always/never overflows.

LLVM_ABI KnownBits toKnownBits() const

Return known bits for values in this range.

LLVM_ABI bool icmp(CmpInst::Predicate Pred, const ConstantRange &Other) const

Does the predicate Pred hold between ranges this and Other?

LLVM_ABI APInt getSignedMin() const

Return the smallest signed value contained in the ConstantRange.

LLVM_ABI OverflowResult unsignedMulMayOverflow(const ConstantRange &Other) const

Return whether unsigned mul of the two ranges always/never overflows.

LLVM_ABI bool isAllNonNegative() const

Return true if all values in this range are non-negative.

static LLVM_ABI ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred, const ConstantRange &Other)

Produce the smallest range such that all values that may satisfy the given predicate with any value c...

LLVM_ABI ConstantRange unionWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const

Return the range that results from the union of this range with another range.

static LLVM_ABI ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred, const APInt &Other)

Produce the exact range such that all values in the returned range satisfy the given predicate with a...

LLVM_ABI bool contains(const APInt &Val) const

Return true if the specified value is in the set.

LLVM_ABI OverflowResult signedAddMayOverflow(const ConstantRange &Other) const

Return whether signed add of the two ranges always/never overflows.

LLVM_ABI ConstantRange intersectWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const

Return the range that results from the intersection of this range with another range.

OverflowResult

Represents whether an operation on the given constant range is known to always or never overflow.

@ NeverOverflows

Never overflows.

@ AlwaysOverflowsHigh

Always overflows in the direction of signed/unsigned max value.

@ AlwaysOverflowsLow

Always overflows in the direction of signed/unsigned min value.

@ MayOverflow

May or may not overflow.

static ConstantRange getNonEmpty(APInt Lower, APInt Upper)

Create non-empty constant range with the given bounds.

uint32_t getBitWidth() const

Get the bit width of this ConstantRange.

LLVM_ABI OverflowResult signedSubMayOverflow(const ConstantRange &Other) const

Return whether signed sub of the two ranges always/never overflows.

LLVM_ABI ConstantRange sub(const ConstantRange &Other) const

Return a new range representing the possible values resulting from a subtraction of a value in this r...

This is an important base class in LLVM.

static LLVM_ABI Constant * replaceUndefsWith(Constant *C, Constant *Replacement)

Try to replace undefined constant C or undefined elements in C with Replacement.

LLVM_ABI Constant * getSplatValue(bool AllowPoison=false) const

If all elements of the vector constant have the same value, return that value.

static LLVM_ABI Constant * getNullValue(Type *Ty)

Constructor to create a '0' constant of arbitrary type.

LLVM_ABI Constant * getAggregateElement(unsigned Elt) const

For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...

LLVM_ABI bool isZeroValue() const

Return true if the value is negative zero or null value.

LLVM_ABI bool isNullValue() const

Return true if this is the value that would be returned by getNullValue.

A parsed version of the target data layout string in and methods for querying it.

bool isLittleEndian() const

Layout endianness...

LLVM_ABI const StructLayout * getStructLayout(StructType *Ty) const

Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...

LLVM_ABI unsigned getIndexTypeSizeInBits(Type *Ty) const

The size in bits of the index used in GEP calculation for this type.

LLVM_ABI unsigned getPointerTypeSizeInBits(Type *) const

The pointer representation size in bits for this type.

TypeSize getTypeSizeInBits(Type *Ty) const

Size examples:

ArrayRef< BranchInst * > conditionsFor(const Value *V) const

Access the list of branches which affect this value.

DomTreeNodeBase * getIDom() const

DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const

getNode - return the (Post)DominatorTree node for the specified basic block.

Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.

LLVM_ABI bool dominates(const BasicBlock *BB, const Use &U) const

Return true if the (end of the) basic block BB dominates the use U.

This instruction compares its operands according to the predicate given to the constructor.

Utility class for floating point operations which can have information about relaxed accuracy require...

Convenience struct for specifying and reasoning about fast-math flags.

bool noSignedZeros() const

void setNoSignedZeros(bool B=true)

void setNoNaNs(bool B=true)

const BasicBlock & getEntryBlock() const

bool hasNoSync() const

Determine if the call can synchroize with other threads.

DenormalMode getDenormalMode(const fltSemantics &FPType) const

Returns the denormal handling type for the default rounding mode of the function.

an instruction for type-safe pointer arithmetic to access elements of arrays and structs

PointerType * getType() const

Global values are always pointers.

LLVM_ABI const DataLayout & getDataLayout() const

Get the data layout of the module this global belongs to.

Type * getValueType() const

const Constant * getInitializer() const

getInitializer - Return the initializer for this global variable.

bool isConstant() const

If the value is a global constant, its value is immutable throughout the runtime execution of the pro...

bool hasDefinitiveInitializer() const

hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...

This instruction compares its operands according to the predicate given to the constructor.

CmpPredicate getSwappedCmpPredicate() const

CmpPredicate getInverseCmpPredicate() const

Predicate getFlippedSignednessPredicate() const

For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->EQ.

static bool isEquality(Predicate P)

Return true if this predicate is either EQ or NE.

static LLVM_ABI std::optional< bool > isImpliedByMatchingCmp(CmpPredicate Pred1, CmpPredicate Pred2)

Determine if Pred1 implies Pred2 is true, false, or if nothing can be inferred about the implication,...

bool isRelational() const

Return true if the predicate is relational (not EQ or NE).

Predicate getUnsignedPredicate() const

For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.

This instruction inserts a struct field of array element value into an aggregate value.

Value * getAggregateOperand()

static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

LLVM_ABI bool hasNoNaNs() const LLVM_READONLY

Determine whether the no-NaNs flag is set.

LLVM_ABI bool hasNoUnsignedWrap() const LLVM_READONLY

Determine whether the no unsigned wrap flag is set.

LLVM_ABI bool hasNoSignedWrap() const LLVM_READONLY

Determine whether the no signed wrap flag is set.

LLVM_ABI InstListType::iterator eraseFromParent()

This method unlinks 'this' from the containing basic block and deletes it.

LLVM_ABI bool isExact() const LLVM_READONLY

Determine whether the exact flag is set.

LLVM_ABI const Function * getFunction() const

Return the function this instruction belongs to.

LLVM_ABI bool comesBefore(const Instruction *Other) const

Given an instruction Other in the same basic block as this instruction, return true if this instructi...

unsigned getOpcode() const

Returns a member of one of the enums like Instruction::Add.

LLVM_ABI const DataLayout & getDataLayout() const

Get the data layout of the module this instruction belongs to.

A wrapper class for inspecting calls to intrinsic functions.

This is an important class for using LLVM in a threaded context.

An instruction for reading from memory.

Value * getPointerOperand()

Align getAlign() const

Return the alignment of the access that is being performed.

bool isLoopHeader(const BlockT *BB) const

LoopT * getLoopFor(const BlockT *BB) const

Return the inner most loop that BB lives in.

Represents a single loop in the control flow graph.

This is a utility class that provides an abstraction for the common functionality between Instruction...

unsigned getOpcode() const

Return the opcode for this Instruction or ConstantExpr.

Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.

iterator_range< const_block_iterator > blocks() const

Value * getIncomingValueForBlock(const BasicBlock *BB) const

BasicBlock * getIncomingBlock(unsigned i) const

Return incoming basic block number i.

Value * getIncomingValue(unsigned i) const

Return incoming value number x.

unsigned getNumIncomingValues() const

Return the number of incoming edges.

static LLVM_ABI PoisonValue * get(Type *T)

Static factory methods - Return an 'poison' object of the specified type.

A udiv, sdiv, lshr, or ashr instruction, which can be marked as "exact", indicating that no bits are ...

bool isExact() const

Test whether this division is known to be exact, with zero remainder.

This class represents the LLVM 'select' instruction.

const Value * getFalseValue() const

const Value * getCondition() const

const Value * getTrueValue() const

This instruction constructs a fixed permutation of two input vectors.

VectorType * getType() const

Overload to return most specific vector type.

static LLVM_ABI void getShuffleMask(const Constant *Mask, SmallVectorImpl< int > &Result)

Convert the input shuffle mask operand to a vector of integers.

A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...

size_type count(ConstPtrType Ptr) const

count - Return 1 if the specified pointer is in the set, 0 otherwise.

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

bool contains(ConstPtrType Ptr) const

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

void reserve(size_type N)

void append(ItTy in_start, ItTy in_end)

Add the specified range to the end of the SmallVector.

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

StringRef - Represent a constant reference to a string, i.e.

constexpr StringRef substr(size_t Start, size_t N=npos) const

Return a reference to the substring from [Start, Start + N).

Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...

TypeSize getElementOffset(unsigned Idx) const

Class to represent struct types.

unsigned getNumElements() const

Random access to the elements.

Type * getElementType(unsigned N) const

Provides information about what library functions are available for the current target.

bool getLibFunc(StringRef funcName, LibFunc &F) const

Searches for a particular function name.

The instances of the Type class are immutable: once they are created, they are never changed.

static LLVM_ABI IntegerType * getInt64Ty(LLVMContext &C)

LLVM_ABI unsigned getIntegerBitWidth() const

bool isVectorTy() const

True if this is an instance of VectorType.

static LLVM_ABI IntegerType * getInt32Ty(LLVMContext &C)

bool isIntOrIntVectorTy() const

Return true if this is an integer type or a vector of integer types.

bool isPointerTy() const

True if this is an instance of PointerType.

LLVM_ABI unsigned getPointerAddressSpace() const

Get the address space of this pointer or pointer vector type.

LLVM_ABI uint64_t getArrayNumElements() const

static LLVM_ABI IntegerType * getInt8Ty(LLVMContext &C)

Type * getScalarType() const

If this is a vector type, return the element type, otherwise return 'this'.

static LLVM_ABI IntegerType * getInt16Ty(LLVMContext &C)

bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const

Return true if it makes sense to take the size of this type.

LLVM_ABI unsigned getScalarSizeInBits() const LLVM_READONLY

If this is a vector type, return the getPrimitiveSizeInBits value for the element type.

bool isPtrOrPtrVectorTy() const

Return true if this is a pointer type or a vector of pointer types.

bool isIntOrPtrTy() const

Return true if this is an integer type or a pointer type.

bool isIntegerTy() const

True if this is an instance of IntegerType.

static LLVM_ABI IntegerType * getIntNTy(LLVMContext &C, unsigned N)

bool isFPOrFPVectorTy() const

Return true if this is a FP type or a vector of FP.

LLVM_ABI const fltSemantics & getFltSemantics() const

static LLVM_ABI UndefValue * get(Type *T)

Static factory methods - Return an 'undef' object of the specified type.

A Use represents the edge between a Value definition and its users.

LLVM_ABI unsigned getOperandNo() const

Return the operand # of this use in its User.

User * getUser() const

Returns the User that contains this Use.

Value * getOperand(unsigned i) const

unsigned getNumOperands() const

LLVM Value Representation.

Type * getType() const

All values are typed, get the type of this value.

const Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset) const

This is a wrapper around stripAndAccumulateConstantOffsets with the in-bounds requirement set to fals...

iterator_range< user_iterator > users()

LLVM_ABI const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr, bool LookThroughIntToPtr=false) const

Accumulate the constant offset this value has compared to a base pointer.

const KnownBits & getKnownBits(const SimplifyQuery &Q) const

PointerType getValue() const

Represents an op.with.overflow intrinsic.

constexpr ScalarTy getFixedValue() const

constexpr bool isScalable() const

Returns whether the quantity is scaled by a runtime quantity (vscale).

constexpr ScalarTy getKnownMinValue() const

Returns the minimum value this quantity can represent.

An efficient, type-erasing, non-owning reference to a callable.

StructType * getStructTypeOrNull() const

TypeSize getSequentialElementStride(const DataLayout &DL) const

Type * getIndexedType() const

const ParentTy * getParent() const

self_iterator getIterator()

A range adaptor for a pair of iterators.

This provides a very simple, boring adaptor for a begin and end iterator into a range type.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

LLVM_ABI APInt ScaleBitMask(const APInt &A, unsigned NewBitWidth, bool MatchAllBits=false)

Splat/Merge neighboring bits to widen/narrow the bitmask represented by.

const APInt & umax(const APInt &A, const APInt &B)

Determine the larger of two APInts considered to be unsigned.

@ C

The default llvm calling convention, compatible with C.

SpecificConstantMatch m_ZeroInt()

Convenience matchers for specific integer values.

BinaryOp_match< SpecificConstantMatch, SrcTy, TargetOpcode::G_SUB > m_Neg(const SrcTy &&Src)

Matches a register negated by a G_SUB.

BinaryOp_match< SrcTy, SpecificConstantMatch, TargetOpcode::G_XOR, true > m_Not(const SrcTy &&Src)

Matches a register not-ed by a G_XOR.

OneUse_match< SubPat > m_OneUse(const SubPat &SP)

cst_pred_ty< is_all_ones > m_AllOnes()

Match an integer or vector with all bits set.

cst_pred_ty< is_lowbit_mask > m_LowBitMask()

Match an integer or vector with only the low bit(s) set.

BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)

PtrToIntSameSize_match< OpTy > m_PtrToIntSameSize(const DataLayout &DL, const OpTy &Op)

BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)

CmpClass_match< LHS, RHS, FCmpInst > m_FCmp(CmpPredicate &Pred, const LHS &L, const RHS &R)

cst_pred_ty< is_sign_mask > m_SignMask()

Match an integer or vector with only the sign bit(s) set.

OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(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)

auto m_LogicalOp()

Matches either L && R or L || R where L and R are arbitrary values.

class_match< Constant > m_Constant()

Match an arbitrary Constant and ignore it.

ap_match< APInt > m_APInt(const APInt *&Res)

Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.

BinaryOp_match< LHS, RHS, Instruction::And, true > m_c_And(const LHS &L, const RHS &R)

Matches an And with LHS and RHS in either order.

cst_pred_ty< is_power2_or_zero > m_Power2OrZero()

Match an integer or vector of 0 or power-of-2 values.

CastInst_match< OpTy, TruncInst > m_Trunc(const OpTy &Op)

Matches Trunc.

BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)

OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)

bool match(Val *V, const Pattern &P)

BinOpPred_match< LHS, RHS, is_idiv_op > m_IDiv(const LHS &L, const RHS &R)

Matches integer division operations.

bind_ty< Instruction > m_Instruction(Instruction *&I)

Match an instruction, capturing it if we match.

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.

BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)

Matches logical shift operations.

ap_match< APFloat > m_APFloat(const APFloat *&Res)

Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...

CmpClass_match< LHS, RHS, ICmpInst, true > m_c_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)

Matches an ICmp with a predicate over LHS and RHS in either order.

OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > m_c_NUWAdd(const LHS &L, const RHS &R)

cst_pred_ty< is_nonnegative > m_NonNegative()

Match an integer or vector of non-negative values.

class_match< ConstantInt > m_ConstantInt()

Match an arbitrary ConstantInt and ignore it.

cst_pred_ty< is_one > m_One()

Match an integer 1 or a vector with all elements equal to 1.

IntrinsicID_match m_Intrinsic()

Match intrinsic calls like this: m_IntrinsicIntrinsic::fabs(m_Value(X))

ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)

Matches SelectInst.

IntrinsicID_match m_VScale()

Matches a call to llvm.vscale().

match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > > m_OrdOrUnordFMin(const LHS &L, const RHS &R)

Match an 'ordered' or 'unordered' floating point minimum function.

ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)

Match a single index ExtractValue instruction.

MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)

bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)

Match a with overflow intrinsic, capturing it if we match.

BinaryOp_match< LHS, RHS, Instruction::Xor, true > m_c_Xor(const LHS &L, const RHS &R)

Matches an Xor with LHS and RHS in either order.

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()...

MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > m_c_SMin(const LHS &L, const RHS &R)

Matches an SMin with LHS and RHS in either order.

auto m_LogicalOr()

Matches L || R where L and R are arbitrary values.

MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true > m_c_UMax(const LHS &L, const RHS &R)

Matches a UMax with LHS and RHS in either order.

SpecificCmpClass_match< LHS, RHS, ICmpInst > m_SpecificICmp(CmpPredicate MatchPred, const LHS &L, const RHS &R)

CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)

Matches ZExt.

BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)

MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)

brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)

match_immconstant_ty m_ImmConstant()

Match an arbitrary immediate Constant and ignore it.

NoWrapTrunc_match< OpTy, TruncInst::NoUnsignedWrap > m_NUWTrunc(const OpTy &Op)

Matches trunc nuw.

MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > m_c_UMin(const LHS &L, const RHS &R)

Matches a UMin with LHS and RHS in either order.

BinaryOp_match< LHS, RHS, Instruction::Add, true > m_c_Add(const LHS &L, const RHS &R)

Matches a Add with LHS and RHS in either order.

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".

match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > > m_OrdOrUnordFMax(const LHS &L, const RHS &R)

Match an 'ordered' or 'unordered' floating point maximum function.

MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true > m_c_SMax(const LHS &L, const RHS &R)

Matches an SMax with LHS and RHS in either order.

OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWSub(const LHS &L, const RHS &R)

MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)

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.

OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)

BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)

CmpClass_match< LHS, RHS, ICmpInst > m_ICmp(CmpPredicate &Pred, const LHS &L, const RHS &R)

match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > m_ZExtOrSExt(const OpTy &Op)

FNeg_match< OpTy > m_FNeg(const OpTy &X)

Match 'fneg X' as 'fsub -0.0, X'.

BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)

Matches shift operations.

BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)

BinOpPred_match< LHS, RHS, is_irem_op > m_IRem(const LHS &L, const RHS &R)

Matches integer remainder operations.

auto m_LogicalAnd()

Matches L && R where L and R are arbitrary values.

class_match< BasicBlock > m_BasicBlock()

Match an arbitrary basic block value and ignore it.

BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)

cst_pred_ty< is_nonpositive > m_NonPositive()

Match an integer or vector of non-positive values.

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.

BinaryOp_match< LHS, RHS, Instruction::Or, true > m_c_Or(const LHS &L, const RHS &R)

Matches an Or with LHS and RHS in either order.

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".

ElementWiseBitCast_match< OpTy > m_ElementWiseBitCast(const OpTy &Op)

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.

CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)

Matches PtrToInt.

MatchFunctor< Val, Pattern > match_fn(const Pattern &P)

A match functor that can be used as a UnaryPredicate in functional algorithms like all_of.

BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)

MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)

match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)

Combine two pattern matchers matching L || R.

static unsigned decodeVSEW(unsigned VSEW)

LLVM_ABI unsigned getSEWLMULRatio(unsigned SEW, VLMUL VLMul)

static constexpr unsigned RVVBitsPerBlock

initializer< Ty > init(const Ty &Val)

std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)

Extract a Value from Metadata.

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI bool haveNoCommonBitsSet(const WithCache< const Value * > &LHSCache, const WithCache< const Value * > &RHSCache, const SimplifyQuery &SQ)

Return true if LHS and RHS have no common bits set.

Definition ValueTracking.cpp:237

LLVM_ABI bool mustExecuteUBIfPoisonOnPathTo(Instruction *Root, Instruction *OnPathTo, DominatorTree *DT)

Return true if undefined behavior would provable be executed on the path to OnPathTo if Root produced...

Definition ValueTracking.cpp:7900

LLVM_ABI Intrinsic::ID getInverseMinMaxIntrinsic(Intrinsic::ID MinMaxID)

Definition ValueTracking.cpp:9194

LLVM_ABI bool willNotFreeBetween(const Instruction *Assume, const Instruction *CtxI)

Returns true, if no instruction between Assume and CtxI may free memory and the function is marked as...

Definition ValueTracking.cpp:705

@ NeverOverflows

Never overflows.

@ AlwaysOverflowsHigh

Always overflows in the direction of signed/unsigned max value.

@ AlwaysOverflowsLow

Always overflows in the direction of signed/unsigned min value.

@ MayOverflow

May or may not overflow.

LLVM_ABI KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, const SimplifyQuery &SQ, unsigned Depth=0)

Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.

Definition ValueTracking.cpp:6080

bool all_of(R &&range, UnaryPredicate P)

Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.

MaybeAlign getAlign(const CallInst &I, unsigned Index)

LLVM_ABI bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr, bool AllowEphemerals=false)

Return true if it is valid to use the assumptions provided by an assume intrinsic,...

Definition ValueTracking.cpp:655

auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)

Get the size of a range.

LLVM_ABI bool canCreatePoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)

Definition ValueTracking.cpp:7651

LLVM_ABI bool mustTriggerUB(const Instruction *I, const SmallPtrSetImpl< const Value * > &KnownPoison)

Return true if the given instruction must trigger undefined behavior when I is executed with any oper...

Definition ValueTracking.cpp:8208

LLVM_ABI bool isKnownNeverInfinity(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)

Return true if the floating-point scalar value is not an infinity or if the floating-point vector val...

Definition ValueTracking.cpp:6152

LLVM_ABI void computeKnownBitsFromContext(const Value *V, KnownBits &Known, const SimplifyQuery &Q, unsigned Depth=0)

Merge bits known from context-dependent facts into Known.

Definition ValueTracking.cpp:1036

detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)

LLVM_ABI bool isOnlyUsedInZeroEqualityComparison(const Instruction *CxtI)

Definition ValueTracking.cpp:261

LLVM_ABI bool isSignBitCheck(ICmpInst::Predicate Pred, const APInt &RHS, bool &TrueIfSigned)

Given an exploded icmp instruction, return true if the comparison only checks the sign bit.

Definition ValueTracking.cpp:4737

LLVM_ABI const Value * getArgumentAliasingToReturnedPointer(const CallBase *Call, bool MustPreserveNullness)

This function returns call pointer argument that is considered the same by aliasing rules.

Definition ValueTracking.cpp:6781

LLVM_ABI bool isAssumeLikeIntrinsic(const Instruction *I)

Return true if it is an intrinsic that cannot be speculated but also cannot trap.

Definition ValueTracking.cpp:648

auto enumerate(FirstRange &&First, RestRanges &&...Rest)

Given two or more input ranges, returns a new range whose values are tuples (A, B,...

LLVM_ABI AllocaInst * findAllocaForValue(Value *V, bool OffsetZero=false)

Returns unique alloca where the value comes from, or nullptr.

Definition ValueTracking.cpp:7045

LLVM_ABI APInt getMinMaxLimit(SelectPatternFlavor SPF, unsigned BitWidth)

Return the minimum or maximum constant value for the specified integer min/max flavor and type.

Definition ValueTracking.cpp:9214

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

LLVM_ABI bool isOnlyUsedInZeroComparison(const Instruction *CxtI)

Definition ValueTracking.cpp:256

const Value * getLoadStorePointerOperand(const Value *V)

A helper function that returns the pointer operand of a load or store instruction.

LLVM_ABI bool getConstantStringInfo(const Value *V, StringRef &Str, bool TrimAtNul=true)

This function computes the length of a null-terminated C string pointed to by V.

Definition ValueTracking.cpp:6658

LLVM_ABI bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty, Align Alignment, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)

Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested.

LLVM_ABI bool onlyUsedByLifetimeMarkersOrDroppableInsts(const Value *V)

Return true if the only users of this pointer are lifetime markers or droppable instructions.

Definition ValueTracking.cpp:7112

LLVM_ABI Constant * ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset)

LLVM_ABI Value * stripNullTest(Value *V)

Returns the inner value X if the expression has the form f(X) where f(X) == 0 if and only if X == 0,...

Definition ValueTracking.cpp:10508

LLVM_ABI bool getUnderlyingObjectsForCodeGen(const Value *V, SmallVectorImpl< Value * > &Objects)

This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr...

Definition ValueTracking.cpp:7012

LLVM_ABI std::pair< Intrinsic::ID, bool > canConvertToMinOrMaxIntrinsic(ArrayRef< Value * > VL)

Check if the values in VL are select instructions that can be converted to a min or max (vector) intr...

Definition ValueTracking.cpp:9225

iterator_range< T > make_range(T x, T y)

Convenience function for iterating over sub-ranges.

LLVM_ABI bool getConstantDataArrayInfo(const Value *V, ConstantDataArraySlice &Slice, unsigned ElementSize, uint64_t Offset=0)

Returns true if the value V is a pointer into a ConstantDataArray.

Definition ValueTracking.cpp:6563

int bit_width(T Value)

Returns the number of bits needed to represent Value if Value is nonzero.

LLVM_ABI bool isGuaranteedToExecuteForEveryIteration(const Instruction *I, const Loop *L)

Return true if this function can prove that the instruction I is executed for every iteration of the ...

Definition ValueTracking.cpp:8010

void append_range(Container &C, Range &&R)

Wrapper function to append range R to container C.

LLVM_ABI bool mustSuppressSpeculation(const LoadInst &LI)

Return true if speculation of the given load must be suppressed to avoid ordering or interfering with...

constexpr bool isPowerOf2_64(uint64_t Value)

Return true if the argument is a power of two > 0 (64 bit edition.)

gep_type_iterator gep_type_end(const User *GEP)

int ilogb(const APFloat &Arg)

Returns the exponent of the internal representation of the APFloat.

LLVM_ABI bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true, bool IgnoreUBImplyingAttrs=true)

Return true if the instruction does not have any effects besides calculating the result and does not ...

Definition ValueTracking.cpp:7125

LLVM_ABI Value * getSplatValue(const Value *V)

Get splat value if the input is a splat vector or return nullptr.

LLVM_ABI CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF, bool Ordered=false)

Return the canonical comparison predicate for the specified minimum/maximum flavor.

Definition ValueTracking.cpp:9159

bool isa_and_nonnull(const Y &Val)

unsigned Log2_64(uint64_t Value)

Return the floor log base 2 of the specified value, -1 if the value is zero.

LLVM_ABI bool canIgnoreSignBitOfZero(const Use &U)

Return true if the sign bit of the FP value can be ignored by the user when the value is zero.

Definition ValueTracking.cpp:6184

LLVM_ABI 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.

Definition ValueTracking.cpp:7886

LLVM_ABI ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)

Parse out a conservative ConstantRange from !range metadata.

std::tuple< Value *, FPClassTest, FPClassTest > fcmpImpliesClass(CmpInst::Predicate Pred, const Function &F, Value *LHS, FPClassTest RHSClass, bool LookThroughSrc=true)

LLVM_ABI ConstantRange computeConstantRange(const Value *V, bool ForSigned, bool UseInstrInfo=true, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)

Determine the possible constant range of an integer or vector of integer value.

Definition ValueTracking.cpp:10264

const Value * getPointerOperand(const Value *V)

A helper function that returns the pointer operand of a load, store or GEP instruction.

LLVM_ABI bool MaskedValueIsZero(const Value *V, const APInt &Mask, const SimplifyQuery &SQ, unsigned Depth=0)

Return true if 'V & Mask' is known to be zero.

Definition ValueTracking.cpp:318

int countr_zero(T Val)

Count number of 0's from the least significant bit to the most stopping at the first 1.

LLVM_ABI bool isOverflowIntrinsicNoWrap(const WithOverflowInst *WO, const DominatorTree &DT)

Returns true if the arithmetic part of the WO 's result is used only along the paths control dependen...

Definition ValueTracking.cpp:7470

LLVM_ABI RetainedKnowledge getKnowledgeFromBundle(AssumeInst &Assume, const CallBase::BundleOpInfo &BOI)

This extracts the Knowledge from an element of an operand bundle.

LLVM_ABI 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,...

Definition ValueTracking.cpp:9292

auto dyn_cast_or_null(const Y &Val)

bool any_of(R &&range, UnaryPredicate P)

Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.

LLVM_ABI OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ, bool IsNSW=false)

Definition ValueTracking.cpp:7285

LLVM_ABI bool getShuffleDemandedElts(int SrcWidth, ArrayRef< int > Mask, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS, bool AllowUndefElts=false)

Transform a shuffle mask's output demanded element mask into demanded element masks for the 2 operand...

unsigned Log2_32(uint32_t Value)

Return the floor log base 2 of the specified value, -1 if the value is zero.

bool isGuard(const User *U)

Returns true iff U has semantics of a guard expressed in a form of call of llvm.experimental....

LLVM_ABI SelectPatternFlavor getInverseMinMaxFlavor(SelectPatternFlavor SPF)

Return the inverse minimum/maximum flavor of the specified flavor.

Definition ValueTracking.cpp:9186

constexpr unsigned MaxAnalysisRecursionDepth

LLVM_ABI void adjustKnownBitsForSelectArm(KnownBits &Known, Value *Cond, Value *Arm, bool Invert, const SimplifyQuery &Q, unsigned Depth=0)

Adjust Known for the given select Arm to include information from the select Cond.

Definition ValueTracking.cpp:1298

LLVM_ABI bool isKnownNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)

Returns true if the given value is known be negative (i.e.

Definition ValueTracking.cpp:298

LLVM_ABI OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)

Definition ValueTracking.cpp:7442

SelectPatternFlavor

Specific patterns of select instructions we can match.

@ SPF_ABS

Floating point maxnum.

@ SPF_NABS

Absolute value.

@ SPF_FMAXNUM

Floating point minnum.

@ SPF_UMIN

Signed minimum.

@ SPF_UMAX

Signed maximum.

@ SPF_SMAX

Unsigned minimum.

@ SPF_FMINNUM

Unsigned maximum.

LLVM_ABI bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(const CallBase *Call, bool MustPreserveNullness)

{launder,strip}.invariant.group returns pointer that aliases its argument, and it only captures point...

Definition ValueTracking.cpp:6794

LLVM_ABI bool impliesPoison(const Value *ValAssumedPoison, const Value *V)

Return true if V is poison given that ValAssumedPoison is already poison.

Definition ValueTracking.cpp:7705

LLVM_ABI void getHorizDemandedEltsForFirstOperand(unsigned VectorBitWidth, const APInt &DemandedElts, APInt &DemandedLHS, APInt &DemandedRHS)

Compute the demanded elements mask of horizontal binary operations.

LLVM_ABI SelectPatternResult getSelectPattern(CmpInst::Predicate Pred, SelectPatternNaNBehavior NaNBehavior=SPNB_NA, bool Ordered=false)

Determine the pattern for predicate X Pred Y ? X : Y.

Definition ValueTracking.cpp:8685

FPClassTest

Floating-point class tests, supported by 'is_fpclass' intrinsic.

LLVM_ABI void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)

Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...

Definition ValueTracking.cpp:152

LLVM_ABI bool programUndefinedIfPoison(const Instruction *Inst)

Definition ValueTracking.cpp:8312

LLVM_ABI SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)

Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...

Definition ValueTracking.cpp:9100

LLVM_ABI bool matchSimpleBinaryIntrinsicRecurrence(const IntrinsicInst *I, PHINode *&P, Value *&Init, Value *&OtherOp)

Attempt to match a simple value-accumulating recurrence of the form: llvm.intrinsic....

Definition ValueTracking.cpp:9312

LLVM_ABI bool NullPointerIsDefined(const Function *F, unsigned AS=0)

Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...

LLVM_ABI bool cannotBeNegativeZero(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)

Return true if we can prove that the specified FP value is never equal to -0.0.

Definition ValueTracking.cpp:6139

LLVM_ABI bool programUndefinedIfUndefOrPoison(const Instruction *Inst)

Return true if this function can prove that if Inst is executed and yields a poison value or undef bi...

Definition ValueTracking.cpp:8308

generic_gep_type_iterator<> gep_type_iterator

LLVM_ABI bool collectPossibleValues(const Value *V, SmallPtrSetImpl< const Constant * > &Constants, unsigned MaxCount, bool AllowUndefOrPoison=true)

Enumerates all possible immediate values of V and inserts them into the set Constants.

Definition ValueTracking.cpp:10512

FunctionAddr VTableAddr Count

LLVM_ABI uint64_t GetStringLength(const Value *V, unsigned CharSize=8)

If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.

Definition ValueTracking.cpp:6769

LLVM_ABI OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)

Definition ValueTracking.cpp:7301

LLVM_ABI ConstantRange getVScaleRange(const Function *F, unsigned BitWidth)

Determine the possible constant range of vscale with the given bit width, based on the vscale_range f...

Definition ValueTracking.cpp:1279

LLVM_ABI Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)

Attempt to constant fold a cast with the specified operand.

LLVM_ABI bool canCreateUndefOrPoison(const Operator *Op, bool ConsiderFlagsAndMetadata=true)

canCreateUndefOrPoison returns true if Op can create undef or poison from non-undef & non-poison oper...

Definition ValueTracking.cpp:7645

LLVM_ABI EHPersonality classifyEHPersonality(const Value *Pers)

See if the given exception handling personality function is one that we understand.

LLVM_ABI bool isKnownInversion(const Value *X, const Value *Y)

Return true iff:

Definition ValueTracking.cpp:8655

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

LLVM_ABI bool intrinsicPropagatesPoison(Intrinsic::ID IID)

Return whether this intrinsic propagates poison for all operands.

Definition ValueTracking.cpp:8025

LLVM_ABI bool isNotCrossLaneOperation(const Instruction *I)

Return true if the instruction doesn't potentially cross vector lanes.

Definition ValueTracking.cpp:7117

LLVM_ABI bool isKnownNonZero(const Value *V, const SimplifyQuery &Q, unsigned Depth=0)

Return true if the given value is known to be non-zero when defined.

Definition ValueTracking.cpp:3744

constexpr int PoisonMaskElem

LLVM_ABI RetainedKnowledge getKnowledgeValidInContext(const Value *V, ArrayRef< Attribute::AttrKind > AttrKinds, AssumptionCache &AC, const Instruction *CtxI, const DominatorTree *DT=nullptr)

Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and the know...

LLVM_ABI bool isSafeToSpeculativelyExecuteWithOpcode(unsigned Opcode, const Instruction *Inst, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true, bool IgnoreUBImplyingAttrs=true)

This returns the same result as isSafeToSpeculativelyExecute if Opcode is the actual opcode of Inst.

Definition ValueTracking.cpp:7134

LLVM_ABI bool onlyUsedByLifetimeMarkers(const Value *V)

Return true if the only users of this pointer are lifetime markers.

Definition ValueTracking.cpp:7108

LLVM_ABI Intrinsic::ID getIntrinsicForCallSite(const CallBase &CB, const TargetLibraryInfo *TLI)

Map a call instruction to an intrinsic ID.

Definition ValueTracking.cpp:4587

@ First

Helpers to iterate all locations in the MemoryEffectsBase class.

LLVM_ABI const Value * getUnderlyingObjectAggressive(const Value *V)

Like getUnderlyingObject(), but will try harder to find a single underlying object.

Definition ValueTracking.cpp:6939

LLVM_ABI Intrinsic::ID getMinMaxIntrinsic(SelectPatternFlavor SPF)

Convert given SPF to equivalent min/max intrinsic.

Definition ValueTracking.cpp:9171

LLVM_ABI SelectPatternResult matchDecomposedSelectPattern(CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS, FastMathFlags FMF=FastMathFlags(), Instruction::CastOps *CastOp=nullptr, unsigned Depth=0)

Determine the pattern that a select with the given compare as its predicate and given values as its t...

Definition ValueTracking.cpp:9121

LLVM_ABI OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)

Definition ValueTracking.cpp:7944

LLVM_ABI bool propagatesPoison(const Use &PoisonOp)

Return true if PoisonOp's user yields poison or raises UB if its operand PoisonOp is poison.

Definition ValueTracking.cpp:8100

LLVM_ABI ConstantRange computeConstantRangeIncludingKnownBits(const WithCache< const Value * > &V, bool ForSigned, const SimplifyQuery &SQ)

Combine constant ranges from computeConstantRange() and computeKnownBits().

Definition ValueTracking.cpp:7274

SelectPatternNaNBehavior

Behavior when a floating point min/max is given one NaN and one non-NaN as input.

@ SPNB_RETURNS_NAN

NaN behavior not applicable.

@ SPNB_RETURNS_OTHER

Given one NaN input, returns the NaN.

@ SPNB_RETURNS_ANY

Given one NaN input, returns the non-NaN.

LLVM_ABI bool isKnownNonEqual(const Value *V1, const Value *V2, const SimplifyQuery &SQ, unsigned Depth=0)

Return true if the given values are known to be non-equal when defined.

Definition ValueTracking.cpp:307

DWARFExpression::Operation Op

LLVM_ABI bool isGuaranteedNotToBeUndefOrPoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)

Return true if this function can prove that V does not have undef bits and is never poison.

Definition ValueTracking.cpp:7871

ArrayRef(const T &OneElt) -> ArrayRef< T >

LLVM_ABI unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)

Return the number of times the sign bit of the register is replicated into the other bits.

Definition ValueTracking.cpp:336

constexpr unsigned BitWidth

LLVM_ABI KnownBits analyzeKnownBitsFromAndXorOr(const Operator *I, const KnownBits &KnownLHS, const KnownBits &KnownRHS, const SimplifyQuery &SQ, unsigned Depth=0)

Using KnownBits LHS/RHS produce the known bits for logic op (and/xor/or).

Definition ValueTracking.cpp:1266

LLVM_ABI OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)

Definition ValueTracking.cpp:7409

LLVM_ABI bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)

Return true if this function can prove that the instruction I will always transfer execution to one o...

Definition ValueTracking.cpp:7950

LLVM_ABI bool isKnownNeverInfOrNaN(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)

Return true if the floating-point value can never contain a NaN or infinity.

Definition ValueTracking.cpp:6159

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

LLVM_ABI bool isKnownNeverNaN(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)

Return true if the floating-point scalar value is not a NaN or if the floating-point vector value has...

Definition ValueTracking.cpp:6168

gep_type_iterator gep_type_begin(const User *GEP)

LLVM_ABI Value * isBytewiseValue(Value *V, const DataLayout &DL)

If the specified value can be set by repeating the same byte in memory, return the i8 value that it i...

Definition ValueTracking.cpp:6292

LLVM_ABI std::optional< std::pair< CmpPredicate, Constant * > > getFlippedStrictnessPredicateAndConstant(CmpPredicate Pred, Constant *C)

Convert an integer comparison with a constant RHS into an equivalent form with the strictness flipped...

Definition ValueTracking.cpp:8717

LLVM_ABI unsigned ComputeMaxSignificantBits(const Value *Op, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)

Get the upper bound on bit size for this Value Op as a signed integer.

Definition ValueTracking.cpp:344

bool is_contained(R &&Range, const E &Element)

Returns true if Element is found in Range.

LLVM_ABI OverflowResult computeOverflowForUnsignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)

Definition ValueTracking.cpp:7341

unsigned Log2(Align A)

Returns the log2 of the alignment.

LLVM_ABI bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)

Return true if the given value is known to have exactly one bit set when defined.

Definition ValueTracking.cpp:268

LLVM_ABI std::optional< bool > isImpliedByDomCondition(const Value *Cond, const Instruction *ContextI, const DataLayout &DL)

Return the boolean condition value in the context of the given instruction if it is known based on do...

Definition ValueTracking.cpp:9840

LLVM_ABI bool isGuaranteedNotToBePoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)

Returns true if V cannot be poison, but may be undef.

Definition ValueTracking.cpp:7879

LLVM_ABI void computeKnownBitsFromRangeMetadata(const MDNode &Ranges, KnownBits &Known)

Compute known bits from the range metadata.

Definition ValueTracking.cpp:579

LLVM_ABI Value * FindInsertedValue(Value *V, ArrayRef< unsigned > idx_range, std::optional< BasicBlock::iterator > InsertBefore=std::nullopt)

Given an aggregate and an sequence of indices, see if the scalar value indexed is already around as a...

Definition ValueTracking.cpp:6475

LLVM_ABI bool isKnownNegation(const Value *X, const Value *Y, bool NeedNSW=false, bool AllowPoison=true)

Return true if the two given values are negation.

Definition ValueTracking.cpp:8624

LLVM_ABI const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=MaxLookupSearchDepth)

This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....

Definition ValueTracking.cpp:6850

LLVM_ABI bool isKnownPositive(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)

Returns true if the given value is known be positive (i.e.

Definition ValueTracking.cpp:286

LLVM_ABI Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)

Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...

LLVM_ABI bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)

Returns true if the give value is known to be non-negative.

Definition ValueTracking.cpp:281

LLVM_ABI bool cannotBeOrderedLessThanZero(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)

Return true if we can prove that the specified FP value is either NaN or never less than -0....

Definition ValueTracking.cpp:6145

LLVM_ABI void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, const LoopInfo *LI=nullptr, unsigned MaxLookup=MaxLookupSearchDepth)

This method is similar to getUnderlyingObject except that it can look through phi and select instruct...

Definition ValueTracking.cpp:6897

LLVM_ABI bool mayHaveNonDefUseDependency(const Instruction &I)

Returns true if the result or effects of the given instructions I depend values not reachable through...

Definition ValueTracking.cpp:7241

LLVM_ABI bool isTriviallyVectorizable(Intrinsic::ID ID)

Identify if the intrinsic is trivially vectorizable.

LLVM_ABI bool isIdentifiedObject(const Value *V)

Return true if this pointer refers to a distinct and identifiable object.

LLVM_ABI std::optional< bool > isImpliedCondition(const Value *LHS, const Value *RHS, const DataLayout &DL, bool LHSIsTrue=true, unsigned Depth=0)

Return true if RHS is known to be implied true by LHS.

Definition ValueTracking.cpp:9740

LLVM_ABI std::optional< bool > computeKnownFPSignBit(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)

Return false if we can prove that the specified FP value's sign bit is 0.

Definition ValueTracking.cpp:6177

LLVM_ABI bool canIgnoreSignBitOfNaN(const Use &U)

Return true if the sign bit of the FP value can be ignored by the user when the value is NaN.

Definition ValueTracking.cpp:6223

LLVM_ABI void findValuesAffectedByCondition(Value *Cond, bool IsAssume, function_ref< void(Value *)> InsertAffected)

Call InsertAffected on all Values whose known bits / value may be affected by the condition Cond.

Definition ValueTracking.cpp:10362

void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)

Implement std::swap in terms of BitVector swap.

This struct is a compact representation of a valid (non-zero power of two) alignment.

SmallPtrSet< Value *, 4 > AffectedValues

Represents offset+length into a ConstantDataArray.

const ConstantDataArray * Array

ConstantDataArray pointer.

Represent subnormal handling kind for floating point instruction inputs and outputs.

DenormalModeKind Input

Denormal treatment kind for floating point instruction inputs in the default floating-point environme...

constexpr bool outputsAreZero() const

Return true if output denormals should be flushed to 0.

@ PositiveZero

Denormals are flushed to positive zero.

@ IEEE

IEEE-754 denormal numbers preserved.

constexpr bool inputsAreZero() const

Return true if input denormals must be implicitly treated as 0.

DenormalModeKind Output

Denormal flushing mode for floating point instruction results in the default floating point environme...

static constexpr DenormalMode getIEEE()

InstrInfoQuery provides an interface to query additional information for instructions like metadata o...

bool isExact(const BinaryOperator *Op) const

MDNode * getMetadata(const Instruction *I, unsigned KindID) const

bool hasNoSignedZeros(const InstT *Op) const

bool hasNoSignedWrap(const InstT *Op) const

bool hasNoUnsignedWrap(const InstT *Op) const

static KnownBits makeConstant(const APInt &C)

Create known bits from a known constant.

static LLVM_ABI KnownBits sadd_sat(const KnownBits &LHS, const KnownBits &RHS)

Compute knownbits resulting from llvm.sadd.sat(LHS, RHS)

static LLVM_ABI std::optional< bool > eq(const KnownBits &LHS, const KnownBits &RHS)

Determine if these known bits always give the same ICMP_EQ result.

KnownBits anyextOrTrunc(unsigned BitWidth) const

Return known bits for an "any" extension or truncation of the value we're tracking.

static LLVM_ABI KnownBits mulhu(const KnownBits &LHS, const KnownBits &RHS)

Compute known bits from zero-extended multiply-hi.

unsigned countMinSignBits() const

Returns the number of times the sign bit is replicated into the other bits.

static LLVM_ABI KnownBits smax(const KnownBits &LHS, const KnownBits &RHS)

Compute known bits for smax(LHS, RHS).

bool isNonNegative() const

Returns true if this value is known to be non-negative.

LLVM_ABI KnownBits blsi() const

Compute known bits for X & -X, which has only the lowest bit set of X set.

void makeNonNegative()

Make this value non-negative.

static LLVM_ABI KnownBits usub_sat(const KnownBits &LHS, const KnownBits &RHS)

Compute knownbits resulting from llvm.usub.sat(LHS, RHS)

unsigned countMinLeadingOnes() const

Returns the minimum number of leading one bits.

unsigned countMinTrailingZeros() const

Returns the minimum number of trailing zero bits.

static LLVM_ABI KnownBits ashr(const KnownBits &LHS, const KnownBits &RHS, bool ShAmtNonZero=false, bool Exact=false)

Compute known bits for ashr(LHS, RHS).

static LLVM_ABI KnownBits ssub_sat(const KnownBits &LHS, const KnownBits &RHS)

Compute knownbits resulting from llvm.ssub.sat(LHS, RHS)

static LLVM_ABI KnownBits urem(const KnownBits &LHS, const KnownBits &RHS)

Compute known bits for urem(LHS, RHS).

bool isUnknown() const

Returns true if we don't know any bits.

unsigned countMaxTrailingZeros() const

Returns the maximum number of trailing zero bits possible.

LLVM_ABI KnownBits blsmsk() const

Compute known bits for X ^ (X - 1), which has all bits up to and including the lowest set bit of X se...

void makeNegative()

Make this value negative.

void setAllConflict()

Make all bits known to be both zero and one.

KnownBits trunc(unsigned BitWidth) const

Return known bits for a truncation of the value we're tracking.

KnownBits byteSwap() const

bool hasConflict() const

Returns true if there is conflicting information.

unsigned countMaxPopulation() const

Returns the maximum number of bits that could be one.

void setAllZero()

Make all bits known to be zero and discard any previous information.

KnownBits reverseBits() const

unsigned getBitWidth() const

Get the bit width of this value.

static LLVM_ABI KnownBits umax(const KnownBits &LHS, const KnownBits &RHS)

Compute known bits for umax(LHS, RHS).

KnownBits zext(unsigned BitWidth) const

Return known bits for a zero extension of the value we're tracking.

bool isConstant() const

Returns true if we know the value of all bits.

void resetAll()

Resets the known state of all bits.

KnownBits unionWith(const KnownBits &RHS) const

Returns KnownBits information that is known to be true for either this or RHS or both.

static LLVM_ABI KnownBits lshr(const KnownBits &LHS, const KnownBits &RHS, bool ShAmtNonZero=false, bool Exact=false)

Compute known bits for lshr(LHS, RHS).

bool isNonZero() const

Returns true if this value is known to be non-zero.

KnownBits extractBits(unsigned NumBits, unsigned BitPosition) const

Return a subset of the known bits from [bitPosition,bitPosition+numBits).

KnownBits intersectWith(const KnownBits &RHS) const

Returns KnownBits information that is known to be true for both this and RHS.

KnownBits sext(unsigned BitWidth) const

Return known bits for a sign extension of the value we're tracking.

unsigned countMinTrailingOnes() const

Returns the minimum number of trailing one bits.

static KnownBits add(const KnownBits &LHS, const KnownBits &RHS, bool NSW=false, bool NUW=false)

Compute knownbits resulting from addition of LHS and RHS.

KnownBits zextOrTrunc(unsigned BitWidth) const

Return known bits for a zero extension or truncation of the value we're tracking.

unsigned countMinLeadingZeros() const

Returns the minimum number of leading zero bits.

APInt getMaxValue() const

Return the maximal unsigned value possible given these KnownBits.

static LLVM_ABI KnownBits smin(const KnownBits &LHS, const KnownBits &RHS)

Compute known bits for smin(LHS, RHS).

static LLVM_ABI KnownBits mulhs(const KnownBits &LHS, const KnownBits &RHS)

Compute known bits from sign-extended multiply-hi.

static LLVM_ABI KnownBits srem(const KnownBits &LHS, const KnownBits &RHS)

Compute known bits for srem(LHS, RHS).

static LLVM_ABI KnownBits udiv(const KnownBits &LHS, const KnownBits &RHS, bool Exact=false)

Compute known bits for udiv(LHS, RHS).

APInt getMinValue() const

Return the minimal unsigned value possible given these KnownBits.

static LLVM_ABI KnownBits computeForAddSub(bool Add, bool NSW, bool NUW, const KnownBits &LHS, const KnownBits &RHS)

Compute known bits resulting from adding LHS and RHS.

static LLVM_ABI KnownBits sdiv(const KnownBits &LHS, const KnownBits &RHS, bool Exact=false)

Compute known bits for sdiv(LHS, RHS).

static bool haveNoCommonBitsSet(const KnownBits &LHS, const KnownBits &RHS)

Return true if LHS and RHS have no common bits set.

bool isNegative() const

Returns true if this value is known to be negative.

static KnownBits sub(const KnownBits &LHS, const KnownBits &RHS, bool NSW=false, bool NUW=false)

Compute knownbits resulting from subtraction of LHS and RHS.

unsigned countMaxLeadingZeros() const

Returns the maximum number of leading zero bits possible.

void setAllOnes()

Make all bits known to be one and discard any previous information.

void insertBits(const KnownBits &SubBits, unsigned BitPosition)

Insert the bits from a smaller known bits starting at bitPosition.

static LLVM_ABI KnownBits uadd_sat(const KnownBits &LHS, const KnownBits &RHS)

Compute knownbits resulting from llvm.uadd.sat(LHS, RHS)

static LLVM_ABI KnownBits mul(const KnownBits &LHS, const KnownBits &RHS, bool NoUndefSelfMultiply=false)

Compute known bits resulting from multiplying LHS and RHS.

KnownBits anyext(unsigned BitWidth) const

Return known bits for an "any" extension of the value we're tracking, where we don't know anything ab...

LLVM_ABI KnownBits abs(bool IntMinIsPoison=false) const

Compute known bits for the absolute value.

static LLVM_ABI std::optional< bool > sgt(const KnownBits &LHS, const KnownBits &RHS)

Determine if these known bits always give the same ICMP_SGT result.

static LLVM_ABI std::optional< bool > uge(const KnownBits &LHS, const KnownBits &RHS)

Determine if these known bits always give the same ICMP_UGE result.

static LLVM_ABI KnownBits shl(const KnownBits &LHS, const KnownBits &RHS, bool NUW=false, bool NSW=false, bool ShAmtNonZero=false)

Compute known bits for shl(LHS, RHS).

static LLVM_ABI KnownBits umin(const KnownBits &LHS, const KnownBits &RHS)

Compute known bits for umin(LHS, RHS).

KnownBits sextOrTrunc(unsigned BitWidth) const

Return known bits for a sign extension or truncation of the value we're tracking.

FPClassTest KnownFPClasses

Floating-point classes the value could be one of.

bool isKnownNeverInfinity() const

Return true if it's known this can never be an infinity.

bool cannotBeOrderedGreaterThanZero() const

Return true if we can prove that the analyzed floating-point value is either NaN or never greater tha...

static constexpr FPClassTest OrderedGreaterThanZeroMask

static constexpr FPClassTest OrderedLessThanZeroMask

void knownNot(FPClassTest RuleOut)

void copysign(const KnownFPClass &Sign)

bool isKnownNeverSubnormal() const

Return true if it's known this can never be a subnormal.

LLVM_ABI bool isKnownNeverLogicalZero(DenormalMode Mode) const

Return true if it's know this can never be interpreted as a zero.

bool isKnownNeverNegInfinity() const

Return true if it's known this can never be -infinity.

bool isKnownNeverNegSubnormal() const

Return true if it's known this can never be a negative subnormal.

bool isKnownNeverPosZero() const

Return true if it's known this can never be a literal positive zero.

std::optional< bool > SignBit

std::nullopt if the sign bit is unknown, true if the sign bit is definitely set or false if the sign ...

bool isKnownNeverNaN() const

Return true if it's known this can never be a nan.

bool isKnownNever(FPClassTest Mask) const

Return true if it's known this can never be one of the mask entries.

bool isKnownNeverNegZero() const

Return true if it's known this can never be a negative zero.

void propagateNaN(const KnownFPClass &Src, bool PreserveSign=false)

bool cannotBeOrderedLessThanZero() const

Return true if we can prove that the analyzed floating-point value is either NaN or never less than -...

void signBitMustBeOne()

Assume the sign bit is one.

LLVM_ABI void propagateCanonicalizingSrc(const KnownFPClass &Src, DenormalMode Mode)

Report known classes if Src is evaluated through a potentially canonicalizing operation.

void signBitMustBeZero()

Assume the sign bit is zero.

LLVM_ABI bool isKnownNeverLogicalPosZero(DenormalMode Mode) const

Return true if it's know this can never be interpreted as a positive zero.

bool isKnownNeverPosInfinity() const

Return true if it's known this can never be +infinity.

LLVM_ABI bool isKnownNeverLogicalNegZero(DenormalMode Mode) const

Return true if it's know this can never be interpreted as a negative zero.

bool isKnownNeverPosSubnormal() const

Return true if it's known this can never be a positive subnormal.

Represent one information held inside an operand bundle of an llvm.assume.

SelectPatternFlavor Flavor

static bool isMinOrMax(SelectPatternFlavor SPF)

When implementing this min/max pattern as fcmp; select, does the fcmp have to be ordered?

SimplifyQuery getWithoutCondContext() const

SimplifyQuery getWithInstruction(const Instruction *I) const

const DomConditionCache * DC