/build/source/llvm/lib/Analysis/InstructionSimplify.cpp

Bug Summary

File:	build/source/llvm/lib/Analysis/InstructionSimplify.cpp
Warning:	line 6535, column 9 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name InstructionSimplify.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm -resource-dir /usr/lib/llvm-17/lib/clang/17 -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I lib/Analysis -I /build/source/llvm/lib/Analysis -I include -I /build/source/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm=build-llvm -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm=build-llvm -fcoverage-prefix-map=/build/source/= -source-date-epoch 1679443490 -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-03-22-005342-16304-1 -x c++ /build/source/llvm/lib/Analysis/InstructionSimplify.cpp

/build/source/llvm/lib/Analysis/InstructionSimplify.cpp

→

1//===- InstructionSimplify.cpp - Fold instruction operands ----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements routines for folding instructions into simpler forms
10// that do not require creating new instructions.  This does constant folding
11// ("add i32 1, 1" -> "2") but can also handle non-constant operands, either
12// returning a constant ("and i32 %x, 0" -> "0") or an already existing value
13// ("and i32 %x, %x" -> "%x").  All operands are assumed to have already been
14// simplified: This is usually true and assuming it simplifies the logic (if
15// they have not been simplified then results are correct but maybe suboptimal).
16//
17//===----------------------------------------------------------------------===//

19#include "llvm/Analysis/InstructionSimplify.h"

21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/SetVector.h"
23#include "llvm/ADT/Statistic.h"
24#include "llvm/Analysis/AliasAnalysis.h"
25#include "llvm/Analysis/AssumptionCache.h"
26#include "llvm/Analysis/CaptureTracking.h"
27#include "llvm/Analysis/CmpInstAnalysis.h"
28#include "llvm/Analysis/ConstantFolding.h"
29#include "llvm/Analysis/InstSimplifyFolder.h"
30#include "llvm/Analysis/LoopAnalysisManager.h"
31#include "llvm/Analysis/MemoryBuiltins.h"
32#include "llvm/Analysis/OverflowInstAnalysis.h"
33#include "llvm/Analysis/ValueTracking.h"
34#include "llvm/Analysis/VectorUtils.h"
35#include "llvm/IR/ConstantRange.h"
36#include "llvm/IR/DataLayout.h"
37#include "llvm/IR/Dominators.h"
38#include "llvm/IR/InstrTypes.h"
39#include "llvm/IR/Instructions.h"
40#include "llvm/IR/Operator.h"
41#include "llvm/IR/PatternMatch.h"
42#include "llvm/Support/KnownBits.h"
43#include <algorithm>
44#include <optional>
45using namespace llvm;
46using namespace llvm::PatternMatch;

48#define DEBUG_TYPE"instsimplify" "instsimplify"

50enum { RecursionLimit = 3 };

52STATISTIC(NumExpand, "Number of expansions")static llvm::Statistic NumExpand = {"instsimplify", "NumExpand"
, "Number of expansions"};
53STATISTIC(NumReassoc, "Number of reassociations")static llvm::Statistic NumReassoc = {"instsimplify", "NumReassoc"
, "Number of reassociations"};

55static Value *simplifyAndInst(Value *, Value *, const SimplifyQuery &,
                            unsigned);
57static Value *simplifyUnOp(unsigned, Value *, const SimplifyQuery &, unsigned);
58static Value *simplifyFPUnOp(unsigned, Value *, const FastMathFlags &,
                           const SimplifyQuery &, unsigned);
60static Value *simplifyBinOp(unsigned, Value *, Value *, const SimplifyQuery &,
                          unsigned);
62static Value *simplifyBinOp(unsigned, Value *, Value *, const FastMathFlags &,
                          const SimplifyQuery &, unsigned);
64static Value *simplifyCmpInst(unsigned, Value *, Value *, const SimplifyQuery &,
                            unsigned);
66static Value *simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                             const SimplifyQuery &Q, unsigned MaxRecurse);
68static Value *simplifyOrInst(Value *, Value *, const SimplifyQuery &, unsigned);
69static Value *simplifyXorInst(Value *, Value *, const SimplifyQuery &,
                            unsigned);
71static Value *simplifyCastInst(unsigned, Value *, Type *, const SimplifyQuery &,
                             unsigned);
73static Value *simplifyGEPInst(Type *, Value *, ArrayRef<Value *>, bool,
                            const SimplifyQuery &, unsigned);
75static Value *simplifySelectInst(Value *, Value *, Value *,
                               const SimplifyQuery &, unsigned);

78static Value *foldSelectWithBinaryOp(Value *Cond, Value *TrueVal,
                                   Value *FalseVal) {
BinaryOperator::BinaryOps BinOpCode;
if (auto *BO = dyn_cast<BinaryOperator>(Cond))
  BinOpCode = BO->getOpcode();
else
  return nullptr;

CmpInst::Predicate ExpectedPred, Pred1, Pred2;
if (BinOpCode == BinaryOperator::Or) {
  ExpectedPred = ICmpInst::ICMP_NE;
} else if (BinOpCode == BinaryOperator::And) {
  ExpectedPred = ICmpInst::ICMP_EQ;
} else
  return nullptr;

// %A = icmp eq %TV, %FV
// %B = icmp eq %X, %Y (and one of these is a select operand)
// %C = and %A, %B
// %D = select %C, %TV, %FV
// -->
// %FV

// %A = icmp ne %TV, %FV
// %B = icmp ne %X, %Y (and one of these is a select operand)
// %C = or %A, %B
// %D = select %C, %TV, %FV
// -->
// %TV
Value *X, *Y;
if (!match(Cond, m_c_BinOp(m_c_ICmp(Pred1, m_Specific(TrueVal),
                                    m_Specific(FalseVal)),
                           m_ICmp(Pred2, m_Value(X), m_Value(Y)))) ||
    Pred1 != Pred2 || Pred1 != ExpectedPred)
  return nullptr;

if (X == TrueVal || X == FalseVal || Y == TrueVal || Y == FalseVal)
  return BinOpCode == BinaryOperator::Or ? TrueVal : FalseVal;

return nullptr;
118}

120/// For a boolean type or a vector of boolean type, return false or a vector
121/// with every element false.
122static Constant *getFalse(Type *Ty) { return ConstantInt::getFalse(Ty); }

124/// For a boolean type or a vector of boolean type, return true or a vector
125/// with every element true.
126static Constant *getTrue(Type *Ty) { return ConstantInt::getTrue(Ty); }

128/// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"?
129static bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS,
                        Value *RHS) {
CmpInst *Cmp = dyn_cast<CmpInst>(V);
if (!Cmp)
  return false;
CmpInst::Predicate CPred = Cmp->getPredicate();
Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1);
if (CPred == Pred && CLHS == LHS && CRHS == RHS)
  return true;
return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS &&
       CRHS == LHS;
140}

142/// Simplify comparison with true or false branch of select:
143///  %sel = select i1 %cond, i32 %tv, i32 %fv
144///  %cmp = icmp sle i32 %sel, %rhs
145/// Compose new comparison by substituting %sel with either %tv or %fv
146/// and see if it simplifies.
147static Value *simplifyCmpSelCase(CmpInst::Predicate Pred, Value *LHS,
                               Value *RHS, Value *Cond,
                               const SimplifyQuery &Q, unsigned MaxRecurse,
                               Constant *TrueOrFalse) {
Value *SimplifiedCmp = simplifyCmpInst(Pred, LHS, RHS, Q, MaxRecurse);
if (SimplifiedCmp == Cond) {
  // %cmp simplified to the select condition (%cond).
  return TrueOrFalse;
} else if (!SimplifiedCmp && isSameCompare(Cond, Pred, LHS, RHS)) {
  // It didn't simplify. However, if composed comparison is equivalent
  // to the select condition (%cond) then we can replace it.
  return TrueOrFalse;
}
return SimplifiedCmp;
161}

163/// Simplify comparison with true branch of select
164static Value *simplifyCmpSelTrueCase(CmpInst::Predicate Pred, Value *LHS,
                                   Value *RHS, Value *Cond,
                                   const SimplifyQuery &Q,
                                   unsigned MaxRecurse) {
return simplifyCmpSelCase(Pred, LHS, RHS, Cond, Q, MaxRecurse,
                          getTrue(Cond->getType()));
170}

172/// Simplify comparison with false branch of select
173static Value *simplifyCmpSelFalseCase(CmpInst::Predicate Pred, Value *LHS,
                                    Value *RHS, Value *Cond,
                                    const SimplifyQuery &Q,
                                    unsigned MaxRecurse) {
return simplifyCmpSelCase(Pred, LHS, RHS, Cond, Q, MaxRecurse,
                          getFalse(Cond->getType()));
179}

181/// We know comparison with both branches of select can be simplified, but they
182/// are not equal. This routine handles some logical simplifications.
183static Value *handleOtherCmpSelSimplifications(Value *TCmp, Value *FCmp,
                                             Value *Cond,
                                             const SimplifyQuery &Q,
                                             unsigned MaxRecurse) {
// If the false value simplified to false, then the result of the compare
// is equal to "Cond && TCmp".  This also catches the case when the false
// value simplified to false and the true value to true, returning "Cond".
// Folding select to and/or isn't poison-safe in general; impliesPoison
// checks whether folding it does not convert a well-defined value into
// poison.
if (match(FCmp, m_Zero()) && impliesPoison(TCmp, Cond))
  if (Value *V = simplifyAndInst(Cond, TCmp, Q, MaxRecurse))
    return V;
// If the true value simplified to true, then the result of the compare
// is equal to "Cond || FCmp".
if (match(TCmp, m_One()) && impliesPoison(FCmp, Cond))
  if (Value *V = simplifyOrInst(Cond, FCmp, Q, MaxRecurse))
    return V;
// Finally, if the false value simplified to true and the true value to
// false, then the result of the compare is equal to "!Cond".
if (match(FCmp, m_One()) && match(TCmp, m_Zero()))
  if (Value *V = simplifyXorInst(
          Cond, Constant::getAllOnesValue(Cond->getType()), Q, MaxRecurse))
    return V;
return nullptr;
208}

210/// Does the given value dominate the specified phi node?
211static bool valueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) {
Instruction *I = dyn_cast<Instruction>(V);
if (!I)
  // Arguments and constants dominate all instructions.
  return true;

// If we are processing instructions (and/or basic blocks) that have not been
// fully added to a function, the parent nodes may still be null. Simply
// return the conservative answer in these cases.
if (!I->getParent() || !P->getParent() || !I->getFunction())
  return false;

// If we have a DominatorTree then do a precise test.
if (DT)
  return DT->dominates(I, P);

// Otherwise, if the instruction is in the entry block and is not an invoke,
// then it obviously dominates all phi nodes.
if (I->getParent()->isEntryBlock() && !isa<InvokeInst>(I) &&
    !isa<CallBrInst>(I))
  return true;

return false;
234}

236/// Try to simplify a binary operator of form "V op OtherOp" where V is
237/// "(B0 opex B1)" by distributing 'op' across 'opex' as
238/// "(B0 op OtherOp) opex (B1 op OtherOp)".
239static Value *expandBinOp(Instruction::BinaryOps Opcode, Value *V,
                        Value *OtherOp, Instruction::BinaryOps OpcodeToExpand,
                        const SimplifyQuery &Q, unsigned MaxRecurse) {
auto *B = dyn_cast<BinaryOperator>(V);
if (!B || B->getOpcode() != OpcodeToExpand)
  return nullptr;
Value *B0 = B->getOperand(0), *B1 = B->getOperand(1);
Value *L =
    simplifyBinOp(Opcode, B0, OtherOp, Q.getWithoutUndef(), MaxRecurse);
if (!L)
  return nullptr;
Value *R =
    simplifyBinOp(Opcode, B1, OtherOp, Q.getWithoutUndef(), MaxRecurse);
if (!R)
  return nullptr;

// Does the expanded pair of binops simplify to the existing binop?
if ((L == B0 && R == B1) ||
    (Instruction::isCommutative(OpcodeToExpand) && L == B1 && R == B0)) {
  ++NumExpand;
  return B;
}

// Otherwise, return "L op' R" if it simplifies.
Value *S = simplifyBinOp(OpcodeToExpand, L, R, Q, MaxRecurse);
if (!S)
  return nullptr;

++NumExpand;
return S;
269}

271/// Try to simplify binops of form "A op (B op' C)" or the commuted variant by
272/// distributing op over op'.
273static Value *expandCommutativeBinOp(Instruction::BinaryOps Opcode, Value *L,
                                   Value *R,
                                   Instruction::BinaryOps OpcodeToExpand,
                                   const SimplifyQuery &Q,
                                   unsigned MaxRecurse) {
// Recursion is always used, so bail out at once if we already hit the limit.
if (!MaxRecurse--)
  return nullptr;

if (Value *V = expandBinOp(Opcode, L, R, OpcodeToExpand, Q, MaxRecurse))
  return V;
if (Value *V = expandBinOp(Opcode, R, L, OpcodeToExpand, Q, MaxRecurse))
  return V;
return nullptr;
287}

289/// Generic simplifications for associative binary operations.
290/// Returns the simpler value, or null if none was found.
291static Value *simplifyAssociativeBinOp(Instruction::BinaryOps Opcode,
                                     Value *LHS, Value *RHS,
                                     const SimplifyQuery &Q,
                                     unsigned MaxRecurse) {
assert(Instruction::isAssociative(Opcode) && "Not an associative operation!")(static_cast <bool> (Instruction::isAssociative(Opcode)
 && "Not an associative operation!") ? void (0) : __assert_fail
 ("Instruction::isAssociative(Opcode) && \"Not an associative operation!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 295, __extension__
 __PRETTY_FUNCTION__));

// Recursion is always used, so bail out at once if we already hit the limit.
if (!MaxRecurse--)
  return nullptr;

BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS);
BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS);

// Transform: "(A op B) op C" ==> "A op (B op C)" if it simplifies completely.
if (Op0 && Op0->getOpcode() == Opcode) {
  Value *A = Op0->getOperand(0);
  Value *B = Op0->getOperand(1);
  Value *C = RHS;

  // Does "B op C" simplify?
  if (Value *V = simplifyBinOp(Opcode, B, C, Q, MaxRecurse)) {
    // It does!  Return "A op V" if it simplifies or is already available.
    // If V equals B then "A op V" is just the LHS.
    if (V == B)
      return LHS;
    // Otherwise return "A op V" if it simplifies.
    if (Value *W = simplifyBinOp(Opcode, A, V, Q, MaxRecurse)) {
      ++NumReassoc;
      return W;
    }
  }
}

// Transform: "A op (B op C)" ==> "(A op B) op C" if it simplifies completely.
if (Op1 && Op1->getOpcode() == Opcode) {
  Value *A = LHS;
  Value *B = Op1->getOperand(0);
  Value *C = Op1->getOperand(1);

  // Does "A op B" simplify?
  if (Value *V = simplifyBinOp(Opcode, A, B, Q, MaxRecurse)) {
    // It does!  Return "V op C" if it simplifies or is already available.
    // If V equals B then "V op C" is just the RHS.
    if (V == B)
      return RHS;
    // Otherwise return "V op C" if it simplifies.
    if (Value *W = simplifyBinOp(Opcode, V, C, Q, MaxRecurse)) {
      ++NumReassoc;
      return W;
    }
  }
}

// The remaining transforms require commutativity as well as associativity.
if (!Instruction::isCommutative(Opcode))
  return nullptr;

// Transform: "(A op B) op C" ==> "(C op A) op B" if it simplifies completely.
if (Op0 && Op0->getOpcode() == Opcode) {
  Value *A = Op0->getOperand(0);
  Value *B = Op0->getOperand(1);
  Value *C = RHS;

  // Does "C op A" simplify?
  if (Value *V = simplifyBinOp(Opcode, C, A, Q, MaxRecurse)) {
    // It does!  Return "V op B" if it simplifies or is already available.
    // If V equals A then "V op B" is just the LHS.
    if (V == A)
      return LHS;
    // Otherwise return "V op B" if it simplifies.
    if (Value *W = simplifyBinOp(Opcode, V, B, Q, MaxRecurse)) {
      ++NumReassoc;
      return W;
    }
  }
}

// Transform: "A op (B op C)" ==> "B op (C op A)" if it simplifies completely.
if (Op1 && Op1->getOpcode() == Opcode) {
  Value *A = LHS;
  Value *B = Op1->getOperand(0);
  Value *C = Op1->getOperand(1);

  // Does "C op A" simplify?
  if (Value *V = simplifyBinOp(Opcode, C, A, Q, MaxRecurse)) {
    // It does!  Return "B op V" if it simplifies or is already available.
    // If V equals C then "B op V" is just the RHS.
    if (V == C)
      return RHS;
    // Otherwise return "B op V" if it simplifies.
    if (Value *W = simplifyBinOp(Opcode, B, V, Q, MaxRecurse)) {
      ++NumReassoc;
      return W;
    }
  }
}

return nullptr;
389}

391/// In the case of a binary operation with a select instruction as an operand,
392/// try to simplify the binop by seeing whether evaluating it on both branches
393/// of the select results in the same value. Returns the common value if so,
394/// otherwise returns null.
395static Value *threadBinOpOverSelect(Instruction::BinaryOps Opcode, Value *LHS,
                                  Value *RHS, const SimplifyQuery &Q,
                                  unsigned MaxRecurse) {
// Recursion is always used, so bail out at once if we already hit the limit.
if (!MaxRecurse--)
  return nullptr;

SelectInst *SI;
if (isa<SelectInst>(LHS)) {
  SI = cast<SelectInst>(LHS);
} else {
  assert(isa<SelectInst>(RHS) && "No select instruction operand!")(static_cast <bool> (isa<SelectInst>(RHS) &&
 "No select instruction operand!") ? void (0) : __assert_fail
 ("isa<SelectInst>(RHS) && \"No select instruction operand!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 406, __extension__
 __PRETTY_FUNCTION__));
  SI = cast<SelectInst>(RHS);
}

// Evaluate the BinOp on the true and false branches of the select.
Value *TV;
Value *FV;
if (SI == LHS) {
  TV = simplifyBinOp(Opcode, SI->getTrueValue(), RHS, Q, MaxRecurse);
  FV = simplifyBinOp(Opcode, SI->getFalseValue(), RHS, Q, MaxRecurse);
} else {
  TV = simplifyBinOp(Opcode, LHS, SI->getTrueValue(), Q, MaxRecurse);
  FV = simplifyBinOp(Opcode, LHS, SI->getFalseValue(), Q, MaxRecurse);
}

// If they simplified to the same value, then return the common value.
// If they both failed to simplify then return null.
if (TV == FV)
  return TV;

// If one branch simplified to undef, return the other one.
if (TV && Q.isUndefValue(TV))
  return FV;
if (FV && Q.isUndefValue(FV))
  return TV;

// If applying the operation did not change the true and false select values,
// then the result of the binop is the select itself.
if (TV == SI->getTrueValue() && FV == SI->getFalseValue())
  return SI;

// If one branch simplified and the other did not, and the simplified
// value is equal to the unsimplified one, return the simplified value.
// For example, select (cond, X, X & Z) & Z -> X & Z.
if ((FV && !TV) || (TV && !FV)) {
  // Check that the simplified value has the form "X op Y" where "op" is the
  // same as the original operation.
  Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV);
  if (Simplified && Simplified->getOpcode() == unsigned(Opcode)) {
    // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS".
    // We already know that "op" is the same as for the simplified value.  See
    // if the operands match too.  If so, return the simplified value.
    Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue();
    Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS;
    Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch;
    if (Simplified->getOperand(0) == UnsimplifiedLHS &&
        Simplified->getOperand(1) == UnsimplifiedRHS)
      return Simplified;
    if (Simplified->isCommutative() &&
        Simplified->getOperand(1) == UnsimplifiedLHS &&
        Simplified->getOperand(0) == UnsimplifiedRHS)
      return Simplified;
  }
}

return nullptr;
462}

464/// In the case of a comparison with a select instruction, try to simplify the
465/// comparison by seeing whether both branches of the select result in the same
466/// value. Returns the common value if so, otherwise returns null.
467/// For example, if we have:
468///  %tmp = select i1 %cmp, i32 1, i32 2
469///  %cmp1 = icmp sle i32 %tmp, 3
470/// We can simplify %cmp1 to true, because both branches of select are
471/// less than 3. We compose new comparison by substituting %tmp with both
472/// branches of select and see if it can be simplified.
473static Value *threadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS,
                                Value *RHS, const SimplifyQuery &Q,
                                unsigned MaxRecurse) {
// Recursion is always used, so bail out at once if we already hit the limit.
if (!MaxRecurse--)
  return nullptr;

// Make sure the select is on the LHS.
if (!isa<SelectInst>(LHS)) {
  std::swap(LHS, RHS);
  Pred = CmpInst::getSwappedPredicate(Pred);
}
assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!")(static_cast <bool> (isa<SelectInst>(LHS) &&
 "Not comparing with a select instruction!") ? void (0) : __assert_fail
 ("isa<SelectInst>(LHS) && \"Not comparing with a select instruction!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 485, __extension__
 __PRETTY_FUNCTION__));
SelectInst *SI = cast<SelectInst>(LHS);
Value *Cond = SI->getCondition();
Value *TV = SI->getTrueValue();
Value *FV = SI->getFalseValue();

// Now that we have "cmp select(Cond, TV, FV), RHS", analyse it.
// Does "cmp TV, RHS" simplify?
Value *TCmp = simplifyCmpSelTrueCase(Pred, TV, RHS, Cond, Q, MaxRecurse);
if (!TCmp)
  return nullptr;

// Does "cmp FV, RHS" simplify?
Value *FCmp = simplifyCmpSelFalseCase(Pred, FV, RHS, Cond, Q, MaxRecurse);
if (!FCmp)
  return nullptr;

// If both sides simplified to the same value, then use it as the result of
// the original comparison.
if (TCmp == FCmp)
  return TCmp;

// The remaining cases only make sense if the select condition has the same
// type as the result of the comparison, so bail out if this is not so.
if (Cond->getType()->isVectorTy() == RHS->getType()->isVectorTy())
  return handleOtherCmpSelSimplifications(TCmp, FCmp, Cond, Q, MaxRecurse);

return nullptr;
513}

515/// In the case of a binary operation with an operand that is a PHI instruction,
516/// try to simplify the binop by seeing whether evaluating it on the incoming
517/// phi values yields the same result for every value. If so returns the common
518/// value, otherwise returns null.
519static Value *threadBinOpOverPHI(Instruction::BinaryOps Opcode, Value *LHS,
                               Value *RHS, const SimplifyQuery &Q,
                               unsigned MaxRecurse) {
// Recursion is always used, so bail out at once if we already hit the limit.
if (!MaxRecurse--)
  return nullptr;

PHINode *PI;
if (isa<PHINode>(LHS)) {
  PI = cast<PHINode>(LHS);
  // Bail out if RHS and the phi may be mutually interdependent due to a loop.
  if (!valueDominatesPHI(RHS, PI, Q.DT))
    return nullptr;
} else {
  assert(isa<PHINode>(RHS) && "No PHI instruction operand!")(static_cast <bool> (isa<PHINode>(RHS) &&
 "No PHI instruction operand!") ? void (0) : __assert_fail ("isa<PHINode>(RHS) && \"No PHI instruction operand!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 533, __extension__
 __PRETTY_FUNCTION__));
  PI = cast<PHINode>(RHS);
  // Bail out if LHS and the phi may be mutually interdependent due to a loop.
  if (!valueDominatesPHI(LHS, PI, Q.DT))
    return nullptr;
}

// Evaluate the BinOp on the incoming phi values.
Value *CommonValue = nullptr;
for (Use &Incoming : PI->incoming_values()) {
  // If the incoming value is the phi node itself, it can safely be skipped.
  if (Incoming == PI)
    continue;
  Instruction *InTI = PI->getIncomingBlock(Incoming)->getTerminator();
  Value *V = PI == LHS
                 ? simplifyBinOp(Opcode, Incoming, RHS,
                                 Q.getWithInstruction(InTI), MaxRecurse)
                 : simplifyBinOp(Opcode, LHS, Incoming,
                                 Q.getWithInstruction(InTI), MaxRecurse);
  // If the operation failed to simplify, or simplified to a different value
  // to previously, then give up.
  if (!V || (CommonValue && V != CommonValue))
    return nullptr;
  CommonValue = V;
}

return CommonValue;
560}

562/// In the case of a comparison with a PHI instruction, try to simplify the
563/// comparison by seeing whether comparing with all of the incoming phi values
564/// yields the same result every time. If so returns the common result,
565/// otherwise returns null.
566static Value *threadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS,
                             const SimplifyQuery &Q, unsigned MaxRecurse) {
// Recursion is always used, so bail out at once if we already hit the limit.
if (!MaxRecurse--)
  return nullptr;

// Make sure the phi is on the LHS.
if (!isa<PHINode>(LHS)) {
  std::swap(LHS, RHS);
  Pred = CmpInst::getSwappedPredicate(Pred);
}
assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!")(static_cast <bool> (isa<PHINode>(LHS) &&
 "Not comparing with a phi instruction!") ? void (0) : __assert_fail
 ("isa<PHINode>(LHS) && \"Not comparing with a phi instruction!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 577, __extension__
 __PRETTY_FUNCTION__));
PHINode *PI = cast<PHINode>(LHS);

// Bail out if RHS and the phi may be mutually interdependent due to a loop.
if (!valueDominatesPHI(RHS, PI, Q.DT))
  return nullptr;

// Evaluate the BinOp on the incoming phi values.
Value *CommonValue = nullptr;
for (unsigned u = 0, e = PI->getNumIncomingValues(); u < e; ++u) {
  Value *Incoming = PI->getIncomingValue(u);
  Instruction *InTI = PI->getIncomingBlock(u)->getTerminator();
  // If the incoming value is the phi node itself, it can safely be skipped.
  if (Incoming == PI)
    continue;
  // Change the context instruction to the "edge" that flows into the phi.
  // This is important because that is where incoming is actually "evaluated"
  // even though it is used later somewhere else.
  Value *V = simplifyCmpInst(Pred, Incoming, RHS, Q.getWithInstruction(InTI),
                             MaxRecurse);
  // If the operation failed to simplify, or simplified to a different value
  // to previously, then give up.
  if (!V || (CommonValue && V != CommonValue))
    return nullptr;
  CommonValue = V;
}

return CommonValue;
605}

607static Constant *foldOrCommuteConstant(Instruction::BinaryOps Opcode,
                                     Value *&Op0, Value *&Op1,
                                     const SimplifyQuery &Q) {
if (auto *CLHS = dyn_cast<Constant>(Op0)) {
  if (auto *CRHS = dyn_cast<Constant>(Op1)) {
    switch (Opcode) {
    default:
      break;
    case Instruction::FAdd:
    case Instruction::FSub:
    case Instruction::FMul:
    case Instruction::FDiv:
    case Instruction::FRem:
      if (Q.CxtI != nullptr)
        return ConstantFoldFPInstOperands(Opcode, CLHS, CRHS, Q.DL, Q.CxtI);
    }
    return ConstantFoldBinaryOpOperands(Opcode, CLHS, CRHS, Q.DL);
  }

  // Canonicalize the constant to the RHS if this is a commutative operation.
  if (Instruction::isCommutative(Opcode))
    std::swap(Op0, Op1);
}
return nullptr;
631}

633/// Given operands for an Add, see if we can fold the result.
634/// If not, this returns null.
635static Value *simplifyAddInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                            const SimplifyQuery &Q, unsigned MaxRecurse) {
if (Constant *C = foldOrCommuteConstant(Instruction::Add, Op0, Op1, Q))
  return C;

// X + poison -> poison
if (isa<PoisonValue>(Op1))
  return Op1;

// X + undef -> undef
if (Q.isUndefValue(Op1))
  return Op1;

// X + 0 -> X
if (match(Op1, m_Zero()))
  return Op0;

// If two operands are negative, return 0.
if (isKnownNegation(Op0, Op1))
  return Constant::getNullValue(Op0->getType());

// X + (Y - X) -> Y
// (Y - X) + X -> Y
// Eg: X + -X -> 0
Value *Y = nullptr;
if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) ||
    match(Op0, m_Sub(m_Value(Y), m_Specific(Op1))))
  return Y;

// X + ~X -> -1   since   ~X = -X-1
Type *Ty = Op0->getType();
if (match(Op0, m_Not(m_Specific(Op1))) || match(Op1, m_Not(m_Specific(Op0))))
  return Constant::getAllOnesValue(Ty);

// add nsw/nuw (xor Y, signmask), signmask --> Y
// The no-wrapping add guarantees that the top bit will be set by the add.
// Therefore, the xor must be clearing the already set sign bit of Y.
if ((IsNSW || IsNUW) && match(Op1, m_SignMask()) &&
    match(Op0, m_Xor(m_Value(Y), m_SignMask())))
  return Y;

// add nuw %x, -1  ->  -1, because %x can only be 0.
if (IsNUW && match(Op1, m_AllOnes()))
  return Op1; // Which is -1.

/// i1 add -> xor.
if (MaxRecurse && Op0->getType()->isIntOrIntVectorTy(1))
  if (Value *V = simplifyXorInst(Op0, Op1, Q, MaxRecurse - 1))
    return V;

// Try some generic simplifications for associative operations.
if (Value *V =
        simplifyAssociativeBinOp(Instruction::Add, Op0, Op1, Q, MaxRecurse))
  return V;

// Threading Add over selects and phi nodes is pointless, so don't bother.
// Threading over the select in "A + select(cond, B, C)" means evaluating
// "A+B" and "A+C" and seeing if they are equal; but they are equal if and
// only if B and C are equal.  If B and C are equal then (since we assume
// that operands have already been simplified) "select(cond, B, C)" should
// have been simplified to the common value of B and C already.  Analysing
// "A+B" and "A+C" thus gains nothing, but costs compile time.  Similarly
// for threading over phi nodes.

return nullptr;
700}

702Value *llvm::simplifyAddInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                           const SimplifyQuery &Query) {
return ::simplifyAddInst(Op0, Op1, IsNSW, IsNUW, Query, RecursionLimit);
705}

707/// Compute the base pointer and cumulative constant offsets for V.
708///
709/// This strips all constant offsets off of V, leaving it the base pointer, and
710/// accumulates the total constant offset applied in the returned constant.
711/// It returns zero if there are no constant offsets applied.
712///
713/// This is very similar to stripAndAccumulateConstantOffsets(), except it
714/// normalizes the offset bitwidth to the stripped pointer type, not the
715/// original pointer type.
716static APInt stripAndComputeConstantOffsets(const DataLayout &DL, Value *&V,
                                          bool AllowNonInbounds = false) {
assert(V->getType()->isPtrOrPtrVectorTy())(static_cast <bool> (V->getType()->isPtrOrPtrVectorTy
()) ? void (0) : __assert_fail ("V->getType()->isPtrOrPtrVectorTy()"
, "llvm/lib/Analysis/InstructionSimplify.cpp", 718, __extension__
 __PRETTY_FUNCTION__));

APInt Offset = APInt::getZero(DL.getIndexTypeSizeInBits(V->getType()));
V = V->stripAndAccumulateConstantOffsets(DL, Offset, AllowNonInbounds);
// As that strip may trace through `addrspacecast`, need to sext or trunc
// the offset calculated.
return Offset.sextOrTrunc(DL.getIndexTypeSizeInBits(V->getType()));
725}

727/// Compute the constant difference between two pointer values.
728/// If the difference is not a constant, returns zero.
729static Constant *computePointerDifference(const DataLayout &DL, Value *LHS,
                                        Value *RHS) {
APInt LHSOffset = stripAndComputeConstantOffsets(DL, LHS);
APInt RHSOffset = stripAndComputeConstantOffsets(DL, RHS);

// If LHS and RHS are not related via constant offsets to the same base
// value, there is nothing we can do here.
if (LHS != RHS)
  return nullptr;

// Otherwise, the difference of LHS - RHS can be computed as:
//    LHS - RHS
//  = (LHSOffset + Base) - (RHSOffset + Base)
//  = LHSOffset - RHSOffset
Constant *Res = ConstantInt::get(LHS->getContext(), LHSOffset - RHSOffset);
if (auto *VecTy = dyn_cast<VectorType>(LHS->getType()))
  Res = ConstantVector::getSplat(VecTy->getElementCount(), Res);
return Res;
747}

749/// Test if there is a dominating equivalence condition for the
750/// two operands. If there is, try to reduce the binary operation
751/// between the two operands.
752/// Example: Op0 - Op1 --> 0 when Op0 == Op1
753static Value *simplifyByDomEq(unsigned Opcode, Value *Op0, Value *Op1,
                            const SimplifyQuery &Q, unsigned MaxRecurse) {
// Recursive run it can not get any benefit
if (MaxRecurse != RecursionLimit)
  return nullptr;

std::optional<bool> Imp =
    isImpliedByDomCondition(CmpInst::ICMP_EQ, Op0, Op1, Q.CxtI, Q.DL);
if (Imp && *Imp) {
  Type *Ty = Op0->getType();
  switch (Opcode) {
  case Instruction::Sub:
  case Instruction::Xor:
  case Instruction::URem:
  case Instruction::SRem:
    return Constant::getNullValue(Ty);

  case Instruction::SDiv:
  case Instruction::UDiv:
    return ConstantInt::get(Ty, 1);

  case Instruction::And:
  case Instruction::Or:
    // Could be either one - choose Op1 since that's more likely a constant.
    return Op1;
  default:
    break;
  }
}
return nullptr;
783}

785/// Given operands for a Sub, see if we can fold the result.
786/// If not, this returns null.
787static Value *simplifySubInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                            const SimplifyQuery &Q, unsigned MaxRecurse) {
if (Constant *C = foldOrCommuteConstant(Instruction::Sub, Op0, Op1, Q))
  return C;

// X - poison -> poison
// poison - X -> poison
if (isa<PoisonValue>(Op0) || isa<PoisonValue>(Op1))
  return PoisonValue::get(Op0->getType());

// X - undef -> undef
// undef - X -> undef
if (Q.isUndefValue(Op0) || Q.isUndefValue(Op1))
  return UndefValue::get(Op0->getType());

// X - 0 -> X
if (match(Op1, m_Zero()))
  return Op0;

// X - X -> 0
if (Op0 == Op1)
  return Constant::getNullValue(Op0->getType());

// Is this a negation?
if (match(Op0, m_Zero())) {
  // 0 - X -> 0 if the sub is NUW.
  if (IsNUW)
    return Constant::getNullValue(Op0->getType());

  KnownBits Known = computeKnownBits(Op1, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
  if (Known.Zero.isMaxSignedValue()) {
    // Op1 is either 0 or the minimum signed value. If the sub is NSW, then
    // Op1 must be 0 because negating the minimum signed value is undefined.
    if (IsNSW)
      return Constant::getNullValue(Op0->getType());

    // 0 - X -> X if X is 0 or the minimum signed value.
    return Op1;
  }
}

// (X + Y) - Z -> X + (Y - Z) or Y + (X - Z) if everything simplifies.
// For example, (X + Y) - Y -> X; (Y + X) - Y -> X
Value *X = nullptr, *Y = nullptr, *Z = Op1;
if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z
  // See if "V === Y - Z" simplifies.
  if (Value *V = simplifyBinOp(Instruction::Sub, Y, Z, Q, MaxRecurse - 1))
    // It does!  Now see if "X + V" simplifies.
    if (Value *W = simplifyBinOp(Instruction::Add, X, V, Q, MaxRecurse - 1)) {
      // It does, we successfully reassociated!
      ++NumReassoc;
      return W;
    }
  // See if "V === X - Z" simplifies.
  if (Value *V = simplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse - 1))
    // It does!  Now see if "Y + V" simplifies.
    if (Value *W = simplifyBinOp(Instruction::Add, Y, V, Q, MaxRecurse - 1)) {
      // It does, we successfully reassociated!
      ++NumReassoc;
      return W;
    }
}

// X - (Y + Z) -> (X - Y) - Z or (X - Z) - Y if everything simplifies.
// For example, X - (X + 1) -> -1
X = Op0;
if (MaxRecurse && match(Op1, m_Add(m_Value(Y), m_Value(Z)))) { // X - (Y + Z)
  // See if "V === X - Y" simplifies.
  if (Value *V = simplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse - 1))
    // It does!  Now see if "V - Z" simplifies.
    if (Value *W = simplifyBinOp(Instruction::Sub, V, Z, Q, MaxRecurse - 1)) {
      // It does, we successfully reassociated!
      ++NumReassoc;
      return W;
    }
  // See if "V === X - Z" simplifies.
  if (Value *V = simplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse - 1))
    // It does!  Now see if "V - Y" simplifies.
    if (Value *W = simplifyBinOp(Instruction::Sub, V, Y, Q, MaxRecurse - 1)) {
      // It does, we successfully reassociated!
      ++NumReassoc;
      return W;
    }
}

// Z - (X - Y) -> (Z - X) + Y if everything simplifies.
// For example, X - (X - Y) -> Y.
Z = Op0;
if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y)
  // See if "V === Z - X" simplifies.
  if (Value *V = simplifyBinOp(Instruction::Sub, Z, X, Q, MaxRecurse - 1))
    // It does!  Now see if "V + Y" simplifies.
    if (Value *W = simplifyBinOp(Instruction::Add, V, Y, Q, MaxRecurse - 1)) {
      // It does, we successfully reassociated!
      ++NumReassoc;
      return W;
    }

// trunc(X) - trunc(Y) -> trunc(X - Y) if everything simplifies.
if (MaxRecurse && match(Op0, m_Trunc(m_Value(X))) &&
    match(Op1, m_Trunc(m_Value(Y))))
  if (X->getType() == Y->getType())
    // See if "V === X - Y" simplifies.
    if (Value *V = simplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse - 1))
      // It does!  Now see if "trunc V" simplifies.
      if (Value *W = simplifyCastInst(Instruction::Trunc, V, Op0->getType(),
                                      Q, MaxRecurse - 1))
        // It does, return the simplified "trunc V".
        return W;

// Variations on GEP(base, I, ...) - GEP(base, i, ...) -> GEP(null, I-i, ...).
if (match(Op0, m_PtrToInt(m_Value(X))) && match(Op1, m_PtrToInt(m_Value(Y))))
  if (Constant *Result = computePointerDifference(Q.DL, X, Y))
    return ConstantExpr::getIntegerCast(Result, Op0->getType(), true);

// i1 sub -> xor.
if (MaxRecurse && Op0->getType()->isIntOrIntVectorTy(1))
  if (Value *V = simplifyXorInst(Op0, Op1, Q, MaxRecurse - 1))
    return V;

// Threading Sub over selects and phi nodes is pointless, so don't bother.
// Threading over the select in "A - select(cond, B, C)" means evaluating
// "A-B" and "A-C" and seeing if they are equal; but they are equal if and
// only if B and C are equal.  If B and C are equal then (since we assume
// that operands have already been simplified) "select(cond, B, C)" should
// have been simplified to the common value of B and C already.  Analysing
// "A-B" and "A-C" thus gains nothing, but costs compile time.  Similarly
// for threading over phi nodes.

if (Value *V = simplifyByDomEq(Instruction::Sub, Op0, Op1, Q, MaxRecurse))
  return V;

return nullptr;
920}

922Value *llvm::simplifySubInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                           const SimplifyQuery &Q) {
return ::simplifySubInst(Op0, Op1, IsNSW, IsNUW, Q, RecursionLimit);
925}

927/// Given operands for a Mul, see if we can fold the result.
928/// If not, this returns null.
929static Value *simplifyMulInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                            const SimplifyQuery &Q, unsigned MaxRecurse) {
if (Constant *C = foldOrCommuteConstant(Instruction::Mul, Op0, Op1, Q))
  return C;

// X * poison -> poison
if (isa<PoisonValue>(Op1))
  return Op1;

// X * undef -> 0
// X * 0 -> 0
if (Q.isUndefValue(Op1) || match(Op1, m_Zero()))
  return Constant::getNullValue(Op0->getType());

// X * 1 -> X
if (match(Op1, m_One()))
  return Op0;

// (X / Y) * Y -> X if the division is exact.
Value *X = nullptr;
if (Q.IIQ.UseInstrInfo &&
    (match(Op0,
           m_Exact(m_IDiv(m_Value(X), m_Specific(Op1)))) ||     // (X / Y) * Y
     match(Op1, m_Exact(m_IDiv(m_Value(X), m_Specific(Op0)))))) // Y * (X / Y)
  return X;

 if (Op0->getType()->isIntOrIntVectorTy(1)) {
  // mul i1 nsw is a special-case because -1 * -1 is poison (+1 is not
  // representable). All other cases reduce to 0, so just return 0.
  if (IsNSW)
    return ConstantInt::getNullValue(Op0->getType());

  // Treat "mul i1" as "and i1".
  if (MaxRecurse)
    if (Value *V = simplifyAndInst(Op0, Op1, Q, MaxRecurse - 1))
      return V;
}

// Try some generic simplifications for associative operations.
if (Value *V =
        simplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, Q, MaxRecurse))
  return V;

// Mul distributes over Add. Try some generic simplifications based on this.
if (Value *V = expandCommutativeBinOp(Instruction::Mul, Op0, Op1,
                                      Instruction::Add, Q, MaxRecurse))
  return V;

// If the operation is with the result of a select instruction, check whether
// operating on either branch of the select always yields the same value.
if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
  if (Value *V =
          threadBinOpOverSelect(Instruction::Mul, Op0, Op1, Q, MaxRecurse))
    return V;

// If the operation is with the result of a phi instruction, check whether
// operating on all incoming values of the phi always yields the same value.
if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
  if (Value *V =
          threadBinOpOverPHI(Instruction::Mul, Op0, Op1, Q, MaxRecurse))
    return V;

return nullptr;
992}

994Value *llvm::simplifyMulInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                           const SimplifyQuery &Q) {
return ::simplifyMulInst(Op0, Op1, IsNSW, IsNUW, Q, RecursionLimit);
997}

999/// Check for common or similar folds of integer division or integer remainder.
1000/// This applies to all 4 opcodes (sdiv/udiv/srem/urem).
1001static Value *simplifyDivRem(Instruction::BinaryOps Opcode, Value *Op0,
                           Value *Op1, const SimplifyQuery &Q,
                           unsigned MaxRecurse) {
bool IsDiv = (Opcode == Instruction::SDiv || Opcode == Instruction::UDiv);
bool IsSigned = (Opcode == Instruction::SDiv || Opcode == Instruction::SRem);

Type *Ty = Op0->getType();

// X / undef -> poison
// X % undef -> poison
if (Q.isUndefValue(Op1) || isa<PoisonValue>(Op1))
  return PoisonValue::get(Ty);

// X / 0 -> poison
// X % 0 -> poison
// We don't need to preserve faults!
if (match(Op1, m_Zero()))
  return PoisonValue::get(Ty);

// If any element of a constant divisor fixed width vector is zero or undef
// the behavior is undefined and we can fold the whole op to poison.
auto *Op1C = dyn_cast<Constant>(Op1);
auto *VTy = dyn_cast<FixedVectorType>(Ty);
if (Op1C && VTy) {
  unsigned NumElts = VTy->getNumElements();
  for (unsigned i = 0; i != NumElts; ++i) {
    Constant *Elt = Op1C->getAggregateElement(i);
    if (Elt && (Elt->isNullValue() || Q.isUndefValue(Elt)))
      return PoisonValue::get(Ty);
  }
}

// poison / X -> poison
// poison % X -> poison
if (isa<PoisonValue>(Op0))
  return Op0;

// undef / X -> 0
// undef % X -> 0
if (Q.isUndefValue(Op0))
  return Constant::getNullValue(Ty);

// 0 / X -> 0
// 0 % X -> 0
if (match(Op0, m_Zero()))
  return Constant::getNullValue(Op0->getType());

// X / X -> 1
// X % X -> 0
if (Op0 == Op1)
  return IsDiv ? ConstantInt::get(Ty, 1) : Constant::getNullValue(Ty);

// X / 1 -> X
// X % 1 -> 0
// If this is a boolean op (single-bit element type), we can't have
// division-by-zero or remainder-by-zero, so assume the divisor is 1.
// Similarly, if we're zero-extending a boolean divisor, then assume it's a 1.
Value *X;
if (match(Op1, m_One()) || Ty->isIntOrIntVectorTy(1) ||
    (match(Op1, m_ZExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)))
  return IsDiv ? Op0 : Constant::getNullValue(Ty);

// If X * Y does not overflow, then:
//   X * Y / Y -> X
//   X * Y % Y -> 0
if (match(Op0, m_c_Mul(m_Value(X), m_Specific(Op1)))) {
  auto *Mul = cast<OverflowingBinaryOperator>(Op0);
  // The multiplication can't overflow if it is defined not to, or if
  // X == A / Y for some A.
  if ((IsSigned && Q.IIQ.hasNoSignedWrap(Mul)) ||
      (!IsSigned && Q.IIQ.hasNoUnsignedWrap(Mul)) ||
      (IsSigned && match(X, m_SDiv(m_Value(), m_Specific(Op1)))) ||
      (!IsSigned && match(X, m_UDiv(m_Value(), m_Specific(Op1))))) {
    return IsDiv ? X : Constant::getNullValue(Op0->getType());
  }
}

if (Value *V = simplifyByDomEq(Opcode, Op0, Op1, Q, MaxRecurse))
  return V;

return nullptr;
1082}

1084/// Given a predicate and two operands, return true if the comparison is true.
1085/// This is a helper for div/rem simplification where we return some other value
1086/// when we can prove a relationship between the operands.
1087static bool isICmpTrue(ICmpInst::Predicate Pred, Value *LHS, Value *RHS,
                     const SimplifyQuery &Q, unsigned MaxRecurse) {
Value *V = simplifyICmpInst(Pred, LHS, RHS, Q, MaxRecurse);
Constant *C = dyn_cast_or_null<Constant>(V);
return (C && C->isAllOnesValue());
1092}

1094/// Return true if we can simplify X / Y to 0. Remainder can adapt that answer
1095/// to simplify X % Y to X.
1096static bool isDivZero(Value *X, Value *Y, const SimplifyQuery &Q,
                    unsigned MaxRecurse, bool IsSigned) {
// Recursion is always used, so bail out at once if we already hit the limit.
if (!MaxRecurse--)
  return false;

if (IsSigned) {
  // |X| / |Y| --> 0
  //
  // We require that 1 operand is a simple constant. That could be extended to
  // 2 variables if we computed the sign bit for each.
  //
  // Make sure that a constant is not the minimum signed value because taking
  // the abs() of that is undefined.
  Type *Ty = X->getType();
  const APInt *C;
  if (match(X, m_APInt(C)) && !C->isMinSignedValue()) {
    // Is the variable divisor magnitude always greater than the constant
    // dividend magnitude?
    // |Y| > |C| --> Y < -abs(C) or Y > abs(C)
    Constant *PosDividendC = ConstantInt::get(Ty, C->abs());
    Constant *NegDividendC = ConstantInt::get(Ty, -C->abs());
    if (isICmpTrue(CmpInst::ICMP_SLT, Y, NegDividendC, Q, MaxRecurse) ||
        isICmpTrue(CmpInst::ICMP_SGT, Y, PosDividendC, Q, MaxRecurse))
      return true;
  }
  if (match(Y, m_APInt(C))) {
    // Special-case: we can't take the abs() of a minimum signed value. If
    // that's the divisor, then all we have to do is prove that the dividend
    // is also not the minimum signed value.
    if (C->isMinSignedValue())
      return isICmpTrue(CmpInst::ICMP_NE, X, Y, Q, MaxRecurse);

    // Is the variable dividend magnitude always less than the constant
    // divisor magnitude?
    // |X| < |C| --> X > -abs(C) and X < abs(C)
    Constant *PosDivisorC = ConstantInt::get(Ty, C->abs());
    Constant *NegDivisorC = ConstantInt::get(Ty, -C->abs());
    if (isICmpTrue(CmpInst::ICMP_SGT, X, NegDivisorC, Q, MaxRecurse) &&
        isICmpTrue(CmpInst::ICMP_SLT, X, PosDivisorC, Q, MaxRecurse))
      return true;
  }
  return false;
}

// IsSigned == false.

// Is the unsigned dividend known to be less than a constant divisor?
// TODO: Convert this (and above) to range analysis
//      ("computeConstantRangeIncludingKnownBits")?
const APInt *C;
if (match(Y, m_APInt(C)) &&
    computeKnownBits(X, Q.DL, 0, Q.AC, Q.CxtI, Q.DT).getMaxValue().ult(*C))
  return true;

// Try again for any divisor:
// Is the dividend unsigned less than the divisor?
return isICmpTrue(ICmpInst::ICMP_ULT, X, Y, Q, MaxRecurse);
1154}

1156/// These are simplifications common to SDiv and UDiv.
1157static Value *simplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1,
                        bool IsExact, const SimplifyQuery &Q,
                        unsigned MaxRecurse) {
if (Constant *C = foldOrCommuteConstant(Opcode, Op0, Op1, Q))
  return C;

if (Value *V = simplifyDivRem(Opcode, Op0, Op1, Q, MaxRecurse))
  return V;

// If this is an exact divide by a constant, then the dividend (Op0) must have
// at least as many trailing zeros as the divisor to divide evenly. If it has
// less trailing zeros, then the result must be poison.
const APInt *DivC;
if (IsExact && match(Op1, m_APInt(DivC)) && DivC->countr_zero()) {
  KnownBits KnownOp0 = computeKnownBits(Op0, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
  if (KnownOp0.countMaxTrailingZeros() < DivC->countr_zero())
    return PoisonValue::get(Op0->getType());
}

bool IsSigned = Opcode == Instruction::SDiv;

// (X rem Y) / Y -> 0
if ((IsSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) ||
    (!IsSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1)))))
  return Constant::getNullValue(Op0->getType());

// (X /u C1) /u C2 -> 0 if C1 * C2 overflow
ConstantInt *C1, *C2;
if (!IsSigned && match(Op0, m_UDiv(m_Value(), m_ConstantInt(C1))) &&
    match(Op1, m_ConstantInt(C2))) {
  bool Overflow;
  (void)C1->getValue().umul_ov(C2->getValue(), Overflow);
  if (Overflow)
    return Constant::getNullValue(Op0->getType());
}

// If the operation is with the result of a select instruction, check whether
// operating on either branch of the select always yields the same value.
if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
  if (Value *V = threadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse))
    return V;

// If the operation is with the result of a phi instruction, check whether
// operating on all incoming values of the phi always yields the same value.
if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
  if (Value *V = threadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse))
    return V;

if (isDivZero(Op0, Op1, Q, MaxRecurse, IsSigned))
  return Constant::getNullValue(Op0->getType());

return nullptr;
1209}

1211/// These are simplifications common to SRem and URem.
1212static Value *simplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1,
                        const SimplifyQuery &Q, unsigned MaxRecurse) {
if (Constant *C = foldOrCommuteConstant(Opcode, Op0, Op1, Q))
  return C;

if (Value *V = simplifyDivRem(Opcode, Op0, Op1, Q, MaxRecurse))
  return V;

// (X % Y) % Y -> X % Y
if ((Opcode == Instruction::SRem &&
     match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) ||
    (Opcode == Instruction::URem &&
     match(Op0, m_URem(m_Value(), m_Specific(Op1)))))
  return Op0;

// (X << Y) % X -> 0
if (Q.IIQ.UseInstrInfo &&
    ((Opcode == Instruction::SRem &&
      match(Op0, m_NSWShl(m_Specific(Op1), m_Value()))) ||
     (Opcode == Instruction::URem &&
      match(Op0, m_NUWShl(m_Specific(Op1), m_Value())))))
  return Constant::getNullValue(Op0->getType());

// If the operation is with the result of a select instruction, check whether
// operating on either branch of the select always yields the same value.
if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
  if (Value *V = threadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse))
    return V;

// If the operation is with the result of a phi instruction, check whether
// operating on all incoming values of the phi always yields the same value.
if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
  if (Value *V = threadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse))
    return V;

// If X / Y == 0, then X % Y == X.
if (isDivZero(Op0, Op1, Q, MaxRecurse, Opcode == Instruction::SRem))
  return Op0;

return nullptr;
1252}

1254/// Given operands for an SDiv, see if we can fold the result.
1255/// If not, this returns null.
1256static Value *simplifySDivInst(Value *Op0, Value *Op1, bool IsExact,
                             const SimplifyQuery &Q, unsigned MaxRecurse) {
// If two operands are negated and no signed overflow, return -1.
if (isKnownNegation(Op0, Op1, /*NeedNSW=*/true))
  return Constant::getAllOnesValue(Op0->getType());

return simplifyDiv(Instruction::SDiv, Op0, Op1, IsExact, Q, MaxRecurse);
1263}

1265Value *llvm::simplifySDivInst(Value *Op0, Value *Op1, bool IsExact,
                            const SimplifyQuery &Q) {
return ::simplifySDivInst(Op0, Op1, IsExact, Q, RecursionLimit);
1268}

1270/// Given operands for a UDiv, see if we can fold the result.
1271/// If not, this returns null.
1272static Value *simplifyUDivInst(Value *Op0, Value *Op1, bool IsExact,
                             const SimplifyQuery &Q, unsigned MaxRecurse) {
return simplifyDiv(Instruction::UDiv, Op0, Op1, IsExact, Q, MaxRecurse);
1275}

1277Value *llvm::simplifyUDivInst(Value *Op0, Value *Op1, bool IsExact,
                            const SimplifyQuery &Q) {
return ::simplifyUDivInst(Op0, Op1, IsExact, Q, RecursionLimit);
1280}

1282/// Given operands for an SRem, see if we can fold the result.
1283/// If not, this returns null.
1284static Value *simplifySRemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                             unsigned MaxRecurse) {
// If the divisor is 0, the result is undefined, so assume the divisor is -1.
// srem Op0, (sext i1 X) --> srem Op0, -1 --> 0
Value *X;
if (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1))
  return ConstantInt::getNullValue(Op0->getType());

// If the two operands are negated, return 0.
if (isKnownNegation(Op0, Op1))
  return ConstantInt::getNullValue(Op0->getType());

return simplifyRem(Instruction::SRem, Op0, Op1, Q, MaxRecurse);
1297}

1299Value *llvm::simplifySRemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
return ::simplifySRemInst(Op0, Op1, Q, RecursionLimit);
1301}

1303/// Given operands for a URem, see if we can fold the result.
1304/// If not, this returns null.
1305static Value *simplifyURemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                             unsigned MaxRecurse) {
return simplifyRem(Instruction::URem, Op0, Op1, Q, MaxRecurse);
1308}

1310Value *llvm::simplifyURemInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
return ::simplifyURemInst(Op0, Op1, Q, RecursionLimit);
1312}

1314/// Returns true if a shift by \c Amount always yields poison.
1315static bool isPoisonShift(Value *Amount, const SimplifyQuery &Q) {
Constant *C = dyn_cast<Constant>(Amount);
if (!C)
  return false;

// X shift by undef -> poison because it may shift by the bitwidth.
if (Q.isUndefValue(C))
  return true;

// Shifting by the bitwidth or more is poison. This covers scalars and
// fixed/scalable vectors with splat constants.
const APInt *AmountC;
if (match(C, m_APInt(AmountC)) && AmountC->uge(AmountC->getBitWidth()))
  return true;

// Try harder for fixed-length vectors:
// If all lanes of a vector shift are poison, the whole shift is poison.
if (isa<ConstantVector>(C) || isa<ConstantDataVector>(C)) {
  for (unsigned I = 0,
                E = cast<FixedVectorType>(C->getType())->getNumElements();
       I != E; ++I)
    if (!isPoisonShift(C->getAggregateElement(I), Q))
      return false;
  return true;
}

return false;
1342}

1344/// Given operands for an Shl, LShr or AShr, see if we can fold the result.
1345/// If not, this returns null.
1346static Value *simplifyShift(Instruction::BinaryOps Opcode, Value *Op0,
                          Value *Op1, bool IsNSW, const SimplifyQuery &Q,
                          unsigned MaxRecurse) {
if (Constant *C = foldOrCommuteConstant(Opcode, Op0, Op1, Q))
  return C;

// poison shift by X -> poison
if (isa<PoisonValue>(Op0))
  return Op0;

// 0 shift by X -> 0
if (match(Op0, m_Zero()))
  return Constant::getNullValue(Op0->getType());

// X shift by 0 -> X
// Shift-by-sign-extended bool must be shift-by-0 because shift-by-all-ones
// would be poison.
Value *X;
if (match(Op1, m_Zero()) ||
    (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)))
  return Op0;

// Fold undefined shifts.
if (isPoisonShift(Op1, Q))
  return PoisonValue::get(Op0->getType());

// If the operation is with the result of a select instruction, check whether
// operating on either branch of the select always yields the same value.
if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
  if (Value *V = threadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse))
    return V;

// If the operation is with the result of a phi instruction, check whether
// operating on all incoming values of the phi always yields the same value.
if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
  if (Value *V = threadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse))
    return V;

// If any bits in the shift amount make that value greater than or equal to
// the number of bits in the type, the shift is undefined.
KnownBits KnownAmt = computeKnownBits(Op1, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
if (KnownAmt.getMinValue().uge(KnownAmt.getBitWidth()))
  return PoisonValue::get(Op0->getType());

// If all valid bits in the shift amount are known zero, the first operand is
// unchanged.
unsigned NumValidShiftBits = Log2_32_Ceil(KnownAmt.getBitWidth());
if (KnownAmt.countMinTrailingZeros() >= NumValidShiftBits)
  return Op0;

// Check for nsw shl leading to a poison value.
if (IsNSW) {
  assert(Opcode == Instruction::Shl && "Expected shl for nsw instruction")(static_cast <bool> (Opcode == Instruction::Shl &&
 "Expected shl for nsw instruction") ? void (0) : __assert_fail
 ("Opcode == Instruction::Shl && \"Expected shl for nsw instruction\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 1398, __extension__
 __PRETTY_FUNCTION__));
  KnownBits KnownVal = computeKnownBits(Op0, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
  KnownBits KnownShl = KnownBits::shl(KnownVal, KnownAmt);

  if (KnownVal.Zero.isSignBitSet())
    KnownShl.Zero.setSignBit();
  if (KnownVal.One.isSignBitSet())
    KnownShl.One.setSignBit();

  if (KnownShl.hasConflict())
    return PoisonValue::get(Op0->getType());
}

return nullptr;
1412}

1414/// Given operands for an LShr or AShr, see if we can fold the result.  If not,
1415/// this returns null.
1416static Value *simplifyRightShift(Instruction::BinaryOps Opcode, Value *Op0,
                               Value *Op1, bool IsExact,
                               const SimplifyQuery &Q, unsigned MaxRecurse) {
if (Value *V =
        simplifyShift(Opcode, Op0, Op1, /*IsNSW*/ false, Q, MaxRecurse))
  return V;

// X >> X -> 0
if (Op0 == Op1)
  return Constant::getNullValue(Op0->getType());

// undef >> X -> 0
// undef >> X -> undef (if it's exact)
if (Q.isUndefValue(Op0))
  return IsExact ? Op0 : Constant::getNullValue(Op0->getType());

// The low bit cannot be shifted out of an exact shift if it is set.
// TODO: Generalize by counting trailing zeros (see fold for exact division).
if (IsExact) {
  KnownBits Op0Known =
      computeKnownBits(Op0, Q.DL, /*Depth=*/0, Q.AC, Q.CxtI, Q.DT);
  if (Op0Known.One[0])
    return Op0;
}

return nullptr;
1442}

1444/// Given operands for an Shl, see if we can fold the result.
1445/// If not, this returns null.
1446static Value *simplifyShlInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                            const SimplifyQuery &Q, unsigned MaxRecurse) {
if (Value *V =
        simplifyShift(Instruction::Shl, Op0, Op1, IsNSW, Q, MaxRecurse))
  return V;

Type *Ty = Op0->getType();
// undef << X -> 0
// undef << X -> undef if (if it's NSW/NUW)
if (Q.isUndefValue(Op0))
  return IsNSW || IsNUW ? Op0 : Constant::getNullValue(Ty);

// (X >> A) << A -> X
Value *X;
if (Q.IIQ.UseInstrInfo &&
    match(Op0, m_Exact(m_Shr(m_Value(X), m_Specific(Op1)))))
  return X;

// shl nuw i8 C, %x  ->  C  iff C has sign bit set.
if (IsNUW && match(Op0, m_Negative()))
  return Op0;
// NOTE: could use computeKnownBits() / LazyValueInfo,
// but the cost-benefit analysis suggests it isn't worth it.

// "nuw" guarantees that only zeros are shifted out, and "nsw" guarantees
// that the sign-bit does not change, so the only input that does not
// produce poison is 0, and "0 << (bitwidth-1) --> 0".
if (IsNSW && IsNUW &&
    match(Op1, m_SpecificInt(Ty->getScalarSizeInBits() - 1)))
  return Constant::getNullValue(Ty);

return nullptr;
1478}

1480Value *llvm::simplifyShlInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                           const SimplifyQuery &Q) {
return ::simplifyShlInst(Op0, Op1, IsNSW, IsNUW, Q, RecursionLimit);
1483}

1485/// Given operands for an LShr, see if we can fold the result.
1486/// If not, this returns null.
1487static Value *simplifyLShrInst(Value *Op0, Value *Op1, bool IsExact,
                             const SimplifyQuery &Q, unsigned MaxRecurse) {
if (Value *V = simplifyRightShift(Instruction::LShr, Op0, Op1, IsExact, Q,
                                  MaxRecurse))
  return V;

// (X << A) >> A -> X
Value *X;
if (match(Op0, m_NUWShl(m_Value(X), m_Specific(Op1))))
  return X;

// ((X << A) | Y) >> A -> X  if effective width of Y is not larger than A.
// We can return X as we do in the above case since OR alters no bits in X.
// SimplifyDemandedBits in InstCombine can do more general optimization for
// bit manipulation. This pattern aims to provide opportunities for other
// optimizers by supporting a simple but common case in InstSimplify.
Value *Y;
const APInt *ShRAmt, *ShLAmt;
if (match(Op1, m_APInt(ShRAmt)) &&
    match(Op0, m_c_Or(m_NUWShl(m_Value(X), m_APInt(ShLAmt)), m_Value(Y))) &&
    *ShRAmt == *ShLAmt) {
  const KnownBits YKnown = computeKnownBits(Y, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
  const unsigned EffWidthY = YKnown.countMaxActiveBits();
  if (ShRAmt->uge(EffWidthY))
    return X;
}

return nullptr;
1515}

1517Value *llvm::simplifyLShrInst(Value *Op0, Value *Op1, bool IsExact,
                            const SimplifyQuery &Q) {
return ::simplifyLShrInst(Op0, Op1, IsExact, Q, RecursionLimit);
1520}

1522/// Given operands for an AShr, see if we can fold the result.
1523/// If not, this returns null.
1524static Value *simplifyAShrInst(Value *Op0, Value *Op1, bool IsExact,
                             const SimplifyQuery &Q, unsigned MaxRecurse) {
if (Value *V = simplifyRightShift(Instruction::AShr, Op0, Op1, IsExact, Q,
                                  MaxRecurse))
  return V;

// -1 >>a X --> -1
// (-1 << X) a>> X --> -1
// Do not return Op0 because it may contain undef elements if it's a vector.
if (match(Op0, m_AllOnes()) ||
    match(Op0, m_Shl(m_AllOnes(), m_Specific(Op1))))
  return Constant::getAllOnesValue(Op0->getType());

// (X << A) >> A -> X
Value *X;
if (Q.IIQ.UseInstrInfo && match(Op0, m_NSWShl(m_Value(X), m_Specific(Op1))))
  return X;

// Arithmetic shifting an all-sign-bit value is a no-op.
unsigned NumSignBits = ComputeNumSignBits(Op0, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
if (NumSignBits == Op0->getType()->getScalarSizeInBits())
  return Op0;

return nullptr;
1548}

1550Value *llvm::simplifyAShrInst(Value *Op0, Value *Op1, bool IsExact,
                            const SimplifyQuery &Q) {
return ::simplifyAShrInst(Op0, Op1, IsExact, Q, RecursionLimit);
1553}

1555/// Commuted variants are assumed to be handled by calling this function again
1556/// with the parameters swapped.
1557static Value *simplifyUnsignedRangeCheck(ICmpInst *ZeroICmp,
                                       ICmpInst *UnsignedICmp, bool IsAnd,
                                       const SimplifyQuery &Q) {
Value *X, *Y;

ICmpInst::Predicate EqPred;
if (!match(ZeroICmp, m_ICmp(EqPred, m_Value(Y), m_Zero())) ||
    !ICmpInst::isEquality(EqPred))
  return nullptr;

ICmpInst::Predicate UnsignedPred;

Value *A, *B;
// Y = (A - B);
if (match(Y, m_Sub(m_Value(A), m_Value(B)))) {
  if (match(UnsignedICmp,
            m_c_ICmp(UnsignedPred, m_Specific(A), m_Specific(B))) &&
      ICmpInst::isUnsigned(UnsignedPred)) {
    // A >=/<= B || (A - B) != 0  <-->  true
    if ((UnsignedPred == ICmpInst::ICMP_UGE ||
         UnsignedPred == ICmpInst::ICMP_ULE) &&
        EqPred == ICmpInst::ICMP_NE && !IsAnd)
      return ConstantInt::getTrue(UnsignedICmp->getType());
    // A </> B && (A - B) == 0  <-->  false
    if ((UnsignedPred == ICmpInst::ICMP_ULT ||
         UnsignedPred == ICmpInst::ICMP_UGT) &&
        EqPred == ICmpInst::ICMP_EQ && IsAnd)
      return ConstantInt::getFalse(UnsignedICmp->getType());

    // A </> B && (A - B) != 0  <-->  A </> B
    // A </> B || (A - B) != 0  <-->  (A - B) != 0
    if (EqPred == ICmpInst::ICMP_NE && (UnsignedPred == ICmpInst::ICMP_ULT ||
                                        UnsignedPred == ICmpInst::ICMP_UGT))
      return IsAnd ? UnsignedICmp : ZeroICmp;

    // A <=/>= B && (A - B) == 0  <-->  (A - B) == 0
    // A <=/>= B || (A - B) == 0  <-->  A <=/>= B
    if (EqPred == ICmpInst::ICMP_EQ && (UnsignedPred == ICmpInst::ICMP_ULE ||
                                        UnsignedPred == ICmpInst::ICMP_UGE))
      return IsAnd ? ZeroICmp : UnsignedICmp;
  }

  // Given  Y = (A - B)
  //   Y >= A && Y != 0  --> Y >= A  iff B != 0
  //   Y <  A || Y == 0  --> Y <  A  iff B != 0
  if (match(UnsignedICmp,
            m_c_ICmp(UnsignedPred, m_Specific(Y), m_Specific(A)))) {
    if (UnsignedPred == ICmpInst::ICMP_UGE && IsAnd &&
        EqPred == ICmpInst::ICMP_NE &&
        isKnownNonZero(B, Q.DL, /*Depth=*/0, Q.AC, Q.CxtI, Q.DT))
      return UnsignedICmp;
    if (UnsignedPred == ICmpInst::ICMP_ULT && !IsAnd &&
        EqPred == ICmpInst::ICMP_EQ &&
        isKnownNonZero(B, Q.DL, /*Depth=*/0, Q.AC, Q.CxtI, Q.DT))
      return UnsignedICmp;
  }
}

if (match(UnsignedICmp, m_ICmp(UnsignedPred, m_Value(X), m_Specific(Y))) &&
    ICmpInst::isUnsigned(UnsignedPred))
  ;
else if (match(UnsignedICmp,
               m_ICmp(UnsignedPred, m_Specific(Y), m_Value(X))) &&
         ICmpInst::isUnsigned(UnsignedPred))
  UnsignedPred = ICmpInst::getSwappedPredicate(UnsignedPred);
else
  return nullptr;

// X > Y && Y == 0  -->  Y == 0  iff X != 0
// X > Y || Y == 0  -->  X > Y   iff X != 0
if (UnsignedPred == ICmpInst::ICMP_UGT && EqPred == ICmpInst::ICMP_EQ &&
    isKnownNonZero(X, Q.DL, /*Depth=*/0, Q.AC, Q.CxtI, Q.DT))
  return IsAnd ? ZeroICmp : UnsignedICmp;

// X <= Y && Y != 0  -->  X <= Y  iff X != 0
// X <= Y || Y != 0  -->  Y != 0  iff X != 0
if (UnsignedPred == ICmpInst::ICMP_ULE && EqPred == ICmpInst::ICMP_NE &&
    isKnownNonZero(X, Q.DL, /*Depth=*/0, Q.AC, Q.CxtI, Q.DT))
  return IsAnd ? UnsignedICmp : ZeroICmp;

// The transforms below here are expected to be handled more generally with
// simplifyAndOrOfICmpsWithLimitConst() or in InstCombine's
// foldAndOrOfICmpsWithConstEq(). If we are looking to trim optimizer overlap,
// these are candidates for removal.

// X < Y && Y != 0  -->  X < Y
// X < Y || Y != 0  -->  Y != 0
if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_NE)
  return IsAnd ? UnsignedICmp : ZeroICmp;

// X >= Y && Y == 0  -->  Y == 0
// X >= Y || Y == 0  -->  X >= Y
if (UnsignedPred == ICmpInst::ICMP_UGE && EqPred == ICmpInst::ICMP_EQ)
  return IsAnd ? ZeroICmp : UnsignedICmp;

// X < Y && Y == 0  -->  false
if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_EQ &&
    IsAnd)
  return getFalse(UnsignedICmp->getType());

// X >= Y || Y != 0  -->  true
if (UnsignedPred == ICmpInst::ICMP_UGE && EqPred == ICmpInst::ICMP_NE &&
    !IsAnd)
  return getTrue(UnsignedICmp->getType());

return nullptr;
1663}

1665/// Test if a pair of compares with a shared operand and 2 constants has an
1666/// empty set intersection, full set union, or if one compare is a superset of
1667/// the other.
1668static Value *simplifyAndOrOfICmpsWithConstants(ICmpInst *Cmp0, ICmpInst *Cmp1,
                                              bool IsAnd) {
// Look for this pattern: {and/or} (icmp X, C0), (icmp X, C1)).
if (Cmp0->getOperand(0) != Cmp1->getOperand(0))
  return nullptr;

const APInt *C0, *C1;
if (!match(Cmp0->getOperand(1), m_APInt(C0)) ||
    !match(Cmp1->getOperand(1), m_APInt(C1)))
  return nullptr;

auto Range0 = ConstantRange::makeExactICmpRegion(Cmp0->getPredicate(), *C0);
auto Range1 = ConstantRange::makeExactICmpRegion(Cmp1->getPredicate(), *C1);

// For and-of-compares, check if the intersection is empty:
// (icmp X, C0) && (icmp X, C1) --> empty set --> false
if (IsAnd && Range0.intersectWith(Range1).isEmptySet())
  return getFalse(Cmp0->getType());

// For or-of-compares, check if the union is full:
// (icmp X, C0) || (icmp X, C1) --> full set --> true
if (!IsAnd && Range0.unionWith(Range1).isFullSet())
  return getTrue(Cmp0->getType());

// Is one range a superset of the other?
// If this is and-of-compares, take the smaller set:
// (icmp sgt X, 4) && (icmp sgt X, 42) --> icmp sgt X, 42
// If this is or-of-compares, take the larger set:
// (icmp sgt X, 4) || (icmp sgt X, 42) --> icmp sgt X, 4
if (Range0.contains(Range1))
  return IsAnd ? Cmp1 : Cmp0;
if (Range1.contains(Range0))
  return IsAnd ? Cmp0 : Cmp1;

return nullptr;
1703}

1705static Value *simplifyAndOrOfICmpsWithZero(ICmpInst *Cmp0, ICmpInst *Cmp1,
                                         bool IsAnd) {
ICmpInst::Predicate P0 = Cmp0->getPredicate(), P1 = Cmp1->getPredicate();
if (!match(Cmp0->getOperand(1), m_Zero()) ||
    !match(Cmp1->getOperand(1), m_Zero()) || P0 != P1)
  return nullptr;

if ((IsAnd && P0 != ICmpInst::ICMP_NE) || (!IsAnd && P1 != ICmpInst::ICMP_EQ))
  return nullptr;

// We have either "(X == 0 || Y == 0)" or "(X != 0 && Y != 0)".
Value *X = Cmp0->getOperand(0);
Value *Y = Cmp1->getOperand(0);

// If one of the compares is a masked version of a (not) null check, then
// that compare implies the other, so we eliminate the other. Optionally, look
// through a pointer-to-int cast to match a null check of a pointer type.

// (X == 0) || (([ptrtoint] X & ?) == 0) --> ([ptrtoint] X & ?) == 0
// (X == 0) || ((? & [ptrtoint] X) == 0) --> (? & [ptrtoint] X) == 0
// (X != 0) && (([ptrtoint] X & ?) != 0) --> ([ptrtoint] X & ?) != 0
// (X != 0) && ((? & [ptrtoint] X) != 0) --> (? & [ptrtoint] X) != 0
if (match(Y, m_c_And(m_Specific(X), m_Value())) ||
    match(Y, m_c_And(m_PtrToInt(m_Specific(X)), m_Value())))
  return Cmp1;

// (([ptrtoint] Y & ?) == 0) || (Y == 0) --> ([ptrtoint] Y & ?) == 0
// ((? & [ptrtoint] Y) == 0) || (Y == 0) --> (? & [ptrtoint] Y) == 0
// (([ptrtoint] Y & ?) != 0) && (Y != 0) --> ([ptrtoint] Y & ?) != 0
// ((? & [ptrtoint] Y) != 0) && (Y != 0) --> (? & [ptrtoint] Y) != 0
if (match(X, m_c_And(m_Specific(Y), m_Value())) ||
    match(X, m_c_And(m_PtrToInt(m_Specific(Y)), m_Value())))
  return Cmp0;

return nullptr;
1740}

1742static Value *simplifyAndOfICmpsWithAdd(ICmpInst *Op0, ICmpInst *Op1,
                                      const InstrInfoQuery &IIQ) {
// (icmp (add V, C0), C1) & (icmp V, C0)
ICmpInst::Predicate Pred0, Pred1;
const APInt *C0, *C1;
Value *V;
if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_APInt(C0)), m_APInt(C1))))
  return nullptr;

if (!match(Op1, m_ICmp(Pred1, m_Specific(V), m_Value())))
  return nullptr;

auto *AddInst = cast<OverflowingBinaryOperator>(Op0->getOperand(0));
if (AddInst->getOperand(1) != Op1->getOperand(1))
  return nullptr;

Type *ITy = Op0->getType();
bool IsNSW = IIQ.hasNoSignedWrap(AddInst);
bool IsNUW = IIQ.hasNoUnsignedWrap(AddInst);

const APInt Delta = *C1 - *C0;
if (C0->isStrictlyPositive()) {
  if (Delta == 2) {
    if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_SGT)
      return getFalse(ITy);
    if (Pred0 == ICmpInst::ICMP_SLT && Pred1 == ICmpInst::ICMP_SGT && IsNSW)
      return getFalse(ITy);
  }
  if (Delta == 1) {
    if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_SGT)
      return getFalse(ITy);
    if (Pred0 == ICmpInst::ICMP_SLE && Pred1 == ICmpInst::ICMP_SGT && IsNSW)
      return getFalse(ITy);
  }
}
if (C0->getBoolValue() && IsNUW) {
  if (Delta == 2)
    if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_UGT)
      return getFalse(ITy);
  if (Delta == 1)
    if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_UGT)
      return getFalse(ITy);
}

return nullptr;
1787}

1789/// Try to eliminate compares with signed or unsigned min/max constants.
1790static Value *simplifyAndOrOfICmpsWithLimitConst(ICmpInst *Cmp0, ICmpInst *Cmp1,
                                               bool IsAnd) {
// Canonicalize an equality compare as Cmp0.
if (Cmp1->isEquality())
  std::swap(Cmp0, Cmp1);
if (!Cmp0->isEquality())
  return nullptr;

// The non-equality compare must include a common operand (X). Canonicalize
// the common operand as operand 0 (the predicate is swapped if the common
// operand was operand 1).
ICmpInst::Predicate Pred0 = Cmp0->getPredicate();
Value *X = Cmp0->getOperand(0);
ICmpInst::Predicate Pred1;
bool HasNotOp = match(Cmp1, m_c_ICmp(Pred1, m_Not(m_Specific(X)), m_Value()));
if (!HasNotOp && !match(Cmp1, m_c_ICmp(Pred1, m_Specific(X), m_Value())))
  return nullptr;
if (ICmpInst::isEquality(Pred1))
  return nullptr;

// The equality compare must be against a constant. Flip bits if we matched
// a bitwise not. Convert a null pointer constant to an integer zero value.
APInt MinMaxC;
const APInt *C;
if (match(Cmp0->getOperand(1), m_APInt(C)))
  MinMaxC = HasNotOp ? ~*C : *C;
else if (isa<ConstantPointerNull>(Cmp0->getOperand(1)))
  MinMaxC = APInt::getZero(8);
else
  return nullptr;

// DeMorganize if this is 'or': P0 || P1 --> !P0 && !P1.
if (!IsAnd) {
  Pred0 = ICmpInst::getInversePredicate(Pred0);
  Pred1 = ICmpInst::getInversePredicate(Pred1);
}

// Normalize to unsigned compare and unsigned min/max value.
// Example for 8-bit: -128 + 128 -> 0; 127 + 128 -> 255
if (ICmpInst::isSigned(Pred1)) {
  Pred1 = ICmpInst::getUnsignedPredicate(Pred1);
  MinMaxC += APInt::getSignedMinValue(MinMaxC.getBitWidth());
}

// (X != MAX) && (X < Y) --> X < Y
// (X == MAX) || (X >= Y) --> X >= Y
if (MinMaxC.isMaxValue())
  if (Pred0 == ICmpInst::ICMP_NE && Pred1 == ICmpInst::ICMP_ULT)
    return Cmp1;

// (X != MIN) && (X > Y) -->  X > Y
// (X == MIN) || (X <= Y) --> X <= Y
if (MinMaxC.isMinValue())
  if (Pred0 == ICmpInst::ICMP_NE && Pred1 == ICmpInst::ICMP_UGT)
    return Cmp1;

return nullptr;
1847}

1849/// Try to simplify and/or of icmp with ctpop intrinsic.
1850static Value *simplifyAndOrOfICmpsWithCtpop(ICmpInst *Cmp0, ICmpInst *Cmp1,
                                          bool IsAnd) {
ICmpInst::Predicate Pred0, Pred1;
Value *X;
const APInt *C;
if (!match(Cmp0, m_ICmp(Pred0, m_Intrinsic<Intrinsic::ctpop>(m_Value(X)),
                        m_APInt(C))) ||
    !match(Cmp1, m_ICmp(Pred1, m_Specific(X), m_ZeroInt())) || C->isZero())
  return nullptr;

// (ctpop(X) == C) || (X != 0) --> X != 0 where C > 0
if (!IsAnd && Pred0 == ICmpInst::ICMP_EQ && Pred1 == ICmpInst::ICMP_NE)
  return Cmp1;
// (ctpop(X) != C) && (X == 0) --> X == 0 where C > 0
if (IsAnd && Pred0 == ICmpInst::ICMP_NE && Pred1 == ICmpInst::ICMP_EQ)
  return Cmp1;

return nullptr;
1868}

1870static Value *simplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1,
                               const SimplifyQuery &Q) {
if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/true, Q))
  return X;
if (Value *X = simplifyUnsignedRangeCheck(Op1, Op0, /*IsAnd=*/true, Q))
  return X;

if (Value *X = simplifyAndOrOfICmpsWithConstants(Op0, Op1, true))
  return X;

if (Value *X = simplifyAndOrOfICmpsWithLimitConst(Op0, Op1, true))
  return X;

if (Value *X = simplifyAndOrOfICmpsWithZero(Op0, Op1, true))
  return X;

if (Value *X = simplifyAndOrOfICmpsWithCtpop(Op0, Op1, true))
  return X;
if (Value *X = simplifyAndOrOfICmpsWithCtpop(Op1, Op0, true))
  return X;

if (Value *X = simplifyAndOfICmpsWithAdd(Op0, Op1, Q.IIQ))
  return X;
if (Value *X = simplifyAndOfICmpsWithAdd(Op1, Op0, Q.IIQ))
  return X;

return nullptr;
1897}

1899static Value *simplifyOrOfICmpsWithAdd(ICmpInst *Op0, ICmpInst *Op1,
                                     const InstrInfoQuery &IIQ) {
// (icmp (add V, C0), C1) | (icmp V, C0)
ICmpInst::Predicate Pred0, Pred1;
const APInt *C0, *C1;
Value *V;
if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_APInt(C0)), m_APInt(C1))))
  return nullptr;

if (!match(Op1, m_ICmp(Pred1, m_Specific(V), m_Value())))
  return nullptr;

auto *AddInst = cast<BinaryOperator>(Op0->getOperand(0));
if (AddInst->getOperand(1) != Op1->getOperand(1))
  return nullptr;

Type *ITy = Op0->getType();
bool IsNSW = IIQ.hasNoSignedWrap(AddInst);
bool IsNUW = IIQ.hasNoUnsignedWrap(AddInst);

const APInt Delta = *C1 - *C0;
if (C0->isStrictlyPositive()) {
  if (Delta == 2) {
    if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_SLE)
      return getTrue(ITy);
    if (Pred0 == ICmpInst::ICMP_SGE && Pred1 == ICmpInst::ICMP_SLE && IsNSW)
      return getTrue(ITy);
  }
  if (Delta == 1) {
    if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_SLE)
      return getTrue(ITy);
    if (Pred0 == ICmpInst::ICMP_SGT && Pred1 == ICmpInst::ICMP_SLE && IsNSW)
      return getTrue(ITy);
  }
}
if (C0->getBoolValue() && IsNUW) {
  if (Delta == 2)
    if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_ULE)
      return getTrue(ITy);
  if (Delta == 1)
    if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_ULE)
      return getTrue(ITy);
}

return nullptr;
1944}

1946static Value *simplifyOrOfICmps(ICmpInst *Op0, ICmpInst *Op1,
                              const SimplifyQuery &Q) {
if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/false, Q))
  return X;
if (Value *X = simplifyUnsignedRangeCheck(Op1, Op0, /*IsAnd=*/false, Q))
  return X;

if (Value *X = simplifyAndOrOfICmpsWithConstants(Op0, Op1, false))
  return X;

if (Value *X = simplifyAndOrOfICmpsWithLimitConst(Op0, Op1, false))
  return X;

if (Value *X = simplifyAndOrOfICmpsWithZero(Op0, Op1, false))
  return X;

if (Value *X = simplifyAndOrOfICmpsWithCtpop(Op0, Op1, false))
  return X;
if (Value *X = simplifyAndOrOfICmpsWithCtpop(Op1, Op0, false))
  return X;

if (Value *X = simplifyOrOfICmpsWithAdd(Op0, Op1, Q.IIQ))
  return X;
if (Value *X = simplifyOrOfICmpsWithAdd(Op1, Op0, Q.IIQ))
  return X;

return nullptr;
1973}

1975static Value *simplifyAndOrOfFCmps(const TargetLibraryInfo *TLI, FCmpInst *LHS,
                                 FCmpInst *RHS, bool IsAnd) {
Value *LHS0 = LHS->getOperand(0), *LHS1 = LHS->getOperand(1);
Value *RHS0 = RHS->getOperand(0), *RHS1 = RHS->getOperand(1);
if (LHS0->getType() != RHS0->getType())
  return nullptr;

FCmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
if ((PredL == FCmpInst::FCMP_ORD && PredR == FCmpInst::FCMP_ORD && IsAnd) ||
    (PredL == FCmpInst::FCMP_UNO && PredR == FCmpInst::FCMP_UNO && !IsAnd)) {
  // (fcmp ord NNAN, X) & (fcmp ord X, Y) --> fcmp ord X, Y
  // (fcmp ord NNAN, X) & (fcmp ord Y, X) --> fcmp ord Y, X
  // (fcmp ord X, NNAN) & (fcmp ord X, Y) --> fcmp ord X, Y
  // (fcmp ord X, NNAN) & (fcmp ord Y, X) --> fcmp ord Y, X
  // (fcmp uno NNAN, X) | (fcmp uno X, Y) --> fcmp uno X, Y
  // (fcmp uno NNAN, X) | (fcmp uno Y, X) --> fcmp uno Y, X
  // (fcmp uno X, NNAN) | (fcmp uno X, Y) --> fcmp uno X, Y
  // (fcmp uno X, NNAN) | (fcmp uno Y, X) --> fcmp uno Y, X
  if ((isKnownNeverNaN(LHS0, TLI) && (LHS1 == RHS0 || LHS1 == RHS1)) ||
      (isKnownNeverNaN(LHS1, TLI) && (LHS0 == RHS0 || LHS0 == RHS1)))
    return RHS;

  // (fcmp ord X, Y) & (fcmp ord NNAN, X) --> fcmp ord X, Y
  // (fcmp ord Y, X) & (fcmp ord NNAN, X) --> fcmp ord Y, X
  // (fcmp ord X, Y) & (fcmp ord X, NNAN) --> fcmp ord X, Y
  // (fcmp ord Y, X) & (fcmp ord X, NNAN) --> fcmp ord Y, X
  // (fcmp uno X, Y) | (fcmp uno NNAN, X) --> fcmp uno X, Y
  // (fcmp uno Y, X) | (fcmp uno NNAN, X) --> fcmp uno Y, X
  // (fcmp uno X, Y) | (fcmp uno X, NNAN) --> fcmp uno X, Y
  // (fcmp uno Y, X) | (fcmp uno X, NNAN) --> fcmp uno Y, X
  if ((isKnownNeverNaN(RHS0, TLI) && (RHS1 == LHS0 || RHS1 == LHS1)) ||
      (isKnownNeverNaN(RHS1, TLI) && (RHS0 == LHS0 || RHS0 == LHS1)))
    return LHS;
}

return nullptr;
2011}

2013static Value *simplifyAndOrOfCmps(const SimplifyQuery &Q, Value *Op0,
                                Value *Op1, bool IsAnd) {
// Look through casts of the 'and' operands to find compares.
auto *Cast0 = dyn_cast<CastInst>(Op0);
auto *Cast1 = dyn_cast<CastInst>(Op1);
if (Cast0 && Cast1 && Cast0->getOpcode() == Cast1->getOpcode() &&
    Cast0->getSrcTy() == Cast1->getSrcTy()) {
  Op0 = Cast0->getOperand(0);
  Op1 = Cast1->getOperand(0);
}

Value *V = nullptr;
auto *ICmp0 = dyn_cast<ICmpInst>(Op0);
auto *ICmp1 = dyn_cast<ICmpInst>(Op1);
if (ICmp0 && ICmp1)
  V = IsAnd ? simplifyAndOfICmps(ICmp0, ICmp1, Q)
            : simplifyOrOfICmps(ICmp0, ICmp1, Q);

auto *FCmp0 = dyn_cast<FCmpInst>(Op0);
auto *FCmp1 = dyn_cast<FCmpInst>(Op1);
if (FCmp0 && FCmp1)
  V = simplifyAndOrOfFCmps(Q.TLI, FCmp0, FCmp1, IsAnd);

if (!V)
  return nullptr;
if (!Cast0)
  return V;

// If we looked through casts, we can only handle a constant simplification
// because we are not allowed to create a cast instruction here.
if (auto *C = dyn_cast<Constant>(V))
  return ConstantExpr::getCast(Cast0->getOpcode(), C, Cast0->getType());

return nullptr;
2047}

2049/// Given a bitwise logic op, check if the operands are add/sub with a common
2050/// source value and inverted constant (identity: C - X -> ~(X + ~C)).
2051static Value *simplifyLogicOfAddSub(Value *Op0, Value *Op1,
                                  Instruction::BinaryOps Opcode) {
assert(Op0->getType() == Op1->getType() && "Mismatched binop types")(static_cast <bool> (Op0->getType() == Op1->getType
() && "Mismatched binop types") ? void (0) : __assert_fail
 ("Op0->getType() == Op1->getType() && \"Mismatched binop types\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 2053, __extension__
 __PRETTY_FUNCTION__));
assert(BinaryOperator::isBitwiseLogicOp(Opcode) && "Expected logic op")(static_cast <bool> (BinaryOperator::isBitwiseLogicOp(Opcode
) && "Expected logic op") ? void (0) : __assert_fail (
"BinaryOperator::isBitwiseLogicOp(Opcode) && \"Expected logic op\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 2054, __extension__
 __PRETTY_FUNCTION__));
Value *X;
Constant *C1, *C2;
if ((match(Op0, m_Add(m_Value(X), m_Constant(C1))) &&
     match(Op1, m_Sub(m_Constant(C2), m_Specific(X)))) ||
    (match(Op1, m_Add(m_Value(X), m_Constant(C1))) &&
     match(Op0, m_Sub(m_Constant(C2), m_Specific(X))))) {
  if (ConstantExpr::getNot(C1) == C2) {
    // (X + C) & (~C - X) --> (X + C) & ~(X + C) --> 0
    // (X + C) | (~C - X) --> (X + C) | ~(X + C) --> -1
    // (X + C) ^ (~C - X) --> (X + C) ^ ~(X + C) --> -1
    Type *Ty = Op0->getType();
    return Opcode == Instruction::And ? ConstantInt::getNullValue(Ty)
                                      : ConstantInt::getAllOnesValue(Ty);
  }
}
return nullptr;
2071}

2073/// Given operands for an And, see if we can fold the result.
2074/// If not, this returns null.
2075static Value *simplifyAndInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                            unsigned MaxRecurse) {
if (Constant *C = foldOrCommuteConstant(Instruction::And, Op0, Op1, Q))
  return C;

// X & poison -> poison
if (isa<PoisonValue>(Op1))
  return Op1;

// X & undef -> 0
if (Q.isUndefValue(Op1))
  return Constant::getNullValue(Op0->getType());

// X & X = X
if (Op0 == Op1)
  return Op0;

// X & 0 = 0
if (match(Op1, m_Zero()))
  return Constant::getNullValue(Op0->getType());

// X & -1 = X
if (match(Op1, m_AllOnes()))
  return Op0;

// A & ~A  =  ~A & A  =  0
if (match(Op0, m_Not(m_Specific(Op1))) || match(Op1, m_Not(m_Specific(Op0))))
  return Constant::getNullValue(Op0->getType());

// (A | ?) & A = A
if (match(Op0, m_c_Or(m_Specific(Op1), m_Value())))
  return Op1;

// A & (A | ?) = A
if (match(Op1, m_c_Or(m_Specific(Op0), m_Value())))
  return Op0;

// (X | Y) & (X | ~Y) --> X (commuted 8 ways)
Value *X, *Y;
if (match(Op0, m_c_Or(m_Value(X), m_Not(m_Value(Y)))) &&
    match(Op1, m_c_Or(m_Deferred(X), m_Deferred(Y))))
  return X;
if (match(Op1, m_c_Or(m_Value(X), m_Not(m_Value(Y)))) &&
    match(Op0, m_c_Or(m_Deferred(X), m_Deferred(Y))))
  return X;

if (Value *V = simplifyLogicOfAddSub(Op0, Op1, Instruction::And))
  return V;

// A mask that only clears known zeros of a shifted value is a no-op.
const APInt *Mask;
const APInt *ShAmt;
if (match(Op1, m_APInt(Mask))) {
  // If all bits in the inverted and shifted mask are clear:
  // and (shl X, ShAmt), Mask --> shl X, ShAmt
  if (match(Op0, m_Shl(m_Value(X), m_APInt(ShAmt))) &&
      (~(*Mask)).lshr(*ShAmt).isZero())
    return Op0;

  // If all bits in the inverted and shifted mask are clear:
  // and (lshr X, ShAmt), Mask --> lshr X, ShAmt
  if (match(Op0, m_LShr(m_Value(X), m_APInt(ShAmt))) &&
      (~(*Mask)).shl(*ShAmt).isZero())
    return Op0;
}

// If we have a multiplication overflow check that is being 'and'ed with a
// check that one of the multipliers is not zero, we can omit the 'and', and
// only keep the overflow check.
if (isCheckForZeroAndMulWithOverflow(Op0, Op1, true))
  return Op1;
if (isCheckForZeroAndMulWithOverflow(Op1, Op0, true))
  return Op0;

// A & (-A) = A if A is a power of two or zero.
if (match(Op0, m_Neg(m_Specific(Op1))) ||
    match(Op1, m_Neg(m_Specific(Op0)))) {
  if (isKnownToBeAPowerOfTwo(Op0, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI,
                             Q.DT))
    return Op0;
  if (isKnownToBeAPowerOfTwo(Op1, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI,
                             Q.DT))
    return Op1;
}

// This is a similar pattern used for checking if a value is a power-of-2:
// (A - 1) & A --> 0 (if A is a power-of-2 or 0)
// A & (A - 1) --> 0 (if A is a power-of-2 or 0)
if (match(Op0, m_Add(m_Specific(Op1), m_AllOnes())) &&
    isKnownToBeAPowerOfTwo(Op1, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI, Q.DT))
  return Constant::getNullValue(Op1->getType());
if (match(Op1, m_Add(m_Specific(Op0), m_AllOnes())) &&
    isKnownToBeAPowerOfTwo(Op0, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI, Q.DT))
  return Constant::getNullValue(Op0->getType());

if (Value *V = simplifyAndOrOfCmps(Q, Op0, Op1, true))
  return V;

// Try some generic simplifications for associative operations.
if (Value *V =
        simplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q, MaxRecurse))
  return V;

// And distributes over Or.  Try some generic simplifications based on this.
if (Value *V = expandCommutativeBinOp(Instruction::And, Op0, Op1,
                                      Instruction::Or, Q, MaxRecurse))
  return V;

// And distributes over Xor.  Try some generic simplifications based on this.
if (Value *V = expandCommutativeBinOp(Instruction::And, Op0, Op1,
                                      Instruction::Xor, Q, MaxRecurse))
  return V;

if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) {
  if (Op0->getType()->isIntOrIntVectorTy(1)) {
    // A & (A && B) -> A && B
    if (match(Op1, m_Select(m_Specific(Op0), m_Value(), m_Zero())))
      return Op1;
    else if (match(Op0, m_Select(m_Specific(Op1), m_Value(), m_Zero())))
      return Op0;
  }
  // If the operation is with the result of a select instruction, check
  // whether operating on either branch of the select always yields the same
  // value.
  if (Value *V =
          threadBinOpOverSelect(Instruction::And, Op0, Op1, Q, MaxRecurse))
    return V;
}

// If the operation is with the result of a phi instruction, check whether
// operating on all incoming values of the phi always yields the same value.
if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
  if (Value *V =
          threadBinOpOverPHI(Instruction::And, Op0, Op1, Q, MaxRecurse))
    return V;

// Assuming the effective width of Y is not larger than A, i.e. all bits
// from X and Y are disjoint in (X << A) | Y,
// if the mask of this AND op covers all bits of X or Y, while it covers
// no bits from the other, we can bypass this AND op. E.g.,
// ((X << A) | Y) & Mask -> Y,
//     if Mask = ((1 << effective_width_of(Y)) - 1)
// ((X << A) | Y) & Mask -> X << A,
//     if Mask = ((1 << effective_width_of(X)) - 1) << A
// SimplifyDemandedBits in InstCombine can optimize the general case.
// This pattern aims to help other passes for a common case.
Value *XShifted;
if (match(Op1, m_APInt(Mask)) &&
    match(Op0, m_c_Or(m_CombineAnd(m_NUWShl(m_Value(X), m_APInt(ShAmt)),
                                   m_Value(XShifted)),
                      m_Value(Y)))) {
  const unsigned Width = Op0->getType()->getScalarSizeInBits();
  const unsigned ShftCnt = ShAmt->getLimitedValue(Width);
  const KnownBits YKnown = computeKnownBits(Y, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
  const unsigned EffWidthY = YKnown.countMaxActiveBits();
  if (EffWidthY <= ShftCnt) {
    const KnownBits XKnown = computeKnownBits(X, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
    const unsigned EffWidthX = XKnown.countMaxActiveBits();
    const APInt EffBitsY = APInt::getLowBitsSet(Width, EffWidthY);
    const APInt EffBitsX = APInt::getLowBitsSet(Width, EffWidthX) << ShftCnt;
    // If the mask is extracting all bits from X or Y as is, we can skip
    // this AND op.
    if (EffBitsY.isSubsetOf(*Mask) && !EffBitsX.intersects(*Mask))
      return Y;
    if (EffBitsX.isSubsetOf(*Mask) && !EffBitsY.intersects(*Mask))
      return XShifted;
  }
}

// ((X | Y) ^ X ) & ((X | Y) ^ Y) --> 0
// ((X | Y) ^ Y ) & ((X | Y) ^ X) --> 0
BinaryOperator *Or;
if (match(Op0, m_c_Xor(m_Value(X),
                       m_CombineAnd(m_BinOp(Or),
                                    m_c_Or(m_Deferred(X), m_Value(Y))))) &&
    match(Op1, m_c_Xor(m_Specific(Or), m_Specific(Y))))
  return Constant::getNullValue(Op0->getType());

if (Op0->getType()->isIntOrIntVectorTy(1)) {
  if (std::optional<bool> Implied = isImpliedCondition(Op0, Op1, Q.DL)) {
    // If Op0 is true implies Op1 is true, then Op0 is a subset of Op1.
    if (*Implied == true)
      return Op0;
    // If Op0 is true implies Op1 is false, then they are not true together.
    if (*Implied == false)
      return ConstantInt::getFalse(Op0->getType());
  }
  if (std::optional<bool> Implied = isImpliedCondition(Op1, Op0, Q.DL)) {
    // If Op1 is true implies Op0 is true, then Op1 is a subset of Op0.
    if (*Implied)
      return Op1;
    // If Op1 is true implies Op0 is false, then they are not true together.
    if (!*Implied)
      return ConstantInt::getFalse(Op1->getType());
  }
}

if (Value *V = simplifyByDomEq(Instruction::And, Op0, Op1, Q, MaxRecurse))
  return V;

return nullptr;
2276}

2278Value *llvm::simplifyAndInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
return ::simplifyAndInst(Op0, Op1, Q, RecursionLimit);
2280}

2282// TODO: Many of these folds could use LogicalAnd/LogicalOr.
2283static Value *simplifyOrLogic(Value *X, Value *Y) {
assert(X->getType() == Y->getType() && "Expected same type for 'or' ops")(static_cast <bool> (X->getType() == Y->getType()
 && "Expected same type for 'or' ops") ? void (0) : __assert_fail
 ("X->getType() == Y->getType() && \"Expected same type for 'or' ops\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 2284, __extension__
 __PRETTY_FUNCTION__));
Type *Ty = X->getType();

// X | ~X --> -1
if (match(Y, m_Not(m_Specific(X))))
  return ConstantInt::getAllOnesValue(Ty);

// X | ~(X & ?) = -1
if (match(Y, m_Not(m_c_And(m_Specific(X), m_Value()))))
  return ConstantInt::getAllOnesValue(Ty);

// X | (X & ?) --> X
if (match(Y, m_c_And(m_Specific(X), m_Value())))
  return X;

Value *A, *B;

// (A ^ B) | (A | B) --> A | B
// (A ^ B) | (B | A) --> B | A
if (match(X, m_Xor(m_Value(A), m_Value(B))) &&
    match(Y, m_c_Or(m_Specific(A), m_Specific(B))))
  return Y;

// ~(A ^ B) | (A | B) --> -1
// ~(A ^ B) | (B | A) --> -1
if (match(X, m_Not(m_Xor(m_Value(A), m_Value(B)))) &&
    match(Y, m_c_Or(m_Specific(A), m_Specific(B))))
  return ConstantInt::getAllOnesValue(Ty);

// (A & ~B) | (A ^ B) --> A ^ B
// (~B & A) | (A ^ B) --> A ^ B
// (A & ~B) | (B ^ A) --> B ^ A
// (~B & A) | (B ^ A) --> B ^ A
if (match(X, m_c_And(m_Value(A), m_Not(m_Value(B)))) &&
    match(Y, m_c_Xor(m_Specific(A), m_Specific(B))))
  return Y;

// (~A ^ B) | (A & B) --> ~A ^ B
// (B ^ ~A) | (A & B) --> B ^ ~A
// (~A ^ B) | (B & A) --> ~A ^ B
// (B ^ ~A) | (B & A) --> B ^ ~A
if (match(X, m_c_Xor(m_NotForbidUndef(m_Value(A)), m_Value(B))) &&
    match(Y, m_c_And(m_Specific(A), m_Specific(B))))
  return X;

// (~A | B) | (A ^ B) --> -1
// (~A | B) | (B ^ A) --> -1
// (B | ~A) | (A ^ B) --> -1
// (B | ~A) | (B ^ A) --> -1
if (match(X, m_c_Or(m_Not(m_Value(A)), m_Value(B))) &&
    match(Y, m_c_Xor(m_Specific(A), m_Specific(B))))
  return ConstantInt::getAllOnesValue(Ty);

// (~A & B) | ~(A | B) --> ~A
// (~A & B) | ~(B | A) --> ~A
// (B & ~A) | ~(A | B) --> ~A
// (B & ~A) | ~(B | A) --> ~A
Value *NotA;
if (match(X,
          m_c_And(m_CombineAnd(m_Value(NotA), m_NotForbidUndef(m_Value(A))),
                  m_Value(B))) &&
    match(Y, m_Not(m_c_Or(m_Specific(A), m_Specific(B)))))
  return NotA;
// The same is true of Logical And
// TODO: This could share the logic of the version above if there was a
// version of LogicalAnd that allowed more than just i1 types.
if (match(X, m_c_LogicalAnd(
                 m_CombineAnd(m_Value(NotA), m_NotForbidUndef(m_Value(A))),
                 m_Value(B))) &&
    match(Y, m_Not(m_c_LogicalOr(m_Specific(A), m_Specific(B)))))
  return NotA;

// ~(A ^ B) | (A & B) --> ~(A ^ B)
// ~(A ^ B) | (B & A) --> ~(A ^ B)
Value *NotAB;
if (match(X, m_CombineAnd(m_NotForbidUndef(m_Xor(m_Value(A), m_Value(B))),
                          m_Value(NotAB))) &&
    match(Y, m_c_And(m_Specific(A), m_Specific(B))))
  return NotAB;

// ~(A & B) | (A ^ B) --> ~(A & B)
// ~(A & B) | (B ^ A) --> ~(A & B)
if (match(X, m_CombineAnd(m_NotForbidUndef(m_And(m_Value(A), m_Value(B))),
                          m_Value(NotAB))) &&
    match(Y, m_c_Xor(m_Specific(A), m_Specific(B))))
  return NotAB;

return nullptr;
2372}

2374/// Given operands for an Or, see if we can fold the result.
2375/// If not, this returns null.
2376static Value *simplifyOrInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                           unsigned MaxRecurse) {
if (Constant *C = foldOrCommuteConstant(Instruction::Or, Op0, Op1, Q))
  return C;

// X | poison -> poison
if (isa<PoisonValue>(Op1))
  return Op1;

// X | undef -> -1
// X | -1 = -1
// Do not return Op1 because it may contain undef elements if it's a vector.
if (Q.isUndefValue(Op1) || match(Op1, m_AllOnes()))
  return Constant::getAllOnesValue(Op0->getType());

// X | X = X
// X | 0 = X
if (Op0 == Op1 || match(Op1, m_Zero()))
  return Op0;

if (Value *R = simplifyOrLogic(Op0, Op1))
  return R;
if (Value *R = simplifyOrLogic(Op1, Op0))
  return R;

if (Value *V = simplifyLogicOfAddSub(Op0, Op1, Instruction::Or))
  return V;

// Rotated -1 is still -1:
// (-1 << X) | (-1 >> (C - X)) --> -1
// (-1 >> X) | (-1 << (C - X)) --> -1
// ...with C <= bitwidth (and commuted variants).
Value *X, *Y;
if ((match(Op0, m_Shl(m_AllOnes(), m_Value(X))) &&
     match(Op1, m_LShr(m_AllOnes(), m_Value(Y)))) ||
    (match(Op1, m_Shl(m_AllOnes(), m_Value(X))) &&
     match(Op0, m_LShr(m_AllOnes(), m_Value(Y))))) {
  const APInt *C;
  if ((match(X, m_Sub(m_APInt(C), m_Specific(Y))) ||
       match(Y, m_Sub(m_APInt(C), m_Specific(X)))) &&
      C->ule(X->getType()->getScalarSizeInBits())) {
    return ConstantInt::getAllOnesValue(X->getType());
  }
}

// A funnel shift (rotate) can be decomposed into simpler shifts. See if we
// are mixing in another shift that is redundant with the funnel shift.

// (fshl X, ?, Y) | (shl X, Y) --> fshl X, ?, Y
// (shl X, Y) | (fshl X, ?, Y) --> fshl X, ?, Y
if (match(Op0,
          m_Intrinsic<Intrinsic::fshl>(m_Value(X), m_Value(), m_Value(Y))) &&
    match(Op1, m_Shl(m_Specific(X), m_Specific(Y))))
  return Op0;
if (match(Op1,
          m_Intrinsic<Intrinsic::fshl>(m_Value(X), m_Value(), m_Value(Y))) &&
    match(Op0, m_Shl(m_Specific(X), m_Specific(Y))))
  return Op1;

// (fshr ?, X, Y) | (lshr X, Y) --> fshr ?, X, Y
// (lshr X, Y) | (fshr ?, X, Y) --> fshr ?, X, Y
if (match(Op0,
          m_Intrinsic<Intrinsic::fshr>(m_Value(), m_Value(X), m_Value(Y))) &&
    match(Op1, m_LShr(m_Specific(X), m_Specific(Y))))
  return Op0;
if (match(Op1,
          m_Intrinsic<Intrinsic::fshr>(m_Value(), m_Value(X), m_Value(Y))) &&
    match(Op0, m_LShr(m_Specific(X), m_Specific(Y))))
  return Op1;

if (Value *V = simplifyAndOrOfCmps(Q, Op0, Op1, false))
  return V;

// If we have a multiplication overflow check that is being 'and'ed with a
// check that one of the multipliers is not zero, we can omit the 'and', and
// only keep the overflow check.
if (isCheckForZeroAndMulWithOverflow(Op0, Op1, false))
  return Op1;
if (isCheckForZeroAndMulWithOverflow(Op1, Op0, false))
  return Op0;

// Try some generic simplifications for associative operations.
if (Value *V =
        simplifyAssociativeBinOp(Instruction::Or, Op0, Op1, Q, MaxRecurse))
  return V;

// Or distributes over And.  Try some generic simplifications based on this.
if (Value *V = expandCommutativeBinOp(Instruction::Or, Op0, Op1,
                                      Instruction::And, Q, MaxRecurse))
  return V;

if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) {
  if (Op0->getType()->isIntOrIntVectorTy(1)) {
    // A | (A || B) -> A || B
    if (match(Op1, m_Select(m_Specific(Op0), m_One(), m_Value())))
      return Op1;
    else if (match(Op0, m_Select(m_Specific(Op1), m_One(), m_Value())))
      return Op0;
  }
  // If the operation is with the result of a select instruction, check
  // whether operating on either branch of the select always yields the same
  // value.
  if (Value *V =
          threadBinOpOverSelect(Instruction::Or, Op0, Op1, Q, MaxRecurse))
    return V;
}

// (A & C1)|(B & C2)
Value *A, *B;
const APInt *C1, *C2;
if (match(Op0, m_And(m_Value(A), m_APInt(C1))) &&
    match(Op1, m_And(m_Value(B), m_APInt(C2)))) {
  if (*C1 == ~*C2) {
    // (A & C1)|(B & C2)
    // If we have: ((V + N) & C1) | (V & C2)
    // .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0
    // replace with V+N.
    Value *N;
    if (C2->isMask() && // C2 == 0+1+
        match(A, m_c_Add(m_Specific(B), m_Value(N)))) {
      // Add commutes, try both ways.
      if (MaskedValueIsZero(N, *C2, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
        return A;
    }
    // Or commutes, try both ways.
    if (C1->isMask() && match(B, m_c_Add(m_Specific(A), m_Value(N)))) {
      // Add commutes, try both ways.
      if (MaskedValueIsZero(N, *C1, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
        return B;
    }
  }
}

// If the operation is with the result of a phi instruction, check whether
// operating on all incoming values of the phi always yields the same value.
if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
  if (Value *V = threadBinOpOverPHI(Instruction::Or, Op0, Op1, Q, MaxRecurse))
    return V;

if (Op0->getType()->isIntOrIntVectorTy(1)) {
  if (std::optional<bool> Implied =
          isImpliedCondition(Op0, Op1, Q.DL, false)) {
    // If Op0 is false implies Op1 is false, then Op1 is a subset of Op0.
    if (*Implied == false)
      return Op0;
    // If Op0 is false implies Op1 is true, then at least one is always true.
    if (*Implied == true)
      return ConstantInt::getTrue(Op0->getType());
  }
  if (std::optional<bool> Implied =
          isImpliedCondition(Op1, Op0, Q.DL, false)) {
    // If Op1 is false implies Op0 is false, then Op0 is a subset of Op1.
    if (*Implied == false)
      return Op1;
    // If Op1 is false implies Op0 is true, then at least one is always true.
    if (*Implied == true)
      return ConstantInt::getTrue(Op1->getType());
  }
}

if (Value *V = simplifyByDomEq(Instruction::Or, Op0, Op1, Q, MaxRecurse))
  return V;

return nullptr;
2540}

2542Value *llvm::simplifyOrInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
return ::simplifyOrInst(Op0, Op1, Q, RecursionLimit);
2544}

2546/// Given operands for a Xor, see if we can fold the result.
2547/// If not, this returns null.
2548static Value *simplifyXorInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                            unsigned MaxRecurse) {
if (Constant *C = foldOrCommuteConstant(Instruction::Xor, Op0, Op1, Q))
  return C;

// X ^ poison -> poison
if (isa<PoisonValue>(Op1))
  return Op1;

// A ^ undef -> undef
if (Q.isUndefValue(Op1))
  return Op1;

// A ^ 0 = A
if (match(Op1, m_Zero()))
  return Op0;

// A ^ A = 0
if (Op0 == Op1)
  return Constant::getNullValue(Op0->getType());

// A ^ ~A  =  ~A ^ A  =  -1
if (match(Op0, m_Not(m_Specific(Op1))) || match(Op1, m_Not(m_Specific(Op0))))
  return Constant::getAllOnesValue(Op0->getType());

auto foldAndOrNot = [](Value *X, Value *Y) -> Value * {
  Value *A, *B;
  // (~A & B) ^ (A | B) --> A -- There are 8 commuted variants.
  if (match(X, m_c_And(m_Not(m_Value(A)), m_Value(B))) &&
      match(Y, m_c_Or(m_Specific(A), m_Specific(B))))
    return A;

  // (~A | B) ^ (A & B) --> ~A -- There are 8 commuted variants.
  // The 'not' op must contain a complete -1 operand (no undef elements for
  // vector) for the transform to be safe.
  Value *NotA;
  if (match(X,
            m_c_Or(m_CombineAnd(m_NotForbidUndef(m_Value(A)), m_Value(NotA)),
                   m_Value(B))) &&
      match(Y, m_c_And(m_Specific(A), m_Specific(B))))
    return NotA;

  return nullptr;
};
if (Value *R = foldAndOrNot(Op0, Op1))
  return R;
if (Value *R = foldAndOrNot(Op1, Op0))
  return R;

if (Value *V = simplifyLogicOfAddSub(Op0, Op1, Instruction::Xor))
  return V;

// Try some generic simplifications for associative operations.
if (Value *V =
        simplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, Q, MaxRecurse))
  return V;

// Threading Xor over selects and phi nodes is pointless, so don't bother.
// Threading over the select in "A ^ select(cond, B, C)" means evaluating
// "A^B" and "A^C" and seeing if they are equal; but they are equal if and
// only if B and C are equal.  If B and C are equal then (since we assume
// that operands have already been simplified) "select(cond, B, C)" should
// have been simplified to the common value of B and C already.  Analysing
// "A^B" and "A^C" thus gains nothing, but costs compile time.  Similarly
// for threading over phi nodes.

if (Value *V = simplifyByDomEq(Instruction::Xor, Op0, Op1, Q, MaxRecurse))
  return V;

return nullptr;
2618}

2620Value *llvm::simplifyXorInst(Value *Op0, Value *Op1, const SimplifyQuery &Q) {
return ::simplifyXorInst(Op0, Op1, Q, RecursionLimit);
2622}

2624static Type *getCompareTy(Value *Op) {
return CmpInst::makeCmpResultType(Op->getType());
2626}

2628/// Rummage around inside V looking for something equivalent to the comparison
2629/// "LHS Pred RHS". Return such a value if found, otherwise return null.
2630/// Helper function for analyzing max/min idioms.
2631static Value *extractEquivalentCondition(Value *V, CmpInst::Predicate Pred,
                                       Value *LHS, Value *RHS) {
SelectInst *SI = dyn_cast<SelectInst>(V);
if (!SI)
  return nullptr;
CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition());
if (!Cmp)
  return nullptr;
Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1);
if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS)
  return Cmp;
if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) &&
    LHS == CmpRHS && RHS == CmpLHS)
  return Cmp;
return nullptr;
2646}

2648/// Return true if the underlying object (storage) must be disjoint from
2649/// storage returned by any noalias return call.
2650static bool isAllocDisjoint(const Value *V) {
// For allocas, we consider only static ones (dynamic
// allocas might be transformed into calls to malloc not simultaneously
// live with the compared-to allocation). For globals, we exclude symbols
// that might be resolve lazily to symbols in another dynamically-loaded
// library (and, thus, could be malloc'ed by the implementation).
if (const AllocaInst *AI = dyn_cast<AllocaInst>(V))
  return AI->getParent() && AI->getFunction() && AI->isStaticAlloca();
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
  return (GV->hasLocalLinkage() || GV->hasHiddenVisibility() ||
          GV->hasProtectedVisibility() || GV->hasGlobalUnnamedAddr()) &&
         !GV->isThreadLocal();
if (const Argument *A = dyn_cast<Argument>(V))
  return A->hasByValAttr();
return false;
2665}

2667/// Return true if V1 and V2 are each the base of some distict storage region
2668/// [V, object_size(V)] which do not overlap.  Note that zero sized regions
2669/// *are* possible, and that zero sized regions do not overlap with any other.
2670static bool haveNonOverlappingStorage(const Value *V1, const Value *V2) {
// Global variables always exist, so they always exist during the lifetime
// of each other and all allocas.  Global variables themselves usually have
// non-overlapping storage, but since their addresses are constants, the
// case involving two globals does not reach here and is instead handled in
// constant folding.
//
// Two different allocas usually have different addresses...
//
// However, if there's an @llvm.stackrestore dynamically in between two
// allocas, they may have the same address. It's tempting to reduce the
// scope of the problem by only looking at *static* allocas here. That would
// cover the majority of allocas while significantly reducing the likelihood
// of having an @llvm.stackrestore pop up in the middle. However, it's not
// actually impossible for an @llvm.stackrestore to pop up in the middle of
// an entry block. Also, if we have a block that's not attached to a
// function, we can't tell if it's "static" under the current definition.
// Theoretically, this problem could be fixed by creating a new kind of
// instruction kind specifically for static allocas. Such a new instruction
// could be required to be at the top of the entry block, thus preventing it
// from being subject to a @llvm.stackrestore. Instcombine could even
// convert regular allocas into these special allocas. It'd be nifty.
// However, until then, this problem remains open.
//
// So, we'll assume that two non-empty allocas have different addresses
// for now.
auto isByValArg = [](const Value *V) {
  const Argument *A = dyn_cast<Argument>(V);
  return A && A->hasByValAttr();
};

// Byval args are backed by store which does not overlap with each other,
// allocas, or globals.
if (isByValArg(V1))
  return isa<AllocaInst>(V2) || isa<GlobalVariable>(V2) || isByValArg(V2);
if (isByValArg(V2))
  return isa<AllocaInst>(V1) || isa<GlobalVariable>(V1) || isByValArg(V1);

return isa<AllocaInst>(V1) &&
       (isa<AllocaInst>(V2) || isa<GlobalVariable>(V2));
2710}

2712// A significant optimization not implemented here is assuming that alloca
2713// addresses are not equal to incoming argument values. They don't *alias*,
2714// as we say, but that doesn't mean they aren't equal, so we take a
2715// conservative approach.
2716//
2717// This is inspired in part by C++11 5.10p1:
2718//   "Two pointers of the same type compare equal if and only if they are both
2719//    null, both point to the same function, or both represent the same
2720//    address."
2721//
2722// This is pretty permissive.
2723//
2724// It's also partly due to C11 6.5.9p6:
2725//   "Two pointers compare equal if and only if both are null pointers, both are
2726//    pointers to the same object (including a pointer to an object and a
2727//    subobject at its beginning) or function, both are pointers to one past the
2728//    last element of the same array object, or one is a pointer to one past the
2729//    end of one array object and the other is a pointer to the start of a
2730//    different array object that happens to immediately follow the first array
2731//    object in the address space.)
2732//
2733// C11's version is more restrictive, however there's no reason why an argument
2734// couldn't be a one-past-the-end value for a stack object in the caller and be
2735// equal to the beginning of a stack object in the callee.
2736//
2737// If the C and C++ standards are ever made sufficiently restrictive in this
2738// area, it may be possible to update LLVM's semantics accordingly and reinstate
2739// this optimization.
2740static Constant *computePointerICmp(CmpInst::Predicate Pred, Value *LHS,
                                  Value *RHS, const SimplifyQuery &Q) {
const DataLayout &DL = Q.DL;
const TargetLibraryInfo *TLI = Q.TLI;
const DominatorTree *DT = Q.DT;
const Instruction *CxtI = Q.CxtI;
const InstrInfoQuery &IIQ = Q.IIQ;

// First, skip past any trivial no-ops.
LHS = LHS->stripPointerCasts();
RHS = RHS->stripPointerCasts();

// A non-null pointer is not equal to a null pointer.
if (isa<ConstantPointerNull>(RHS) && ICmpInst::isEquality(Pred) &&
    llvm::isKnownNonZero(LHS, DL, 0, nullptr, nullptr, nullptr,
                         IIQ.UseInstrInfo))
  return ConstantInt::get(getCompareTy(LHS), !CmpInst::isTrueWhenEqual(Pred));

// We can only fold certain predicates on pointer comparisons.
switch (Pred) {
default:
  return nullptr;

  // Equality comparisons are easy to fold.
case CmpInst::ICMP_EQ:
case CmpInst::ICMP_NE:
  break;

  // We can only handle unsigned relational comparisons because 'inbounds' on
  // a GEP only protects against unsigned wrapping.
case CmpInst::ICMP_UGT:
case CmpInst::ICMP_UGE:
case CmpInst::ICMP_ULT:
case CmpInst::ICMP_ULE:
  // However, we have to switch them to their signed variants to handle
  // negative indices from the base pointer.
  Pred = ICmpInst::getSignedPredicate(Pred);
  break;
}

// Strip off any constant offsets so that we can reason about them.
// It's tempting to use getUnderlyingObject or even just stripInBoundsOffsets
// here and compare base addresses like AliasAnalysis does, however there are
// numerous hazards. AliasAnalysis and its utilities rely on special rules
// governing loads and stores which don't apply to icmps. Also, AliasAnalysis
// doesn't need to guarantee pointer inequality when it says NoAlias.

// Even if an non-inbounds GEP occurs along the path we can still optimize
// equality comparisons concerning the result.
bool AllowNonInbounds = ICmpInst::isEquality(Pred);
APInt LHSOffset = stripAndComputeConstantOffsets(DL, LHS, AllowNonInbounds);
APInt RHSOffset = stripAndComputeConstantOffsets(DL, RHS, AllowNonInbounds);

// If LHS and RHS are related via constant offsets to the same base
// value, we can replace it with an icmp which just compares the offsets.
if (LHS == RHS)
  return ConstantInt::get(getCompareTy(LHS),
                          ICmpInst::compare(LHSOffset, RHSOffset, Pred));

// Various optimizations for (in)equality comparisons.
if (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE) {
  // Different non-empty allocations that exist at the same time have
  // different addresses (if the program can tell). If the offsets are
  // within the bounds of their allocations (and not one-past-the-end!
  // so we can't use inbounds!), and their allocations aren't the same,
  // the pointers are not equal.
  if (haveNonOverlappingStorage(LHS, RHS)) {
    uint64_t LHSSize, RHSSize;
    ObjectSizeOpts Opts;
    Opts.EvalMode = ObjectSizeOpts::Mode::Min;
    auto *F = [](Value *V) -> Function * {
      if (auto *I = dyn_cast<Instruction>(V))
        return I->getFunction();
      if (auto *A = dyn_cast<Argument>(V))
        return A->getParent();
      return nullptr;
    }(LHS);
    Opts.NullIsUnknownSize = F ? NullPointerIsDefined(F) : true;
    if (getObjectSize(LHS, LHSSize, DL, TLI, Opts) &&
        getObjectSize(RHS, RHSSize, DL, TLI, Opts) &&
        !LHSOffset.isNegative() && !RHSOffset.isNegative() &&
        LHSOffset.ult(LHSSize) && RHSOffset.ult(RHSSize)) {
      return ConstantInt::get(getCompareTy(LHS),
                              !CmpInst::isTrueWhenEqual(Pred));
    }
  }

  // If one side of the equality comparison must come from a noalias call
  // (meaning a system memory allocation function), and the other side must
  // come from a pointer that cannot overlap with dynamically-allocated
  // memory within the lifetime of the current function (allocas, byval
  // arguments, globals), then determine the comparison result here.
  SmallVector<const Value *, 8> LHSUObjs, RHSUObjs;
  getUnderlyingObjects(LHS, LHSUObjs);
  getUnderlyingObjects(RHS, RHSUObjs);

  // Is the set of underlying objects all noalias calls?
  auto IsNAC = [](ArrayRef<const Value *> Objects) {
    return all_of(Objects, isNoAliasCall);
  };

  // Is the set of underlying objects all things which must be disjoint from
  // noalias calls.  We assume that indexing from such disjoint storage
  // into the heap is undefined, and thus offsets can be safely ignored.
  auto IsAllocDisjoint = [](ArrayRef<const Value *> Objects) {
    return all_of(Objects, ::isAllocDisjoint);
  };

  if ((IsNAC(LHSUObjs) && IsAllocDisjoint(RHSUObjs)) ||
      (IsNAC(RHSUObjs) && IsAllocDisjoint(LHSUObjs)))
    return ConstantInt::get(getCompareTy(LHS),
                            !CmpInst::isTrueWhenEqual(Pred));

  // Fold comparisons for non-escaping pointer even if the allocation call
  // cannot be elided. We cannot fold malloc comparison to null. Also, the
  // dynamic allocation call could be either of the operands.  Note that
  // the other operand can not be based on the alloc - if it were, then
  // the cmp itself would be a capture.
  Value *MI = nullptr;
  if (isAllocLikeFn(LHS, TLI) &&
      llvm::isKnownNonZero(RHS, DL, 0, nullptr, CxtI, DT))
    MI = LHS;
  else if (isAllocLikeFn(RHS, TLI) &&
           llvm::isKnownNonZero(LHS, DL, 0, nullptr, CxtI, DT))
    MI = RHS;
  if (MI) {
    // FIXME: This is incorrect, see PR54002. While we can assume that the
    // allocation is at an address that makes the comparison false, this
    // requires that *all* comparisons to that address be false, which
    // InstSimplify cannot guarantee.
    struct CustomCaptureTracker : public CaptureTracker {
      bool Captured = false;
      void tooManyUses() override { Captured = true; }
      bool captured(const Use *U) override {
        if (auto *ICmp = dyn_cast<ICmpInst>(U->getUser())) {
          // Comparison against value stored in global variable. Given the
          // pointer does not escape, its value cannot be guessed and stored
          // separately in a global variable.
          unsigned OtherIdx = 1 - U->getOperandNo();
          auto *LI = dyn_cast<LoadInst>(ICmp->getOperand(OtherIdx));
          if (LI && isa<GlobalVariable>(LI->getPointerOperand()))
            return false;
        }

        Captured = true;
        return true;
      }
    };
    CustomCaptureTracker Tracker;
    PointerMayBeCaptured(MI, &Tracker);
    if (!Tracker.Captured)
      return ConstantInt::get(getCompareTy(LHS),
                              CmpInst::isFalseWhenEqual(Pred));
  }
}

// Otherwise, fail.
return nullptr;
2898}

2900/// Fold an icmp when its operands have i1 scalar type.
2901static Value *simplifyICmpOfBools(CmpInst::Predicate Pred, Value *LHS,
                                Value *RHS, const SimplifyQuery &Q) {
Type *ITy = getCompareTy(LHS); // The return type.
Type *OpTy = LHS->getType();   // The operand type.
if (!OpTy->isIntOrIntVectorTy(1))
  return nullptr;

// A boolean compared to true/false can be reduced in 14 out of the 20
// (10 predicates * 2 constants) possible combinations. The other
// 6 cases require a 'not' of the LHS.

auto ExtractNotLHS = [](Value *V) -> Value * {
  Value *X;
  if (match(V, m_Not(m_Value(X))))
    return X;
  return nullptr;
};

if (match(RHS, m_Zero())) {
  switch (Pred) {
  case CmpInst::ICMP_NE:  // X !=  0 -> X
  case CmpInst::ICMP_UGT: // X >u  0 -> X
  case CmpInst::ICMP_SLT: // X <s  0 -> X
    return LHS;

  case CmpInst::ICMP_EQ:  // not(X) ==  0 -> X != 0 -> X
  case CmpInst::ICMP_ULE: // not(X) <=u 0 -> X >u 0 -> X
  case CmpInst::ICMP_SGE: // not(X) >=s 0 -> X <s 0 -> X
    if (Value *X = ExtractNotLHS(LHS))
      return X;
    break;

  case CmpInst::ICMP_ULT: // X <u  0 -> false
  case CmpInst::ICMP_SGT: // X >s  0 -> false
    return getFalse(ITy);

  case CmpInst::ICMP_UGE: // X >=u 0 -> true
  case CmpInst::ICMP_SLE: // X <=s 0 -> true
    return getTrue(ITy);

  default:
    break;
  }
} else if (match(RHS, m_One())) {
  switch (Pred) {
  case CmpInst::ICMP_EQ:  // X ==   1 -> X
  case CmpInst::ICMP_UGE: // X >=u  1 -> X
  case CmpInst::ICMP_SLE: // X <=s -1 -> X
    return LHS;

  case CmpInst::ICMP_NE:  // not(X) !=  1 -> X ==   1 -> X
  case CmpInst::ICMP_ULT: // not(X) <=u 1 -> X >=u  1 -> X
  case CmpInst::ICMP_SGT: // not(X) >s  1 -> X <=s -1 -> X
    if (Value *X = ExtractNotLHS(LHS))
      return X;
    break;

  case CmpInst::ICMP_UGT: // X >u   1 -> false
  case CmpInst::ICMP_SLT: // X <s  -1 -> false
    return getFalse(ITy);

  case CmpInst::ICMP_ULE: // X <=u  1 -> true
  case CmpInst::ICMP_SGE: // X >=s -1 -> true
    return getTrue(ITy);

  default:
    break;
  }
}

switch (Pred) {
default:
  break;
case ICmpInst::ICMP_UGE:
  if (isImpliedCondition(RHS, LHS, Q.DL).value_or(false))
    return getTrue(ITy);
  break;
case ICmpInst::ICMP_SGE:
  /// For signed comparison, the values for an i1 are 0 and -1
  /// respectively. This maps into a truth table of:
  /// LHS | RHS | LHS >=s RHS   | LHS implies RHS
  ///  0  |  0  |  1 (0 >= 0)   |  1
  ///  0  |  1  |  1 (0 >= -1)  |  1
  ///  1  |  0  |  0 (-1 >= 0)  |  0
  ///  1  |  1  |  1 (-1 >= -1) |  1
  if (isImpliedCondition(LHS, RHS, Q.DL).value_or(false))
    return getTrue(ITy);
  break;
case ICmpInst::ICMP_ULE:
  if (isImpliedCondition(LHS, RHS, Q.DL).value_or(false))
    return getTrue(ITy);
  break;
case ICmpInst::ICMP_SLE:
  /// SLE follows the same logic as SGE with the LHS and RHS swapped.
  if (isImpliedCondition(RHS, LHS, Q.DL).value_or(false))
    return getTrue(ITy);
  break;
}

return nullptr;
3001}

3003/// Try hard to fold icmp with zero RHS because this is a common case.
3004static Value *simplifyICmpWithZero(CmpInst::Predicate Pred, Value *LHS,
                                 Value *RHS, const SimplifyQuery &Q) {
if (!match(RHS, m_Zero()))
  return nullptr;

Type *ITy = getCompareTy(LHS); // The return type.
switch (Pred) {
default:
  llvm_unreachable("Unknown ICmp predicate!")::llvm::llvm_unreachable_internal("Unknown ICmp predicate!", "llvm/lib/Analysis/InstructionSimplify.cpp"
, 3012);
case ICmpInst::ICMP_ULT:
  return getFalse(ITy);
case ICmpInst::ICMP_UGE:
  return getTrue(ITy);
case ICmpInst::ICMP_EQ:
case ICmpInst::ICMP_ULE:
  if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT, Q.IIQ.UseInstrInfo))
    return getFalse(ITy);
  break;
case ICmpInst::ICMP_NE:
case ICmpInst::ICMP_UGT:
  if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT, Q.IIQ.UseInstrInfo))
    return getTrue(ITy);
  break;
case ICmpInst::ICMP_SLT: {
  KnownBits LHSKnown = computeKnownBits(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
  if (LHSKnown.isNegative())
    return getTrue(ITy);
  if (LHSKnown.isNonNegative())
    return getFalse(ITy);
  break;
}
case ICmpInst::ICMP_SLE: {
  KnownBits LHSKnown = computeKnownBits(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
  if (LHSKnown.isNegative())
    return getTrue(ITy);
  if (LHSKnown.isNonNegative() &&
      isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
    return getFalse(ITy);
  break;
}
case ICmpInst::ICMP_SGE: {
  KnownBits LHSKnown = computeKnownBits(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
  if (LHSKnown.isNegative())
    return getFalse(ITy);
  if (LHSKnown.isNonNegative())
    return getTrue(ITy);
  break;
}
case ICmpInst::ICMP_SGT: {
  KnownBits LHSKnown = computeKnownBits(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
  if (LHSKnown.isNegative())
    return getFalse(ITy);
  if (LHSKnown.isNonNegative() &&
      isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
    return getTrue(ITy);
  break;
}
}

return nullptr;
3064}

3066static Value *simplifyICmpWithConstant(CmpInst::Predicate Pred, Value *LHS,
                                     Value *RHS, const InstrInfoQuery &IIQ) {
Type *ITy = getCompareTy(RHS); // The return type.

Value *X;
// Sign-bit checks can be optimized to true/false after unsigned
// floating-point casts:
// icmp slt (bitcast (uitofp X)),  0 --> false
// icmp sgt (bitcast (uitofp X)), -1 --> true
if (match(LHS, m_BitCast(m_UIToFP(m_Value(X))))) {
  if (Pred == ICmpInst::ICMP_SLT && match(RHS, m_Zero()))
    return ConstantInt::getFalse(ITy);
  if (Pred == ICmpInst::ICMP_SGT && match(RHS, m_AllOnes()))
    return ConstantInt::getTrue(ITy);
}

const APInt *C;
if (!match(RHS, m_APIntAllowUndef(C)))
  return nullptr;

// Rule out tautological comparisons (eg., ult 0 or uge 0).
ConstantRange RHS_CR = ConstantRange::makeExactICmpRegion(Pred, *C);
if (RHS_CR.isEmptySet())
  return ConstantInt::getFalse(ITy);
if (RHS_CR.isFullSet())
  return ConstantInt::getTrue(ITy);

ConstantRange LHS_CR =
    computeConstantRange(LHS, CmpInst::isSigned(Pred), IIQ.UseInstrInfo);
if (!LHS_CR.isFullSet()) {
  if (RHS_CR.contains(LHS_CR))
    return ConstantInt::getTrue(ITy);
  if (RHS_CR.inverse().contains(LHS_CR))
    return ConstantInt::getFalse(ITy);
}

// (mul nuw/nsw X, MulC) != C --> true  (if C is not a multiple of MulC)
// (mul nuw/nsw X, MulC) == C --> false (if C is not a multiple of MulC)
const APInt *MulC;
if (ICmpInst::isEquality(Pred) &&
    ((match(LHS, m_NUWMul(m_Value(), m_APIntAllowUndef(MulC))) &&
      *MulC != 0 && C->urem(*MulC) != 0) ||
     (match(LHS, m_NSWMul(m_Value(), m_APIntAllowUndef(MulC))) &&
      *MulC != 0 && C->srem(*MulC) != 0)))
  return ConstantInt::get(ITy, Pred == ICmpInst::ICMP_NE);

return nullptr;
3113}

3115static Value *simplifyICmpWithBinOpOnLHS(CmpInst::Predicate Pred,
                                       BinaryOperator *LBO, Value *RHS,
                                       const SimplifyQuery &Q,
                                       unsigned MaxRecurse) {
Type *ITy = getCompareTy(RHS); // The return type.

Value *Y = nullptr;
// icmp pred (or X, Y), X
if (match(LBO, m_c_Or(m_Value(Y), m_Specific(RHS)))) {
  if (Pred == ICmpInst::ICMP_ULT)
    return getFalse(ITy);
  if (Pred == ICmpInst::ICMP_UGE)
    return getTrue(ITy);

  if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SGE) {
    KnownBits RHSKnown = computeKnownBits(RHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
    KnownBits YKnown = computeKnownBits(Y, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
    if (RHSKnown.isNonNegative() && YKnown.isNegative())
      return Pred == ICmpInst::ICMP_SLT ? getTrue(ITy) : getFalse(ITy);
    if (RHSKnown.isNegative() || YKnown.isNonNegative())
      return Pred == ICmpInst::ICMP_SLT ? getFalse(ITy) : getTrue(ITy);
  }
}

// icmp pred (and X, Y), X
if (match(LBO, m_c_And(m_Value(), m_Specific(RHS)))) {
  if (Pred == ICmpInst::ICMP_UGT)
    return getFalse(ITy);
  if (Pred == ICmpInst::ICMP_ULE)
    return getTrue(ITy);
}

// icmp pred (urem X, Y), Y
if (match(LBO, m_URem(m_Value(), m_Specific(RHS)))) {
  switch (Pred) {
  default:
    break;
  case ICmpInst::ICMP_SGT:
  case ICmpInst::ICMP_SGE: {
    KnownBits Known = computeKnownBits(RHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
    if (!Known.isNonNegative())
      break;
    [[fallthrough]];
  }
  case ICmpInst::ICMP_EQ:
  case ICmpInst::ICMP_UGT:
  case ICmpInst::ICMP_UGE:
    return getFalse(ITy);
  case ICmpInst::ICMP_SLT:
  case ICmpInst::ICMP_SLE: {
    KnownBits Known = computeKnownBits(RHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
    if (!Known.isNonNegative())
      break;
    [[fallthrough]];
  }
  case ICmpInst::ICMP_NE:
  case ICmpInst::ICMP_ULT:
  case ICmpInst::ICMP_ULE:
    return getTrue(ITy);
  }
}

// icmp pred (urem X, Y), X
if (match(LBO, m_URem(m_Specific(RHS), m_Value()))) {
  if (Pred == ICmpInst::ICMP_ULE)
    return getTrue(ITy);
  if (Pred == ICmpInst::ICMP_UGT)
    return getFalse(ITy);
}

// x >>u y <=u x --> true.
// x >>u y >u  x --> false.
// x udiv y <=u x --> true.
// x udiv y >u  x --> false.
if (match(LBO, m_LShr(m_Specific(RHS), m_Value())) ||
    match(LBO, m_UDiv(m_Specific(RHS), m_Value()))) {
  // icmp pred (X op Y), X
  if (Pred == ICmpInst::ICMP_UGT)
    return getFalse(ITy);
  if (Pred == ICmpInst::ICMP_ULE)
    return getTrue(ITy);
}

// If x is nonzero:
// x >>u C <u  x --> true  for C != 0.
// x >>u C !=  x --> true  for C != 0.
// x >>u C >=u x --> false for C != 0.
// x >>u C ==  x --> false for C != 0.
// x udiv C <u  x --> true  for C != 1.
// x udiv C !=  x --> true  for C != 1.
// x udiv C >=u x --> false for C != 1.
// x udiv C ==  x --> false for C != 1.
// TODO: allow non-constant shift amount/divisor
const APInt *C;
if ((match(LBO, m_LShr(m_Specific(RHS), m_APInt(C))) && *C != 0) ||
    (match(LBO, m_UDiv(m_Specific(RHS), m_APInt(C))) && *C != 1)) {
  if (isKnownNonZero(RHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT)) {
    switch (Pred) {
    default:
      break;
    case ICmpInst::ICMP_EQ:
    case ICmpInst::ICMP_UGE:
      return getFalse(ITy);
    case ICmpInst::ICMP_NE:
    case ICmpInst::ICMP_ULT:
      return getTrue(ITy);
    case ICmpInst::ICMP_UGT:
    case ICmpInst::ICMP_ULE:
      // UGT/ULE are handled by the more general case just above
      llvm_unreachable("Unexpected UGT/ULE, should have been handled")::llvm::llvm_unreachable_internal("Unexpected UGT/ULE, should have been handled"
, "llvm/lib/Analysis/InstructionSimplify.cpp", 3224);
    }
  }
}

// (x*C1)/C2 <= x for C1 <= C2.
// This holds even if the multiplication overflows: Assume that x != 0 and
// arithmetic is modulo M. For overflow to occur we must have C1 >= M/x and
// thus C2 >= M/x. It follows that (x*C1)/C2 <= (M-1)/C2 <= ((M-1)*x)/M < x.
//
// Additionally, either the multiplication and division might be represented
// as shifts:
// (x*C1)>>C2 <= x for C1 < 2**C2.
// (x<<C1)/C2 <= x for 2**C1 < C2.
const APInt *C1, *C2;
if ((match(LBO, m_UDiv(m_Mul(m_Specific(RHS), m_APInt(C1)), m_APInt(C2))) &&
     C1->ule(*C2)) ||
    (match(LBO, m_LShr(m_Mul(m_Specific(RHS), m_APInt(C1)), m_APInt(C2))) &&
     C1->ule(APInt(C2->getBitWidth(), 1) << *C2)) ||
    (match(LBO, m_UDiv(m_Shl(m_Specific(RHS), m_APInt(C1)), m_APInt(C2))) &&
     (APInt(C1->getBitWidth(), 1) << *C1).ule(*C2))) {
  if (Pred == ICmpInst::ICMP_UGT)
    return getFalse(ITy);
  if (Pred == ICmpInst::ICMP_ULE)
    return getTrue(ITy);
}

// (sub C, X) == X, C is odd  --> false
// (sub C, X) != X, C is odd  --> true
if (match(LBO, m_Sub(m_APIntAllowUndef(C), m_Specific(RHS))) &&
    (*C & 1) == 1 && ICmpInst::isEquality(Pred))
  return (Pred == ICmpInst::ICMP_EQ) ? getFalse(ITy) : getTrue(ITy);

return nullptr;
3258}

3260// If only one of the icmp's operands has NSW flags, try to prove that:
3261//
3262//   icmp slt (x + C1), (x +nsw C2)
3263//
3264// is equivalent to:
3265//
3266//   icmp slt C1, C2
3267//
3268// which is true if x + C2 has the NSW flags set and:
3269// *) C1 < C2 && C1 >= 0, or
3270// *) C2 < C1 && C1 <= 0.
3271//
3272static bool trySimplifyICmpWithAdds(CmpInst::Predicate Pred, Value *LHS,
                                  Value *RHS) {
// TODO: only support icmp slt for now.
if (Pred != CmpInst::ICMP_SLT)
  return false;

// Canonicalize nsw add as RHS.
if (!match(RHS, m_NSWAdd(m_Value(), m_Value())))
  std::swap(LHS, RHS);
if (!match(RHS, m_NSWAdd(m_Value(), m_Value())))
  return false;

Value *X;
const APInt *C1, *C2;
if (!match(LHS, m_c_Add(m_Value(X), m_APInt(C1))) ||
    !match(RHS, m_c_Add(m_Specific(X), m_APInt(C2))))
  return false;

return (C1->slt(*C2) && C1->isNonNegative()) ||
       (C2->slt(*C1) && C1->isNonPositive());
3292}

3294/// TODO: A large part of this logic is duplicated in InstCombine's
3295/// foldICmpBinOp(). We should be able to share that and avoid the code
3296/// duplication.
3297static Value *simplifyICmpWithBinOp(CmpInst::Predicate Pred, Value *LHS,
                                  Value *RHS, const SimplifyQuery &Q,
                                  unsigned MaxRecurse) {
BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS);
BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS);
if (MaxRecurse && (LBO || RBO)) {
  // Analyze the case when either LHS or RHS is an add instruction.
  Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr;
  // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null).
  bool NoLHSWrapProblem = false, NoRHSWrapProblem = false;
  if (LBO && LBO->getOpcode() == Instruction::Add) {
    A = LBO->getOperand(0);
    B = LBO->getOperand(1);
    NoLHSWrapProblem =
        ICmpInst::isEquality(Pred) ||
        (CmpInst::isUnsigned(Pred) &&
         Q.IIQ.hasNoUnsignedWrap(cast<OverflowingBinaryOperator>(LBO))) ||
        (CmpInst::isSigned(Pred) &&
         Q.IIQ.hasNoSignedWrap(cast<OverflowingBinaryOperator>(LBO)));
  }
  if (RBO && RBO->getOpcode() == Instruction::Add) {
    C = RBO->getOperand(0);
    D = RBO->getOperand(1);
    NoRHSWrapProblem =
        ICmpInst::isEquality(Pred) ||
        (CmpInst::isUnsigned(Pred) &&
         Q.IIQ.hasNoUnsignedWrap(cast<OverflowingBinaryOperator>(RBO))) ||
        (CmpInst::isSigned(Pred) &&
         Q.IIQ.hasNoSignedWrap(cast<OverflowingBinaryOperator>(RBO)));
  }

  // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow.
  if ((A == RHS || B == RHS) && NoLHSWrapProblem)
    if (Value *V = simplifyICmpInst(Pred, A == RHS ? B : A,
                                    Constant::getNullValue(RHS->getType()), Q,
                                    MaxRecurse - 1))
      return V;

  // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow.
  if ((C == LHS || D == LHS) && NoRHSWrapProblem)
    if (Value *V =
            simplifyICmpInst(Pred, Constant::getNullValue(LHS->getType()),
                             C == LHS ? D : C, Q, MaxRecurse - 1))
      return V;

  // icmp (X+Y), (X+Z) -> icmp Y,Z for equalities or if there is no overflow.
  bool CanSimplify = (NoLHSWrapProblem && NoRHSWrapProblem) ||
                     trySimplifyICmpWithAdds(Pred, LHS, RHS);
  if (A && C && (A == C || A == D || B == C || B == D) && CanSimplify) {
    // Determine Y and Z in the form icmp (X+Y), (X+Z).
    Value *Y, *Z;
    if (A == C) {
      // C + B == C + D  ->  B == D
      Y = B;
      Z = D;
    } else if (A == D) {
      // D + B == C + D  ->  B == C
      Y = B;
      Z = C;
    } else if (B == C) {
      // A + C == C + D  ->  A == D
      Y = A;
      Z = D;
    } else {
      assert(B == D)(static_cast <bool> (B == D) ? void (0) : __assert_fail
 ("B == D", "llvm/lib/Analysis/InstructionSimplify.cpp", 3361
, __extension__ __PRETTY_FUNCTION__));
      // A + D == C + D  ->  A == C
      Y = A;
      Z = C;
    }
    if (Value *V = simplifyICmpInst(Pred, Y, Z, Q, MaxRecurse - 1))
      return V;
  }
}

if (LBO)
  if (Value *V = simplifyICmpWithBinOpOnLHS(Pred, LBO, RHS, Q, MaxRecurse))
    return V;

if (RBO)
  if (Value *V = simplifyICmpWithBinOpOnLHS(
          ICmpInst::getSwappedPredicate(Pred), RBO, LHS, Q, MaxRecurse))
    return V;

// 0 - (zext X) pred C
if (!CmpInst::isUnsigned(Pred) && match(LHS, m_Neg(m_ZExt(m_Value())))) {
  const APInt *C;
  if (match(RHS, m_APInt(C))) {
    if (C->isStrictlyPositive()) {
      if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_NE)
        return ConstantInt::getTrue(getCompareTy(RHS));
      if (Pred == ICmpInst::ICMP_SGE || Pred == ICmpInst::ICMP_EQ)
        return ConstantInt::getFalse(getCompareTy(RHS));
    }
    if (C->isNonNegative()) {
      if (Pred == ICmpInst::ICMP_SLE)
        return ConstantInt::getTrue(getCompareTy(RHS));
      if (Pred == ICmpInst::ICMP_SGT)
        return ConstantInt::getFalse(getCompareTy(RHS));
    }
  }
}

//   If C2 is a power-of-2 and C is not:
//   (C2 << X) == C --> false
//   (C2 << X) != C --> true
const APInt *C;
if (match(LHS, m_Shl(m_Power2(), m_Value())) &&
    match(RHS, m_APIntAllowUndef(C)) && !C->isPowerOf2()) {
  // C2 << X can equal zero in some circumstances.
  // This simplification might be unsafe if C is zero.
  //
  // We know it is safe if:
  // - The shift is nsw. We can't shift out the one bit.
  // - The shift is nuw. We can't shift out the one bit.
  // - C2 is one.
  // - C isn't zero.
  if (Q.IIQ.hasNoSignedWrap(cast<OverflowingBinaryOperator>(LBO)) ||
      Q.IIQ.hasNoUnsignedWrap(cast<OverflowingBinaryOperator>(LBO)) ||
      match(LHS, m_Shl(m_One(), m_Value())) || !C->isZero()) {
    if (Pred == ICmpInst::ICMP_EQ)
      return ConstantInt::getFalse(getCompareTy(RHS));
    if (Pred == ICmpInst::ICMP_NE)
      return ConstantInt::getTrue(getCompareTy(RHS));
  }
}

// TODO: This is overly constrained. LHS can be any power-of-2.
// (1 << X)  >u 0x8000 --> false
// (1 << X) <=u 0x8000 --> true
if (match(LHS, m_Shl(m_One(), m_Value())) && match(RHS, m_SignMask())) {
  if (Pred == ICmpInst::ICMP_UGT)
    return ConstantInt::getFalse(getCompareTy(RHS));
  if (Pred == ICmpInst::ICMP_ULE)
    return ConstantInt::getTrue(getCompareTy(RHS));
}

if (!MaxRecurse || !LBO || !RBO || LBO->getOpcode() != RBO->getOpcode())
  return nullptr;

if (LBO->getOperand(0) == RBO->getOperand(0)) {
  switch (LBO->getOpcode()) {
  default:
    break;
  case Instruction::Shl:
    bool NUW = Q.IIQ.hasNoUnsignedWrap(LBO) && Q.IIQ.hasNoUnsignedWrap(RBO);
    bool NSW = Q.IIQ.hasNoSignedWrap(LBO) && Q.IIQ.hasNoSignedWrap(RBO);
    if (!NUW || (ICmpInst::isSigned(Pred) && !NSW) ||
        !isKnownNonZero(LBO->getOperand(0), Q.DL))
      break;
    if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(1),
                                    RBO->getOperand(1), Q, MaxRecurse - 1))
      return V;
  }
}

if (LBO->getOperand(1) == RBO->getOperand(1)) {
  switch (LBO->getOpcode()) {
  default:
    break;
  case Instruction::UDiv:
  case Instruction::LShr:
    if (ICmpInst::isSigned(Pred) || !Q.IIQ.isExact(LBO) ||
        !Q.IIQ.isExact(RBO))
      break;
    if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(0),
                                    RBO->getOperand(0), Q, MaxRecurse - 1))
      return V;
    break;
  case Instruction::SDiv:
    if (!ICmpInst::isEquality(Pred) || !Q.IIQ.isExact(LBO) ||
        !Q.IIQ.isExact(RBO))
      break;
    if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(0),
                                    RBO->getOperand(0), Q, MaxRecurse - 1))
      return V;
    break;
  case Instruction::AShr:
    if (!Q.IIQ.isExact(LBO) || !Q.IIQ.isExact(RBO))
      break;
    if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(0),
                                    RBO->getOperand(0), Q, MaxRecurse - 1))
      return V;
    break;
  case Instruction::Shl: {
    bool NUW = Q.IIQ.hasNoUnsignedWrap(LBO) && Q.IIQ.hasNoUnsignedWrap(RBO);
    bool NSW = Q.IIQ.hasNoSignedWrap(LBO) && Q.IIQ.hasNoSignedWrap(RBO);
    if (!NUW && !NSW)
      break;
    if (!NSW && ICmpInst::isSigned(Pred))
      break;
    if (Value *V = simplifyICmpInst(Pred, LBO->getOperand(0),
                                    RBO->getOperand(0), Q, MaxRecurse - 1))
      return V;
    break;
  }
  }
}
return nullptr;
3495}

3497/// simplify integer comparisons where at least one operand of the compare
3498/// matches an integer min/max idiom.
3499static Value *simplifyICmpWithMinMax(CmpInst::Predicate Pred, Value *LHS,
                                   Value *RHS, const SimplifyQuery &Q,
                                   unsigned MaxRecurse) {
Type *ITy = getCompareTy(LHS); // The return type.
Value *A, *B;
CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE;
CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B".

// Signed variants on "max(a,b)>=a -> true".
if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) {
  if (A != RHS)
    std::swap(A, B);       // smax(A, B) pred A.
  EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B".
  // We analyze this as smax(A, B) pred A.
  P = Pred;
} else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) &&
           (A == LHS || B == LHS)) {
  if (A != LHS)
    std::swap(A, B);       // A pred smax(A, B).
  EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B".
  // We analyze this as smax(A, B) swapped-pred A.
  P = CmpInst::getSwappedPredicate(Pred);
} else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) &&
           (A == RHS || B == RHS)) {
  if (A != RHS)
    std::swap(A, B);       // smin(A, B) pred A.
  EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B".
  // We analyze this as smax(-A, -B) swapped-pred -A.
  // Note that we do not need to actually form -A or -B thanks to EqP.
  P = CmpInst::getSwappedPredicate(Pred);
} else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) &&
           (A == LHS || B == LHS)) {
  if (A != LHS)
    std::swap(A, B);       // A pred smin(A, B).
  EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B".
  // We analyze this as smax(-A, -B) pred -A.
  // Note that we do not need to actually form -A or -B thanks to EqP.
  P = Pred;
}
if (P != CmpInst::BAD_ICMP_PREDICATE) {
  // Cases correspond to "max(A, B) p A".
  switch (P) {
  default:
    break;
  case CmpInst::ICMP_EQ:
  case CmpInst::ICMP_SLE:
    // Equivalent to "A EqP B".  This may be the same as the condition tested
    // in the max/min; if so, we can just return that.
    if (Value *V = extractEquivalentCondition(LHS, EqP, A, B))
      return V;
    if (Value *V = extractEquivalentCondition(RHS, EqP, A, B))
      return V;
    // Otherwise, see if "A EqP B" simplifies.
    if (MaxRecurse)
      if (Value *V = simplifyICmpInst(EqP, A, B, Q, MaxRecurse - 1))
        return V;
    break;
  case CmpInst::ICMP_NE:
  case CmpInst::ICMP_SGT: {
    CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP);
    // Equivalent to "A InvEqP B".  This may be the same as the condition
    // tested in the max/min; if so, we can just return that.
    if (Value *V = extractEquivalentCondition(LHS, InvEqP, A, B))
      return V;
    if (Value *V = extractEquivalentCondition(RHS, InvEqP, A, B))
      return V;
    // Otherwise, see if "A InvEqP B" simplifies.
    if (MaxRecurse)
      if (Value *V = simplifyICmpInst(InvEqP, A, B, Q, MaxRecurse - 1))
        return V;
    break;
  }
  case CmpInst::ICMP_SGE:
    // Always true.
    return getTrue(ITy);
  case CmpInst::ICMP_SLT:
    // Always false.
    return getFalse(ITy);
  }
}

// Unsigned variants on "max(a,b)>=a -> true".
P = CmpInst::BAD_ICMP_PREDICATE;
if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) {
  if (A != RHS)
    std::swap(A, B);       // umax(A, B) pred A.
  EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B".
  // We analyze this as umax(A, B) pred A.
  P = Pred;
} else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) &&
           (A == LHS || B == LHS)) {
  if (A != LHS)
    std::swap(A, B);       // A pred umax(A, B).
  EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B".
  // We analyze this as umax(A, B) swapped-pred A.
  P = CmpInst::getSwappedPredicate(Pred);
} else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) &&
           (A == RHS || B == RHS)) {
  if (A != RHS)
    std::swap(A, B);       // umin(A, B) pred A.
  EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B".
  // We analyze this as umax(-A, -B) swapped-pred -A.
  // Note that we do not need to actually form -A or -B thanks to EqP.
  P = CmpInst::getSwappedPredicate(Pred);
} else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) &&
           (A == LHS || B == LHS)) {
  if (A != LHS)
    std::swap(A, B);       // A pred umin(A, B).
  EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B".
  // We analyze this as umax(-A, -B) pred -A.
  // Note that we do not need to actually form -A or -B thanks to EqP.
  P = Pred;
}
if (P != CmpInst::BAD_ICMP_PREDICATE) {
  // Cases correspond to "max(A, B) p A".
  switch (P) {
  default:
    break;
  case CmpInst::ICMP_EQ:
  case CmpInst::ICMP_ULE:
    // Equivalent to "A EqP B".  This may be the same as the condition tested
    // in the max/min; if so, we can just return that.
    if (Value *V = extractEquivalentCondition(LHS, EqP, A, B))
      return V;
    if (Value *V = extractEquivalentCondition(RHS, EqP, A, B))
      return V;
    // Otherwise, see if "A EqP B" simplifies.
    if (MaxRecurse)
      if (Value *V = simplifyICmpInst(EqP, A, B, Q, MaxRecurse - 1))
        return V;
    break;
  case CmpInst::ICMP_NE:
  case CmpInst::ICMP_UGT: {
    CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP);
    // Equivalent to "A InvEqP B".  This may be the same as the condition
    // tested in the max/min; if so, we can just return that.
    if (Value *V = extractEquivalentCondition(LHS, InvEqP, A, B))
      return V;
    if (Value *V = extractEquivalentCondition(RHS, InvEqP, A, B))
      return V;
    // Otherwise, see if "A InvEqP B" simplifies.
    if (MaxRecurse)
      if (Value *V = simplifyICmpInst(InvEqP, A, B, Q, MaxRecurse - 1))
        return V;
    break;
  }
  case CmpInst::ICMP_UGE:
    return getTrue(ITy);
  case CmpInst::ICMP_ULT:
    return getFalse(ITy);
  }
}

// Comparing 1 each of min/max with a common operand?
// Canonicalize min operand to RHS.
if (match(LHS, m_UMin(m_Value(), m_Value())) ||
    match(LHS, m_SMin(m_Value(), m_Value()))) {
  std::swap(LHS, RHS);
  Pred = ICmpInst::getSwappedPredicate(Pred);
}

Value *C, *D;
if (match(LHS, m_SMax(m_Value(A), m_Value(B))) &&
    match(RHS, m_SMin(m_Value(C), m_Value(D))) &&
    (A == C || A == D || B == C || B == D)) {
  // smax(A, B) >=s smin(A, D) --> true
  if (Pred == CmpInst::ICMP_SGE)
    return getTrue(ITy);
  // smax(A, B) <s smin(A, D) --> false
  if (Pred == CmpInst::ICMP_SLT)
    return getFalse(ITy);
} else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) &&
           match(RHS, m_UMin(m_Value(C), m_Value(D))) &&
           (A == C || A == D || B == C || B == D)) {
  // umax(A, B) >=u umin(A, D) --> true
  if (Pred == CmpInst::ICMP_UGE)
    return getTrue(ITy);
  // umax(A, B) <u umin(A, D) --> false
  if (Pred == CmpInst::ICMP_ULT)
    return getFalse(ITy);
}

return nullptr;
3682}

3684static Value *simplifyICmpWithDominatingAssume(CmpInst::Predicate Predicate,
                                             Value *LHS, Value *RHS,
                                             const SimplifyQuery &Q) {
// Gracefully handle instructions that have not been inserted yet.
if (!Q.AC || !Q.CxtI || !Q.CxtI->getParent())
  return nullptr;

for (Value *AssumeBaseOp : {LHS, RHS}) {
  for (auto &AssumeVH : Q.AC->assumptionsFor(AssumeBaseOp)) {
    if (!AssumeVH)
      continue;

    CallInst *Assume = cast<CallInst>(AssumeVH);
    if (std::optional<bool> Imp = isImpliedCondition(
            Assume->getArgOperand(0), Predicate, LHS, RHS, Q.DL))
      if (isValidAssumeForContext(Assume, Q.CxtI, Q.DT))
        return ConstantInt::get(getCompareTy(LHS), *Imp);
  }
}

return nullptr;
3705}

3707/// Given operands for an ICmpInst, see if we can fold the result.
3708/// If not, this returns null.
3709static Value *simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                             const SimplifyQuery &Q, unsigned MaxRecurse) {
CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate;
assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!")(static_cast <bool> (CmpInst::isIntPredicate(Pred) &&
 "Not an integer compare!") ? void (0) : __assert_fail ("CmpInst::isIntPredicate(Pred) && \"Not an integer compare!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 3712, __extension__
 __PRETTY_FUNCTION__));

if (Constant *CLHS = dyn_cast<Constant>(LHS)) {
  if (Constant *CRHS = dyn_cast<Constant>(RHS))
    return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI);

  // If we have a constant, make sure it is on the RHS.
  std::swap(LHS, RHS);
  Pred = CmpInst::getSwappedPredicate(Pred);
}
assert(!isa<UndefValue>(LHS) && "Unexpected icmp undef,%X")(static_cast <bool> (!isa<UndefValue>(LHS) &&
 "Unexpected icmp undef,%X") ? void (0) : __assert_fail ("!isa<UndefValue>(LHS) && \"Unexpected icmp undef,%X\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 3722, __extension__
 __PRETTY_FUNCTION__));

Type *ITy = getCompareTy(LHS); // The return type.

// icmp poison, X -> poison
if (isa<PoisonValue>(RHS))
  return PoisonValue::get(ITy);

// For EQ and NE, we can always pick a value for the undef to make the
// predicate pass or fail, so we can return undef.
// Matches behavior in llvm::ConstantFoldCompareInstruction.
if (Q.isUndefValue(RHS) && ICmpInst::isEquality(Pred))
  return UndefValue::get(ITy);

// icmp X, X -> true/false
// icmp X, undef -> true/false because undef could be X.
if (LHS == RHS || Q.isUndefValue(RHS))
  return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred));

if (Value *V = simplifyICmpOfBools(Pred, LHS, RHS, Q))
  return V;

// TODO: Sink/common this with other potentially expensive calls that use
//       ValueTracking? See comment below for isKnownNonEqual().
if (Value *V = simplifyICmpWithZero(Pred, LHS, RHS, Q))
  return V;

if (Value *V = simplifyICmpWithConstant(Pred, LHS, RHS, Q.IIQ))
  return V;

// If both operands have range metadata, use the metadata
// to simplify the comparison.
if (isa<Instruction>(RHS) && isa<Instruction>(LHS)) {
  auto RHS_Instr = cast<Instruction>(RHS);
  auto LHS_Instr = cast<Instruction>(LHS);

  if (Q.IIQ.getMetadata(RHS_Instr, LLVMContext::MD_range) &&
      Q.IIQ.getMetadata(LHS_Instr, LLVMContext::MD_range)) {
    auto RHS_CR = getConstantRangeFromMetadata(
        *RHS_Instr->getMetadata(LLVMContext::MD_range));
    auto LHS_CR = getConstantRangeFromMetadata(
        *LHS_Instr->getMetadata(LLVMContext::MD_range));

    if (LHS_CR.icmp(Pred, RHS_CR))
      return ConstantInt::getTrue(RHS->getContext());

    if (LHS_CR.icmp(CmpInst::getInversePredicate(Pred), RHS_CR))
      return ConstantInt::getFalse(RHS->getContext());
  }
}

// Compare of cast, for example (zext X) != 0 -> X != 0
if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) {
  Instruction *LI = cast<CastInst>(LHS);
  Value *SrcOp = LI->getOperand(0);
  Type *SrcTy = SrcOp->getType();
  Type *DstTy = LI->getType();

  // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input
  // if the integer type is the same size as the pointer type.
  if (MaxRecurse && isa<PtrToIntInst>(LI) &&
      Q.DL.getTypeSizeInBits(SrcTy) == DstTy->getPrimitiveSizeInBits()) {
    if (Constant *RHSC = dyn_cast<Constant>(RHS)) {
      // Transfer the cast to the constant.
      if (Value *V = simplifyICmpInst(Pred, SrcOp,
                                      ConstantExpr::getIntToPtr(RHSC, SrcTy),
                                      Q, MaxRecurse - 1))
        return V;
    } else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) {
      if (RI->getOperand(0)->getType() == SrcTy)
        // Compare without the cast.
        if (Value *V = simplifyICmpInst(Pred, SrcOp, RI->getOperand(0), Q,
                                        MaxRecurse - 1))
          return V;
    }
  }

  if (isa<ZExtInst>(LHS)) {
    // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the
    // same type.
    if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) {
      if (MaxRecurse && SrcTy == RI->getOperand(0)->getType())
        // Compare X and Y.  Note that signed predicates become unsigned.
        if (Value *V =
                simplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), SrcOp,
                                 RI->getOperand(0), Q, MaxRecurse - 1))
          return V;
    }
    // Fold (zext X) ule (sext X), (zext X) sge (sext X) to true.
    else if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) {
      if (SrcOp == RI->getOperand(0)) {
        if (Pred == ICmpInst::ICMP_ULE || Pred == ICmpInst::ICMP_SGE)
          return ConstantInt::getTrue(ITy);
        if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_SLT)
          return ConstantInt::getFalse(ITy);
      }
    }
    // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended
    // too.  If not, then try to deduce the result of the comparison.
    else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
      // Compute the constant that would happen if we truncated to SrcTy then
      // reextended to DstTy.
      Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy);
      Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy);

      // If the re-extended constant didn't change then this is effectively
      // also a case of comparing two zero-extended values.
      if (RExt == CI && MaxRecurse)
        if (Value *V = simplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred),
                                        SrcOp, Trunc, Q, MaxRecurse - 1))
          return V;

      // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit
      // there.  Use this to work out the result of the comparison.
      if (RExt != CI) {
        switch (Pred) {
        default:
          llvm_unreachable("Unknown ICmp predicate!")::llvm::llvm_unreachable_internal("Unknown ICmp predicate!", "llvm/lib/Analysis/InstructionSimplify.cpp"
, 3839);
        // LHS <u RHS.
        case ICmpInst::ICMP_EQ:
        case ICmpInst::ICMP_UGT:
        case ICmpInst::ICMP_UGE:
          return ConstantInt::getFalse(CI->getContext());

        case ICmpInst::ICMP_NE:
        case ICmpInst::ICMP_ULT:
        case ICmpInst::ICMP_ULE:
          return ConstantInt::getTrue(CI->getContext());

        // LHS is non-negative.  If RHS is negative then LHS >s LHS.  If RHS
        // is non-negative then LHS <s RHS.
        case ICmpInst::ICMP_SGT:
        case ICmpInst::ICMP_SGE:
          return CI->getValue().isNegative()
                     ? ConstantInt::getTrue(CI->getContext())
                     : ConstantInt::getFalse(CI->getContext());

        case ICmpInst::ICMP_SLT:
        case ICmpInst::ICMP_SLE:
          return CI->getValue().isNegative()
                     ? ConstantInt::getFalse(CI->getContext())
                     : ConstantInt::getTrue(CI->getContext());
        }
      }
    }
  }

  if (isa<SExtInst>(LHS)) {
    // Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the
    // same type.
    if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) {
      if (MaxRecurse && SrcTy == RI->getOperand(0)->getType())
        // Compare X and Y.  Note that the predicate does not change.
        if (Value *V = simplifyICmpInst(Pred, SrcOp, RI->getOperand(0), Q,
                                        MaxRecurse - 1))
          return V;
    }
    // Fold (sext X) uge (zext X), (sext X) sle (zext X) to true.
    else if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) {
      if (SrcOp == RI->getOperand(0)) {
        if (Pred == ICmpInst::ICMP_UGE || Pred == ICmpInst::ICMP_SLE)
          return ConstantInt::getTrue(ITy);
        if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_SGT)
          return ConstantInt::getFalse(ITy);
      }
    }
    // Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended
    // too.  If not, then try to deduce the result of the comparison.
    else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
      // Compute the constant that would happen if we truncated to SrcTy then
      // reextended to DstTy.
      Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy);
      Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy);

      // If the re-extended constant didn't change then this is effectively
      // also a case of comparing two sign-extended values.
      if (RExt == CI && MaxRecurse)
        if (Value *V =
                simplifyICmpInst(Pred, SrcOp, Trunc, Q, MaxRecurse - 1))
          return V;

      // Otherwise the upper bits of LHS are all equal, while RHS has varying
      // bits there.  Use this to work out the result of the comparison.
      if (RExt != CI) {
        switch (Pred) {
        default:
          llvm_unreachable("Unknown ICmp predicate!")::llvm::llvm_unreachable_internal("Unknown ICmp predicate!", "llvm/lib/Analysis/InstructionSimplify.cpp"
, 3908);
        case ICmpInst::ICMP_EQ:
          return ConstantInt::getFalse(CI->getContext());
        case ICmpInst::ICMP_NE:
          return ConstantInt::getTrue(CI->getContext());

        // If RHS is non-negative then LHS <s RHS.  If RHS is negative then
        // LHS >s RHS.
        case ICmpInst::ICMP_SGT:
        case ICmpInst::ICMP_SGE:
          return CI->getValue().isNegative()
                     ? ConstantInt::getTrue(CI->getContext())
                     : ConstantInt::getFalse(CI->getContext());
        case ICmpInst::ICMP_SLT:
        case ICmpInst::ICMP_SLE:
          return CI->getValue().isNegative()
                     ? ConstantInt::getFalse(CI->getContext())
                     : ConstantInt::getTrue(CI->getContext());

        // If LHS is non-negative then LHS <u RHS.  If LHS is negative then
        // LHS >u RHS.
        case ICmpInst::ICMP_UGT:
        case ICmpInst::ICMP_UGE:
          // Comparison is true iff the LHS <s 0.
          if (MaxRecurse)
            if (Value *V = simplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp,
                                            Constant::getNullValue(SrcTy), Q,
                                            MaxRecurse - 1))
              return V;
          break;
        case ICmpInst::ICMP_ULT:
        case ICmpInst::ICMP_ULE:
          // Comparison is true iff the LHS >=s 0.
          if (MaxRecurse)
            if (Value *V = simplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp,
                                            Constant::getNullValue(SrcTy), Q,
                                            MaxRecurse - 1))
              return V;
          break;
        }
      }
    }
  }
}

// icmp eq|ne X, Y -> false|true if X != Y
// This is potentially expensive, and we have already computedKnownBits for
// compares with 0 above here, so only try this for a non-zero compare.
if (ICmpInst::isEquality(Pred) && !match(RHS, m_Zero()) &&
    isKnownNonEqual(LHS, RHS, Q.DL, Q.AC, Q.CxtI, Q.DT, Q.IIQ.UseInstrInfo)) {
  return Pred == ICmpInst::ICMP_NE ? getTrue(ITy) : getFalse(ITy);
}

if (Value *V = simplifyICmpWithBinOp(Pred, LHS, RHS, Q, MaxRecurse))
  return V;

if (Value *V = simplifyICmpWithMinMax(Pred, LHS, RHS, Q, MaxRecurse))
  return V;

if (Value *V = simplifyICmpWithDominatingAssume(Pred, LHS, RHS, Q))
  return V;

if (std::optional<bool> Res =
        isImpliedByDomCondition(Pred, LHS, RHS, Q.CxtI, Q.DL))
  return ConstantInt::getBool(ITy, *Res);

// Simplify comparisons of related pointers using a powerful, recursive
// GEP-walk when we have target data available..
if (LHS->getType()->isPointerTy())
  if (auto *C = computePointerICmp(Pred, LHS, RHS, Q))
    return C;
if (auto *CLHS = dyn_cast<PtrToIntOperator>(LHS))
  if (auto *CRHS = dyn_cast<PtrToIntOperator>(RHS))
    if (Q.DL.getTypeSizeInBits(CLHS->getPointerOperandType()) ==
            Q.DL.getTypeSizeInBits(CLHS->getType()) &&
        Q.DL.getTypeSizeInBits(CRHS->getPointerOperandType()) ==
            Q.DL.getTypeSizeInBits(CRHS->getType()))
      if (auto *C = computePointerICmp(Pred, CLHS->getPointerOperand(),
                                       CRHS->getPointerOperand(), Q))
        return C;

// If the comparison is with the result of a select instruction, check whether
// comparing with either branch of the select always yields the same value.
if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
  if (Value *V = threadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse))
    return V;

// If the comparison is with the result of a phi instruction, check whether
// doing the compare with each incoming phi value yields a common result.
if (isa<PHINode>(LHS) || isa<PHINode>(RHS))
  if (Value *V = threadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse))
    return V;

return nullptr;
4002}

4004Value *llvm::simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                            const SimplifyQuery &Q) {
return ::simplifyICmpInst(Predicate, LHS, RHS, Q, RecursionLimit);
4007}

4009/// Given operands for an FCmpInst, see if we can fold the result.
4010/// If not, this returns null.
4011static Value *simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                             FastMathFlags FMF, const SimplifyQuery &Q,
                             unsigned MaxRecurse) {
CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate;
assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!")(static_cast <bool> (CmpInst::isFPPredicate(Pred) &&
 "Not an FP compare!") ? void (0) : __assert_fail ("CmpInst::isFPPredicate(Pred) && \"Not an FP compare!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4015, __extension__
 __PRETTY_FUNCTION__));

if (Constant *CLHS = dyn_cast<Constant>(LHS)) {
  if (Constant *CRHS = dyn_cast<Constant>(RHS))
    return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI,
                                           Q.CxtI);

  // If we have a constant, make sure it is on the RHS.
  std::swap(LHS, RHS);
  Pred = CmpInst::getSwappedPredicate(Pred);
}

// Fold trivial predicates.
Type *RetTy = getCompareTy(LHS);
if (Pred == FCmpInst::FCMP_FALSE)
  return getFalse(RetTy);
if (Pred == FCmpInst::FCMP_TRUE)
  return getTrue(RetTy);

// Fold (un)ordered comparison if we can determine there are no NaNs.
if (Pred == FCmpInst::FCMP_UNO || Pred == FCmpInst::FCMP_ORD)
  if (FMF.noNaNs() ||
      (isKnownNeverNaN(LHS, Q.TLI) && isKnownNeverNaN(RHS, Q.TLI)))
    return ConstantInt::get(RetTy, Pred == FCmpInst::FCMP_ORD);

// NaN is unordered; NaN is not ordered.
assert((FCmpInst::isOrdered(Pred) || FCmpInst::isUnordered(Pred)) &&(static_cast <bool> ((FCmpInst::isOrdered(Pred) || FCmpInst
::isUnordered(Pred)) && "Comparison must be either ordered or unordered"
) ? void (0) : __assert_fail ("(FCmpInst::isOrdered(Pred) || FCmpInst::isUnordered(Pred)) && \"Comparison must be either ordered or unordered\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4042, __extension__
 __PRETTY_FUNCTION__))
       "Comparison must be either ordered or unordered")(static_cast <bool> ((FCmpInst::isOrdered(Pred) || FCmpInst
::isUnordered(Pred)) && "Comparison must be either ordered or unordered"
) ? void (0) : __assert_fail ("(FCmpInst::isOrdered(Pred) || FCmpInst::isUnordered(Pred)) && \"Comparison must be either ordered or unordered\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4042, __extension__
 __PRETTY_FUNCTION__));
if (match(RHS, m_NaN()))
  return ConstantInt::get(RetTy, CmpInst::isUnordered(Pred));

// fcmp pred x, poison and  fcmp pred poison, x
// fold to poison
if (isa<PoisonValue>(LHS) || isa<PoisonValue>(RHS))
  return PoisonValue::get(RetTy);

// fcmp pred x, undef  and  fcmp pred undef, x
// fold to true if unordered, false if ordered
if (Q.isUndefValue(LHS) || Q.isUndefValue(RHS)) {
  // Choosing NaN for the undef will always make unordered comparison succeed
  // and ordered comparison fail.
  return ConstantInt::get(RetTy, CmpInst::isUnordered(Pred));
}

// fcmp x,x -> true/false.  Not all compares are foldable.
if (LHS == RHS) {
  if (CmpInst::isTrueWhenEqual(Pred))
    return getTrue(RetTy);
  if (CmpInst::isFalseWhenEqual(Pred))
    return getFalse(RetTy);
}

// Handle fcmp with constant RHS.
// TODO: Use match with a specific FP value, so these work with vectors with
// undef lanes.
const APFloat *C;
if (match(RHS, m_APFloat(C))) {
  // Check whether the constant is an infinity.
  if (C->isInfinity()) {
    if (C->isNegative()) {
      switch (Pred) {
      case FCmpInst::FCMP_OLT:
        // No value is ordered and less than negative infinity.
        return getFalse(RetTy);
      case FCmpInst::FCMP_UGE:
        // All values are unordered with or at least negative infinity.
        return getTrue(RetTy);
      default:
        break;
      }
    } else {
      switch (Pred) {
      case FCmpInst::FCMP_OGT:
        // No value is ordered and greater than infinity.
        return getFalse(RetTy);
      case FCmpInst::FCMP_ULE:
        // All values are unordered with and at most infinity.
        return getTrue(RetTy);
      default:
        break;
      }
    }

    // LHS == Inf
    if (Pred == FCmpInst::FCMP_OEQ && isKnownNeverInfinity(LHS, Q.TLI))
      return getFalse(RetTy);
    // LHS != Inf
    if (Pred == FCmpInst::FCMP_UNE && isKnownNeverInfinity(LHS, Q.TLI))
      return getTrue(RetTy);
    // LHS == Inf || LHS == NaN
    if (Pred == FCmpInst::FCMP_UEQ && isKnownNeverInfinity(LHS, Q.TLI) &&
        isKnownNeverNaN(LHS, Q.TLI))
      return getFalse(RetTy);
    // LHS != Inf && LHS != NaN
    if (Pred == FCmpInst::FCMP_ONE && isKnownNeverInfinity(LHS, Q.TLI) &&
        isKnownNeverNaN(LHS, Q.TLI))
      return getTrue(RetTy);
  }
  if (C->isNegative() && !C->isNegZero()) {
    assert(!C->isNaN() && "Unexpected NaN constant!")(static_cast <bool> (!C->isNaN() && "Unexpected NaN constant!"
) ? void (0) : __assert_fail ("!C->isNaN() && \"Unexpected NaN constant!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4114, __extension__
 __PRETTY_FUNCTION__));
    // TODO: We can catch more cases by using a range check rather than
    //       relying on CannotBeOrderedLessThanZero.
    switch (Pred) {
    case FCmpInst::FCMP_UGE:
    case FCmpInst::FCMP_UGT:
    case FCmpInst::FCMP_UNE:
      // (X >= 0) implies (X > C) when (C < 0)
      if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
        return getTrue(RetTy);
      break;
    case FCmpInst::FCMP_OEQ:
    case FCmpInst::FCMP_OLE:
    case FCmpInst::FCMP_OLT:
      // (X >= 0) implies !(X < C) when (C < 0)
      if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
        return getFalse(RetTy);
      break;
    default:
      break;
    }
  }

  // Check comparison of [minnum/maxnum with constant] with other constant.
  const APFloat *C2;
  if ((match(LHS, m_Intrinsic<Intrinsic::minnum>(m_Value(), m_APFloat(C2))) &&
       *C2 < *C) ||
      (match(LHS, m_Intrinsic<Intrinsic::maxnum>(m_Value(), m_APFloat(C2))) &&
       *C2 > *C)) {
    bool IsMaxNum =
        cast<IntrinsicInst>(LHS)->getIntrinsicID() == Intrinsic::maxnum;
    // The ordered relationship and minnum/maxnum guarantee that we do not
    // have NaN constants, so ordered/unordered preds are handled the same.
    switch (Pred) {
    case FCmpInst::FCMP_OEQ:
    case FCmpInst::FCMP_UEQ:
      // minnum(X, LesserC)  == C --> false
      // maxnum(X, GreaterC) == C --> false
      return getFalse(RetTy);
    case FCmpInst::FCMP_ONE:
    case FCmpInst::FCMP_UNE:
      // minnum(X, LesserC)  != C --> true
      // maxnum(X, GreaterC) != C --> true
      return getTrue(RetTy);
    case FCmpInst::FCMP_OGE:
    case FCmpInst::FCMP_UGE:
    case FCmpInst::FCMP_OGT:
    case FCmpInst::FCMP_UGT:
      // minnum(X, LesserC)  >= C --> false
      // minnum(X, LesserC)  >  C --> false
      // maxnum(X, GreaterC) >= C --> true
      // maxnum(X, GreaterC) >  C --> true
      return ConstantInt::get(RetTy, IsMaxNum);
    case FCmpInst::FCMP_OLE:
    case FCmpInst::FCMP_ULE:
    case FCmpInst::FCMP_OLT:
    case FCmpInst::FCMP_ULT:
      // minnum(X, LesserC)  <= C --> true
      // minnum(X, LesserC)  <  C --> true
      // maxnum(X, GreaterC) <= C --> false
      // maxnum(X, GreaterC) <  C --> false
      return ConstantInt::get(RetTy, !IsMaxNum);
    default:
      // TRUE/FALSE/ORD/UNO should be handled before this.
      llvm_unreachable("Unexpected fcmp predicate")::llvm::llvm_unreachable_internal("Unexpected fcmp predicate"
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4178);
    }
  }
}

if (match(RHS, m_AnyZeroFP())) {
  switch (Pred) {
  case FCmpInst::FCMP_OGE:
  case FCmpInst::FCMP_ULT:
    // Positive or zero X >= 0.0 --> true
    // Positive or zero X <  0.0 --> false
    if ((FMF.noNaNs() || isKnownNeverNaN(LHS, Q.TLI)) &&
        CannotBeOrderedLessThanZero(LHS, Q.TLI))
      return Pred == FCmpInst::FCMP_OGE ? getTrue(RetTy) : getFalse(RetTy);
    break;
  case FCmpInst::FCMP_UGE:
  case FCmpInst::FCMP_OLT:
    // Positive or zero or nan X >= 0.0 --> true
    // Positive or zero or nan X <  0.0 --> false
    if (CannotBeOrderedLessThanZero(LHS, Q.TLI))
      return Pred == FCmpInst::FCMP_UGE ? getTrue(RetTy) : getFalse(RetTy);
    break;
  default:
    break;
  }
}

// If the comparison is with the result of a select instruction, check whether
// comparing with either branch of the select always yields the same value.
if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
  if (Value *V = threadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse))
    return V;

// If the comparison is with the result of a phi instruction, check whether
// doing the compare with each incoming phi value yields a common result.
if (isa<PHINode>(LHS) || isa<PHINode>(RHS))
  if (Value *V = threadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse))
    return V;

return nullptr;
4218}

4220Value *llvm::simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                            FastMathFlags FMF, const SimplifyQuery &Q) {
return ::simplifyFCmpInst(Predicate, LHS, RHS, FMF, Q, RecursionLimit);
4223}

4225static Value *simplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
                                   const SimplifyQuery &Q,
                                   bool AllowRefinement,
                                   unsigned MaxRecurse) {
// Trivial replacement.
if (V == Op)
  return RepOp;

// We cannot replace a constant, and shouldn't even try.
if (isa<Constant>(Op))
  return nullptr;

auto *I = dyn_cast<Instruction>(V);
if (!I || !is_contained(I->operands(), Op))
  return nullptr;

if (Op->getType()->isVectorTy()) {
  // For vector types, the simplification must hold per-lane, so forbid
  // potentially cross-lane operations like shufflevector.
  assert(I->getType()->isVectorTy() && "Vector type mismatch")(static_cast <bool> (I->getType()->isVectorTy() &&
 "Vector type mismatch") ? void (0) : __assert_fail ("I->getType()->isVectorTy() && \"Vector type mismatch\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4244, __extension__
 __PRETTY_FUNCTION__));
  if (isa<ShuffleVectorInst>(I) || isa<CallBase>(I))
    return nullptr;
}

// Replace Op with RepOp in instruction operands.
SmallVector<Value *, 8> NewOps(I->getNumOperands());
transform(I->operands(), NewOps.begin(),
          [&](Value *V) { return V == Op ? RepOp : V; });

if (!AllowRefinement) {
  // General InstSimplify functions may refine the result, e.g. by returning
  // a constant for a potentially poison value. To avoid this, implement only
  // a few non-refining but profitable transforms here.

  if (auto *BO = dyn_cast<BinaryOperator>(I)) {
    unsigned Opcode = BO->getOpcode();
    // id op x -> x, x op id -> x
    if (NewOps[0] == ConstantExpr::getBinOpIdentity(Opcode, I->getType()))
      return NewOps[1];
    if (NewOps[1] == ConstantExpr::getBinOpIdentity(Opcode, I->getType(),
                                                    /* RHS */ true))
      return NewOps[0];

    // x & x -> x, x | x -> x
    if ((Opcode == Instruction::And || Opcode == Instruction::Or) &&
        NewOps[0] == NewOps[1])
      return NewOps[0];

    // If we are substituting an absorber constant into a binop and extra
    // poison can't leak if we remove the select -- because both operands of
    // the binop are based on the same value -- then it may be safe to replace
    // the value with the absorber constant. Examples:
    // (Op == 0) ? 0 : (Op & -Op)            --> Op & -Op
    // (Op == 0) ? 0 : (Op * (binop Op, C))  --> Op * (binop Op, C)
    // (Op == -1) ? -1 : (Op | (binop C, Op) --> Op | (binop C, Op)
    if (RepOp == ConstantExpr::getBinOpAbsorber(Opcode, I->getType()) &&
        impliesPoison(BO, Op))
      return RepOp;
  }

  if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
    // getelementptr x, 0 -> x
    if (NewOps.size() == 2 && match(NewOps[1], m_Zero()) &&
        !GEP->isInBounds())
      return NewOps[0];
  }
} else if (MaxRecurse) {
  // The simplification queries below may return the original value. Consider:
  //   %div = udiv i32 %arg, %arg2
  //   %mul = mul nsw i32 %div, %arg2
  //   %cmp = icmp eq i32 %mul, %arg
  //   %sel = select i1 %cmp, i32 %div, i32 undef
  // Replacing %arg by %mul, %div becomes "udiv i32 %mul, %arg2", which
  // simplifies back to %arg. This can only happen because %mul does not
  // dominate %div. To ensure a consistent return value contract, we make sure
  // that this case returns nullptr as well.
  auto PreventSelfSimplify = [V](Value *Simplified) {
    return Simplified != V ? Simplified : nullptr;
  };

  if (auto *B = dyn_cast<BinaryOperator>(I))
    return PreventSelfSimplify(simplifyBinOp(B->getOpcode(), NewOps[0],
                                             NewOps[1], Q, MaxRecurse - 1));

  if (CmpInst *C = dyn_cast<CmpInst>(I))
    return PreventSelfSimplify(simplifyCmpInst(C->getPredicate(), NewOps[0],
                                               NewOps[1], Q, MaxRecurse - 1));

  if (auto *GEP = dyn_cast<GetElementPtrInst>(I))
    return PreventSelfSimplify(simplifyGEPInst(
        GEP->getSourceElementType(), NewOps[0], ArrayRef(NewOps).slice(1),
        GEP->isInBounds(), Q, MaxRecurse - 1));

  if (isa<SelectInst>(I))
    return PreventSelfSimplify(simplifySelectInst(
        NewOps[0], NewOps[1], NewOps[2], Q, MaxRecurse - 1));
  // TODO: We could hand off more cases to instsimplify here.
}

// If all operands are constant after substituting Op for RepOp then we can
// constant fold the instruction.
SmallVector<Constant *, 8> ConstOps;
for (Value *NewOp : NewOps) {
  if (Constant *ConstOp = dyn_cast<Constant>(NewOp))
    ConstOps.push_back(ConstOp);
  else
    return nullptr;
}

// Consider:
//   %cmp = icmp eq i32 %x, 2147483647
//   %add = add nsw i32 %x, 1
//   %sel = select i1 %cmp, i32 -2147483648, i32 %add
//
// We can't replace %sel with %add unless we strip away the flags (which
// will be done in InstCombine).
// TODO: This may be unsound, because it only catches some forms of
// refinement.
if (!AllowRefinement && canCreatePoison(cast<Operator>(I)))
  return nullptr;

return ConstantFoldInstOperands(I, ConstOps, Q.DL, Q.TLI);
4347}

4349Value *llvm::simplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
                                  const SimplifyQuery &Q,
                                  bool AllowRefinement) {
return ::simplifyWithOpReplaced(V, Op, RepOp, Q, AllowRefinement,
                                RecursionLimit);
4354}

4356/// Try to simplify a select instruction when its condition operand is an
4357/// integer comparison where one operand of the compare is a constant.
4358static Value *simplifySelectBitTest(Value *TrueVal, Value *FalseVal, Value *X,
                                  const APInt *Y, bool TrueWhenUnset) {
const APInt *C;

// (X & Y) == 0 ? X & ~Y : X  --> X
// (X & Y) != 0 ? X & ~Y : X  --> X & ~Y
if (FalseVal == X && match(TrueVal, m_And(m_Specific(X), m_APInt(C))) &&
    *Y == ~*C)
  return TrueWhenUnset ? FalseVal : TrueVal;

// (X & Y) == 0 ? X : X & ~Y  --> X & ~Y
// (X & Y) != 0 ? X : X & ~Y  --> X
if (TrueVal == X && match(FalseVal, m_And(m_Specific(X), m_APInt(C))) &&
    *Y == ~*C)
  return TrueWhenUnset ? FalseVal : TrueVal;

if (Y->isPowerOf2()) {
  // (X & Y) == 0 ? X | Y : X  --> X | Y
  // (X & Y) != 0 ? X | Y : X  --> X
  if (FalseVal == X && match(TrueVal, m_Or(m_Specific(X), m_APInt(C))) &&
      *Y == *C)
    return TrueWhenUnset ? TrueVal : FalseVal;

  // (X & Y) == 0 ? X : X | Y  --> X
  // (X & Y) != 0 ? X : X | Y  --> X | Y
  if (TrueVal == X && match(FalseVal, m_Or(m_Specific(X), m_APInt(C))) &&
      *Y == *C)
    return TrueWhenUnset ? TrueVal : FalseVal;
}

return nullptr;
4389}

4391static Value *simplifyCmpSelOfMaxMin(Value *CmpLHS, Value *CmpRHS,
                                   ICmpInst::Predicate Pred, Value *TVal,
                                   Value *FVal) {
// Canonicalize common cmp+sel operand as CmpLHS.
if (CmpRHS == TVal || CmpRHS == FVal) {
  std::swap(CmpLHS, CmpRHS);
  Pred = ICmpInst::getSwappedPredicate(Pred);
}

// Canonicalize common cmp+sel operand as TVal.
if (CmpLHS == FVal) {
  std::swap(TVal, FVal);
  Pred = ICmpInst::getInversePredicate(Pred);
}

// A vector select may be shuffling together elements that are equivalent
// based on the max/min/select relationship.
Value *X = CmpLHS, *Y = CmpRHS;
bool PeekedThroughSelectShuffle = false;
auto *Shuf = dyn_cast<ShuffleVectorInst>(FVal);
if (Shuf && Shuf->isSelect()) {
  if (Shuf->getOperand(0) == Y)
    FVal = Shuf->getOperand(1);
  else if (Shuf->getOperand(1) == Y)
    FVal = Shuf->getOperand(0);
  else
    return nullptr;
  PeekedThroughSelectShuffle = true;
}

// (X pred Y) ? X : max/min(X, Y)
auto *MMI = dyn_cast<MinMaxIntrinsic>(FVal);
if (!MMI || TVal != X ||
    !match(FVal, m_c_MaxOrMin(m_Specific(X), m_Specific(Y))))
  return nullptr;

// (X >  Y) ? X : max(X, Y) --> max(X, Y)
// (X >= Y) ? X : max(X, Y) --> max(X, Y)
// (X <  Y) ? X : min(X, Y) --> min(X, Y)
// (X <= Y) ? X : min(X, Y) --> min(X, Y)
//
// The equivalence allows a vector select (shuffle) of max/min and Y. Ex:
// (X > Y) ? X : (Z ? max(X, Y) : Y)
// If Z is true, this reduces as above, and if Z is false:
// (X > Y) ? X : Y --> max(X, Y)
ICmpInst::Predicate MMPred = MMI->getPredicate();
if (MMPred == CmpInst::getStrictPredicate(Pred))
  return MMI;

// Other transforms are not valid with a shuffle.
if (PeekedThroughSelectShuffle)
  return nullptr;

// (X == Y) ? X : max/min(X, Y) --> max/min(X, Y)
if (Pred == CmpInst::ICMP_EQ)
  return MMI;

// (X != Y) ? X : max/min(X, Y) --> X
if (Pred == CmpInst::ICMP_NE)
  return X;

// (X <  Y) ? X : max(X, Y) --> X
// (X <= Y) ? X : max(X, Y) --> X
// (X >  Y) ? X : min(X, Y) --> X
// (X >= Y) ? X : min(X, Y) --> X
ICmpInst::Predicate InvPred = CmpInst::getInversePredicate(Pred);
if (MMPred == CmpInst::getStrictPredicate(InvPred))
  return X;

return nullptr;
4461}

4463/// An alternative way to test if a bit is set or not uses sgt/slt instead of
4464/// eq/ne.
4465static Value *simplifySelectWithFakeICmpEq(Value *CmpLHS, Value *CmpRHS,
                                         ICmpInst::Predicate Pred,
                                         Value *TrueVal, Value *FalseVal) {
Value *X;
APInt Mask;
if (!decomposeBitTestICmp(CmpLHS, CmpRHS, Pred, X, Mask))
  return nullptr;

return simplifySelectBitTest(TrueVal, FalseVal, X, &Mask,
                             Pred == ICmpInst::ICMP_EQ);
4475}

4477/// Try to simplify a select instruction when its condition operand is an
4478/// integer comparison.
4479static Value *simplifySelectWithICmpCond(Value *CondVal, Value *TrueVal,
                                       Value *FalseVal,
                                       const SimplifyQuery &Q,
                                       unsigned MaxRecurse) {
ICmpInst::Predicate Pred;
Value *CmpLHS, *CmpRHS;
if (!match(CondVal, m_ICmp(Pred, m_Value(CmpLHS), m_Value(CmpRHS))))
  return nullptr;

if (Value *V = simplifyCmpSelOfMaxMin(CmpLHS, CmpRHS, Pred, TrueVal, FalseVal))
  return V;

// Canonicalize ne to eq predicate.
if (Pred == ICmpInst::ICMP_NE) {
  Pred = ICmpInst::ICMP_EQ;
  std::swap(TrueVal, FalseVal);
}

// Check for integer min/max with a limit constant:
// X > MIN_INT ? X : MIN_INT --> X
// X < MAX_INT ? X : MAX_INT --> X
if (TrueVal->getType()->isIntOrIntVectorTy()) {
  Value *X, *Y;
  SelectPatternFlavor SPF =
      matchDecomposedSelectPattern(cast<ICmpInst>(CondVal), TrueVal, FalseVal,
                                   X, Y)
          .Flavor;
  if (SelectPatternResult::isMinOrMax(SPF) && Pred == getMinMaxPred(SPF)) {
    APInt LimitC = getMinMaxLimit(getInverseMinMaxFlavor(SPF),
                                  X->getType()->getScalarSizeInBits());
    if (match(Y, m_SpecificInt(LimitC)))
      return X;
  }
}

if (Pred == ICmpInst::ICMP_EQ && match(CmpRHS, m_Zero())) {
  Value *X;
  const APInt *Y;
  if (match(CmpLHS, m_And(m_Value(X), m_APInt(Y))))
    if (Value *V = simplifySelectBitTest(TrueVal, FalseVal, X, Y,
                                         /*TrueWhenUnset=*/true))
      return V;

  // Test for a bogus zero-shift-guard-op around funnel-shift or rotate.
  Value *ShAmt;
  auto isFsh = m_CombineOr(m_FShl(m_Value(X), m_Value(), m_Value(ShAmt)),
                           m_FShr(m_Value(), m_Value(X), m_Value(ShAmt)));
  // (ShAmt == 0) ? fshl(X, *, ShAmt) : X --> X
  // (ShAmt == 0) ? fshr(*, X, ShAmt) : X --> X
  if (match(TrueVal, isFsh) && FalseVal == X && CmpLHS == ShAmt)
    return X;

  // Test for a zero-shift-guard-op around rotates. These are used to
  // avoid UB from oversized shifts in raw IR rotate patterns, but the
  // intrinsics do not have that problem.
  // We do not allow this transform for the general funnel shift case because
  // that would not preserve the poison safety of the original code.
  auto isRotate =
      m_CombineOr(m_FShl(m_Value(X), m_Deferred(X), m_Value(ShAmt)),
                  m_FShr(m_Value(X), m_Deferred(X), m_Value(ShAmt)));
  // (ShAmt == 0) ? X : fshl(X, X, ShAmt) --> fshl(X, X, ShAmt)
  // (ShAmt == 0) ? X : fshr(X, X, ShAmt) --> fshr(X, X, ShAmt)
  if (match(FalseVal, isRotate) && TrueVal == X && CmpLHS == ShAmt &&
      Pred == ICmpInst::ICMP_EQ)
    return FalseVal;

  // X == 0 ? abs(X) : -abs(X) --> -abs(X)
  // X == 0 ? -abs(X) : abs(X) --> abs(X)
  if (match(TrueVal, m_Intrinsic<Intrinsic::abs>(m_Specific(CmpLHS))) &&
      match(FalseVal, m_Neg(m_Intrinsic<Intrinsic::abs>(m_Specific(CmpLHS)))))
    return FalseVal;
  if (match(TrueVal,
            m_Neg(m_Intrinsic<Intrinsic::abs>(m_Specific(CmpLHS)))) &&
      match(FalseVal, m_Intrinsic<Intrinsic::abs>(m_Specific(CmpLHS))))
    return FalseVal;
}

// Check for other compares that behave like bit test.
if (Value *V =
        simplifySelectWithFakeICmpEq(CmpLHS, CmpRHS, Pred, TrueVal, FalseVal))
  return V;

// If we have a scalar equality comparison, then we know the value in one of
// the arms of the select. See if substituting this value into the arm and
// simplifying the result yields the same value as the other arm.
if (Pred == ICmpInst::ICMP_EQ) {
  if (simplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, Q,
                             /* AllowRefinement */ false,
                             MaxRecurse) == TrueVal ||
      simplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, Q,
                             /* AllowRefinement */ false,
                             MaxRecurse) == TrueVal)
    return FalseVal;
  if (simplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, Q,
                             /* AllowRefinement */ true,
                             MaxRecurse) == FalseVal ||
      simplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, Q,
                             /* AllowRefinement */ true,
                             MaxRecurse) == FalseVal)
    return FalseVal;
}

return nullptr;
4582}

4584/// Try to simplify a select instruction when its condition operand is a
4585/// floating-point comparison.
4586static Value *simplifySelectWithFCmp(Value *Cond, Value *T, Value *F,
                                   const SimplifyQuery &Q) {
FCmpInst::Predicate Pred;
if (!match(Cond, m_FCmp(Pred, m_Specific(T), m_Specific(F))) &&
    !match(Cond, m_FCmp(Pred, m_Specific(F), m_Specific(T))))
  return nullptr;

// This transform is safe if we do not have (do not care about) -0.0 or if
// at least one operand is known to not be -0.0. Otherwise, the select can
// change the sign of a zero operand.
bool HasNoSignedZeros =
    Q.CxtI && isa<FPMathOperator>(Q.CxtI) && Q.CxtI->hasNoSignedZeros();
const APFloat *C;
if (HasNoSignedZeros || (match(T, m_APFloat(C)) && C->isNonZero()) ||
    (match(F, m_APFloat(C)) && C->isNonZero())) {
  // (T == F) ? T : F --> F
  // (F == T) ? T : F --> F
  if (Pred == FCmpInst::FCMP_OEQ)
    return F;

  // (T != F) ? T : F --> T
  // (F != T) ? T : F --> T
  if (Pred == FCmpInst::FCMP_UNE)
    return T;
}

return nullptr;
4613}

4615/// Given operands for a SelectInst, see if we can fold the result.
4616/// If not, this returns null.
4617static Value *simplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
                               const SimplifyQuery &Q, unsigned MaxRecurse) {
if (auto *CondC = dyn_cast<Constant>(Cond)) {
  if (auto *TrueC = dyn_cast<Constant>(TrueVal))
    if (auto *FalseC = dyn_cast<Constant>(FalseVal))
      return ConstantFoldSelectInstruction(CondC, TrueC, FalseC);

  // select poison, X, Y -> poison
  if (isa<PoisonValue>(CondC))
    return PoisonValue::get(TrueVal->getType());

  // select undef, X, Y -> X or Y
  if (Q.isUndefValue(CondC))
    return isa<Constant>(FalseVal) ? FalseVal : TrueVal;

  // select true,  X, Y --> X
  // select false, X, Y --> Y
  // For vectors, allow undef/poison elements in the condition to match the
  // defined elements, so we can eliminate the select.
  if (match(CondC, m_One()))
    return TrueVal;
  if (match(CondC, m_Zero()))
    return FalseVal;
}

assert(Cond->getType()->isIntOrIntVectorTy(1) &&(static_cast <bool> (Cond->getType()->isIntOrIntVectorTy
(1) && "Select must have bool or bool vector condition"
) ? void (0) : __assert_fail ("Cond->getType()->isIntOrIntVectorTy(1) && \"Select must have bool or bool vector condition\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4643, __extension__
 __PRETTY_FUNCTION__))
       "Select must have bool or bool vector condition")(static_cast <bool> (Cond->getType()->isIntOrIntVectorTy
(1) && "Select must have bool or bool vector condition"
) ? void (0) : __assert_fail ("Cond->getType()->isIntOrIntVectorTy(1) && \"Select must have bool or bool vector condition\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4643, __extension__
 __PRETTY_FUNCTION__));
assert(TrueVal->getType() == FalseVal->getType() &&(static_cast <bool> (TrueVal->getType() == FalseVal->
getType() && "Select must have same types for true/false ops"
) ? void (0) : __assert_fail ("TrueVal->getType() == FalseVal->getType() && \"Select must have same types for true/false ops\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4645, __extension__
 __PRETTY_FUNCTION__))
       "Select must have same types for true/false ops")(static_cast <bool> (TrueVal->getType() == FalseVal->
getType() && "Select must have same types for true/false ops"
) ? void (0) : __assert_fail ("TrueVal->getType() == FalseVal->getType() && \"Select must have same types for true/false ops\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 4645, __extension__
 __PRETTY_FUNCTION__));

if (Cond->getType() == TrueVal->getType()) {
  // select i1 Cond, i1 true, i1 false --> i1 Cond
  if (match(TrueVal, m_One()) && match(FalseVal, m_ZeroInt()))
    return Cond;

  // (X && Y) ? X : Y --> Y (commuted 2 ways)
  if (match(Cond, m_c_LogicalAnd(m_Specific(TrueVal), m_Specific(FalseVal))))
    return FalseVal;

  // (X || Y) ? X : Y --> X (commuted 2 ways)
  if (match(Cond, m_c_LogicalOr(m_Specific(TrueVal), m_Specific(FalseVal))))
    return TrueVal;

  // (X || Y) ? false : X --> false (commuted 2 ways)
  if (match(Cond, m_c_LogicalOr(m_Specific(FalseVal), m_Value())) &&
      match(TrueVal, m_ZeroInt()))
    return ConstantInt::getFalse(Cond->getType());

  // Match patterns that end in logical-and.
  if (match(FalseVal, m_ZeroInt())) {
    // !(X || Y) && X --> false (commuted 2 ways)
    if (match(Cond, m_Not(m_c_LogicalOr(m_Specific(TrueVal), m_Value()))))
      return ConstantInt::getFalse(Cond->getType());
    // X && !(X || Y) --> false (commuted 2 ways)
    if (match(TrueVal, m_Not(m_c_LogicalOr(m_Specific(Cond), m_Value()))))
      return ConstantInt::getFalse(Cond->getType());

    // (X || Y) && Y --> Y (commuted 2 ways)
    if (match(Cond, m_c_LogicalOr(m_Specific(TrueVal), m_Value())))
      return TrueVal;
    // Y && (X || Y) --> Y (commuted 2 ways)
    if (match(TrueVal, m_c_LogicalOr(m_Specific(Cond), m_Value())))
      return Cond;

    // (X || Y) && (X || !Y) --> X (commuted 8 ways)
    Value *X, *Y;
    if (match(Cond, m_c_LogicalOr(m_Value(X), m_Not(m_Value(Y)))) &&
        match(TrueVal, m_c_LogicalOr(m_Specific(X), m_Specific(Y))))
      return X;
    if (match(TrueVal, m_c_LogicalOr(m_Value(X), m_Not(m_Value(Y)))) &&
        match(Cond, m_c_LogicalOr(m_Specific(X), m_Specific(Y))))
      return X;
  }

  // Match patterns that end in logical-or.
  if (match(TrueVal, m_One())) {
    // !(X && Y) || X --> true (commuted 2 ways)
    if (match(Cond, m_Not(m_c_LogicalAnd(m_Specific(FalseVal), m_Value()))))
      return ConstantInt::getTrue(Cond->getType());
    // X || !(X && Y) --> true (commuted 2 ways)
    if (match(FalseVal, m_Not(m_c_LogicalAnd(m_Specific(Cond), m_Value()))))
      return ConstantInt::getTrue(Cond->getType());

    // (X && Y) || Y --> Y (commuted 2 ways)
    if (match(Cond, m_c_LogicalAnd(m_Specific(FalseVal), m_Value())))
      return FalseVal;
    // Y || (X && Y) --> Y (commuted 2 ways)
    if (match(FalseVal, m_c_LogicalAnd(m_Specific(Cond), m_Value())))
      return Cond;
  }
}

// select ?, X, X -> X
if (TrueVal == FalseVal)
  return TrueVal;

if (Cond == TrueVal) {
  // select i1 X, i1 X, i1 false --> X (logical-and)
  if (match(FalseVal, m_ZeroInt()))
    return Cond;
  // select i1 X, i1 X, i1 true --> true
  if (match(FalseVal, m_One()))
    return ConstantInt::getTrue(Cond->getType());
}
if (Cond == FalseVal) {
  // select i1 X, i1 true, i1 X --> X (logical-or)
  if (match(TrueVal, m_One()))
    return Cond;
  // select i1 X, i1 false, i1 X --> false
  if (match(TrueVal, m_ZeroInt()))
    return ConstantInt::getFalse(Cond->getType());
}

// If the true or false value is poison, we can fold to the other value.
// If the true or false value is undef, we can fold to the other value as
// long as the other value isn't poison.
// select ?, poison, X -> X
// select ?, undef,  X -> X
if (isa<PoisonValue>(TrueVal) ||
    (Q.isUndefValue(TrueVal) &&
     isGuaranteedNotToBePoison(FalseVal, Q.AC, Q.CxtI, Q.DT)))
  return FalseVal;
// select ?, X, poison -> X
// select ?, X, undef  -> X
if (isa<PoisonValue>(FalseVal) ||
    (Q.isUndefValue(FalseVal) &&
     isGuaranteedNotToBePoison(TrueVal, Q.AC, Q.CxtI, Q.DT)))
  return TrueVal;

// Deal with partial undef vector constants: select ?, VecC, VecC' --> VecC''
Constant *TrueC, *FalseC;
if (isa<FixedVectorType>(TrueVal->getType()) &&
    match(TrueVal, m_Constant(TrueC)) &&
    match(FalseVal, m_Constant(FalseC))) {
  unsigned NumElts =
      cast<FixedVectorType>(TrueC->getType())->getNumElements();
  SmallVector<Constant *, 16> NewC;
  for (unsigned i = 0; i != NumElts; ++i) {
    // Bail out on incomplete vector constants.
    Constant *TEltC = TrueC->getAggregateElement(i);
    Constant *FEltC = FalseC->getAggregateElement(i);
    if (!TEltC || !FEltC)
      break;

    // If the elements match (undef or not), that value is the result. If only
    // one element is undef, choose the defined element as the safe result.
    if (TEltC == FEltC)
      NewC.push_back(TEltC);
    else if (isa<PoisonValue>(TEltC) ||
             (Q.isUndefValue(TEltC) && isGuaranteedNotToBePoison(FEltC)))
      NewC.push_back(FEltC);
    else if (isa<PoisonValue>(FEltC) ||
             (Q.isUndefValue(FEltC) && isGuaranteedNotToBePoison(TEltC)))
      NewC.push_back(TEltC);
    else
      break;
  }
  if (NewC.size() == NumElts)
    return ConstantVector::get(NewC);
}

if (Value *V =
        simplifySelectWithICmpCond(Cond, TrueVal, FalseVal, Q, MaxRecurse))
  return V;

if (Value *V = simplifySelectWithFCmp(Cond, TrueVal, FalseVal, Q))
  return V;

if (Value *V = foldSelectWithBinaryOp(Cond, TrueVal, FalseVal))
  return V;

std::optional<bool> Imp = isImpliedByDomCondition(Cond, Q.CxtI, Q.DL);
if (Imp)
  return *Imp ? TrueVal : FalseVal;

return nullptr;
4793}

4795Value *llvm::simplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
                              const SimplifyQuery &Q) {
return ::simplifySelectInst(Cond, TrueVal, FalseVal, Q, RecursionLimit);
4798}

4800/// Given operands for an GetElementPtrInst, see if we can fold the result.
4801/// If not, this returns null.
4802static Value *simplifyGEPInst(Type *SrcTy, Value *Ptr,
                            ArrayRef<Value *> Indices, bool InBounds,
                            const SimplifyQuery &Q, unsigned) {
// The type of the GEP pointer operand.
unsigned AS =
    cast<PointerType>(Ptr->getType()->getScalarType())->getAddressSpace();

// getelementptr P -> P.
if (Indices.empty())
  return Ptr;

// Compute the (pointer) type returned by the GEP instruction.
Type *LastType = GetElementPtrInst::getIndexedType(SrcTy, Indices);
Type *GEPTy = PointerType::get(LastType, AS);
if (VectorType *VT = dyn_cast<VectorType>(Ptr->getType()))
  GEPTy = VectorType::get(GEPTy, VT->getElementCount());
else {
  for (Value *Op : Indices) {
    // If one of the operands is a vector, the result type is a vector of
    // pointers. All vector operands must have the same number of elements.
    if (VectorType *VT = dyn_cast<VectorType>(Op->getType())) {
      GEPTy = VectorType::get(GEPTy, VT->getElementCount());
      break;
    }
  }
}

// For opaque pointers an all-zero GEP is a no-op. For typed pointers,
// it may be equivalent to a bitcast.
if (Ptr->getType()->getScalarType()->isOpaquePointerTy() &&
    Ptr->getType() == GEPTy &&
    all_of(Indices, [](const auto *V) { return match(V, m_Zero()); }))
  return Ptr;

// getelementptr poison, idx -> poison
// getelementptr baseptr, poison -> poison
if (isa<PoisonValue>(Ptr) ||
    any_of(Indices, [](const auto *V) { return isa<PoisonValue>(V); }))
  return PoisonValue::get(GEPTy);

if (Q.isUndefValue(Ptr))
  // If inbounds, we can choose an out-of-bounds pointer as a base pointer.
  return InBounds ? PoisonValue::get(GEPTy) : UndefValue::get(GEPTy);

bool IsScalableVec =
    isa<ScalableVectorType>(SrcTy) || any_of(Indices, [](const Value *V) {
      return isa<ScalableVectorType>(V->getType());
    });

if (Indices.size() == 1) {
  // getelementptr P, 0 -> P.
  if (match(Indices[0], m_Zero()) && Ptr->getType() == GEPTy)
    return Ptr;

  Type *Ty = SrcTy;
  if (!IsScalableVec && Ty->isSized()) {
    Value *P;
    uint64_t C;
    uint64_t TyAllocSize = Q.DL.getTypeAllocSize(Ty);
    // getelementptr P, N -> P if P points to a type of zero size.
    if (TyAllocSize == 0 && Ptr->getType() == GEPTy)
      return Ptr;

    // The following transforms are only safe if the ptrtoint cast
    // doesn't truncate the pointers.
    if (Indices[0]->getType()->getScalarSizeInBits() ==
        Q.DL.getPointerSizeInBits(AS)) {
      auto CanSimplify = [GEPTy, &P, Ptr]() -> bool {
        return P->getType() == GEPTy &&
               getUnderlyingObject(P) == getUnderlyingObject(Ptr);
      };
      // getelementptr V, (sub P, V) -> P if P points to a type of size 1.
      if (TyAllocSize == 1 &&
          match(Indices[0],
                m_Sub(m_PtrToInt(m_Value(P)), m_PtrToInt(m_Specific(Ptr)))) &&
          CanSimplify())
        return P;

      // getelementptr V, (ashr (sub P, V), C) -> P if P points to a type of
      // size 1 << C.
      if (match(Indices[0], m_AShr(m_Sub(m_PtrToInt(m_Value(P)),
                                         m_PtrToInt(m_Specific(Ptr))),
                                   m_ConstantInt(C))) &&
          TyAllocSize == 1ULL << C && CanSimplify())
        return P;

      // getelementptr V, (sdiv (sub P, V), C) -> P if P points to a type of
      // size C.
      if (match(Indices[0], m_SDiv(m_Sub(m_PtrToInt(m_Value(P)),
                                         m_PtrToInt(m_Specific(Ptr))),
                                   m_SpecificInt(TyAllocSize))) &&
          CanSimplify())
        return P;
    }
  }
}

if (!IsScalableVec && Q.DL.getTypeAllocSize(LastType) == 1 &&
    all_of(Indices.drop_back(1),
           [](Value *Idx) { return match(Idx, m_Zero()); })) {
  unsigned IdxWidth =
      Q.DL.getIndexSizeInBits(Ptr->getType()->getPointerAddressSpace());
  if (Q.DL.getTypeSizeInBits(Indices.back()->getType()) == IdxWidth) {
    APInt BasePtrOffset(IdxWidth, 0);
    Value *StrippedBasePtr =
        Ptr->stripAndAccumulateInBoundsConstantOffsets(Q.DL, BasePtrOffset);

    // Avoid creating inttoptr of zero here: While LLVMs treatment of
    // inttoptr is generally conservative, this particular case is folded to
    // a null pointer, which will have incorrect provenance.

    // gep (gep V, C), (sub 0, V) -> C
    if (match(Indices.back(),
              m_Sub(m_Zero(), m_PtrToInt(m_Specific(StrippedBasePtr)))) &&
        !BasePtrOffset.isZero()) {
      auto *CI = ConstantInt::get(GEPTy->getContext(), BasePtrOffset);
      return ConstantExpr::getIntToPtr(CI, GEPTy);
    }
    // gep (gep V, C), (xor V, -1) -> C-1
    if (match(Indices.back(),
              m_Xor(m_PtrToInt(m_Specific(StrippedBasePtr)), m_AllOnes())) &&
        !BasePtrOffset.isOne()) {
      auto *CI = ConstantInt::get(GEPTy->getContext(), BasePtrOffset - 1);
      return ConstantExpr::getIntToPtr(CI, GEPTy);
    }
  }
}

// Check to see if this is constant foldable.
if (!isa<Constant>(Ptr) ||
    !all_of(Indices, [](Value *V) { return isa<Constant>(V); }))
  return nullptr;

if (!ConstantExpr::isSupportedGetElementPtr(SrcTy))
  return ConstantFoldGetElementPtr(SrcTy, cast<Constant>(Ptr), InBounds,
                                   std::nullopt, Indices);

auto *CE = ConstantExpr::getGetElementPtr(SrcTy, cast<Constant>(Ptr), Indices,
                                          InBounds);
return ConstantFoldConstant(CE, Q.DL);
4942}

4944Value *llvm::simplifyGEPInst(Type *SrcTy, Value *Ptr, ArrayRef<Value *> Indices,
                           bool InBounds, const SimplifyQuery &Q) {
return ::simplifyGEPInst(SrcTy, Ptr, Indices, InBounds, Q, RecursionLimit);
4947}

4949/// Given operands for an InsertValueInst, see if we can fold the result.
4950/// If not, this returns null.
4951static Value *simplifyInsertValueInst(Value *Agg, Value *Val,
                                    ArrayRef<unsigned> Idxs,
                                    const SimplifyQuery &Q, unsigned) {
if (Constant *CAgg = dyn_cast<Constant>(Agg))
  if (Constant *CVal = dyn_cast<Constant>(Val))
    return ConstantFoldInsertValueInstruction(CAgg, CVal, Idxs);

// insertvalue x, poison, n -> x
// insertvalue x, undef, n -> x if x cannot be poison
if (isa<PoisonValue>(Val) ||
    (Q.isUndefValue(Val) && isGuaranteedNotToBePoison(Agg)))
  return Agg;

// insertvalue x, (extractvalue y, n), n
if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val))
  if (EV->getAggregateOperand()->getType() == Agg->getType() &&
      EV->getIndices() == Idxs) {
    // insertvalue poison, (extractvalue y, n), n -> y
    // insertvalue undef, (extractvalue y, n), n -> y if y cannot be poison
    if (isa<PoisonValue>(Agg) ||
        (Q.isUndefValue(Agg) &&
         isGuaranteedNotToBePoison(EV->getAggregateOperand())))
      return EV->getAggregateOperand();

    // insertvalue y, (extractvalue y, n), n -> y
    if (Agg == EV->getAggregateOperand())
      return Agg;
  }

return nullptr;
4981}

4983Value *llvm::simplifyInsertValueInst(Value *Agg, Value *Val,
                                   ArrayRef<unsigned> Idxs,
                                   const SimplifyQuery &Q) {
return ::simplifyInsertValueInst(Agg, Val, Idxs, Q, RecursionLimit);
4987}

4989Value *llvm::simplifyInsertElementInst(Value *Vec, Value *Val, Value *Idx,
                                     const SimplifyQuery &Q) {
// Try to constant fold.
auto *VecC = dyn_cast<Constant>(Vec);
auto *ValC = dyn_cast<Constant>(Val);
auto *IdxC = dyn_cast<Constant>(Idx);
if (VecC && ValC && IdxC)
  return ConstantExpr::getInsertElement(VecC, ValC, IdxC);

// For fixed-length vector, fold into poison if index is out of bounds.
if (auto *CI = dyn_cast<ConstantInt>(Idx)) {
  if (isa<FixedVectorType>(Vec->getType()) &&
      CI->uge(cast<FixedVectorType>(Vec->getType())->getNumElements()))
    return PoisonValue::get(Vec->getType());
}

// If index is undef, it might be out of bounds (see above case)
if (Q.isUndefValue(Idx))
  return PoisonValue::get(Vec->getType());

// If the scalar is poison, or it is undef and there is no risk of
// propagating poison from the vector value, simplify to the vector value.
if (isa<PoisonValue>(Val) ||
    (Q.isUndefValue(Val) && isGuaranteedNotToBePoison(Vec)))
  return Vec;

// If we are extracting a value from a vector, then inserting it into the same
// place, that's the input vector:
// insertelt Vec, (extractelt Vec, Idx), Idx --> Vec
if (match(Val, m_ExtractElt(m_Specific(Vec), m_Specific(Idx))))
  return Vec;

return nullptr;
5022}

5024/// Given operands for an ExtractValueInst, see if we can fold the result.
5025/// If not, this returns null.
5026static Value *simplifyExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,
                                     const SimplifyQuery &, unsigned) {
if (auto *CAgg = dyn_cast<Constant>(Agg))
  return ConstantFoldExtractValueInstruction(CAgg, Idxs);

// extractvalue x, (insertvalue y, elt, n), n -> elt
unsigned NumIdxs = Idxs.size();
for (auto *IVI = dyn_cast<InsertValueInst>(Agg); IVI != nullptr;
     IVI = dyn_cast<InsertValueInst>(IVI->getAggregateOperand())) {
  ArrayRef<unsigned> InsertValueIdxs = IVI->getIndices();
  unsigned NumInsertValueIdxs = InsertValueIdxs.size();
  unsigned NumCommonIdxs = std::min(NumInsertValueIdxs, NumIdxs);
  if (InsertValueIdxs.slice(0, NumCommonIdxs) ==
      Idxs.slice(0, NumCommonIdxs)) {
    if (NumIdxs == NumInsertValueIdxs)
      return IVI->getInsertedValueOperand();
    break;
  }
}

return nullptr;
5047}

5049Value *llvm::simplifyExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,
                                    const SimplifyQuery &Q) {
return ::simplifyExtractValueInst(Agg, Idxs, Q, RecursionLimit);
5052}

5054/// Given operands for an ExtractElementInst, see if we can fold the result.
5055/// If not, this returns null.
5056static Value *simplifyExtractElementInst(Value *Vec, Value *Idx,
                                       const SimplifyQuery &Q, unsigned) {
auto *VecVTy = cast<VectorType>(Vec->getType());
if (auto *CVec = dyn_cast<Constant>(Vec)) {
  if (auto *CIdx = dyn_cast<Constant>(Idx))
    return ConstantExpr::getExtractElement(CVec, CIdx);

  if (Q.isUndefValue(Vec))
    return UndefValue::get(VecVTy->getElementType());
}

// An undef extract index can be arbitrarily chosen to be an out-of-range
// index value, which would result in the instruction being poison.
if (Q.isUndefValue(Idx))
  return PoisonValue::get(VecVTy->getElementType());

// If extracting a specified index from the vector, see if we can recursively
// find a previously computed scalar that was inserted into the vector.
if (auto *IdxC = dyn_cast<ConstantInt>(Idx)) {
  // For fixed-length vector, fold into undef if index is out of bounds.
  unsigned MinNumElts = VecVTy->getElementCount().getKnownMinValue();
  if (isa<FixedVectorType>(VecVTy) && IdxC->getValue().uge(MinNumElts))
    return PoisonValue::get(VecVTy->getElementType());
  // Handle case where an element is extracted from a splat.
  if (IdxC->getValue().ult(MinNumElts))
    if (auto *Splat = getSplatValue(Vec))
      return Splat;
  if (Value *Elt = findScalarElement(Vec, IdxC->getZExtValue()))
    return Elt;
} else {
  // extractelt x, (insertelt y, elt, n), n -> elt
  // If the possibly-variable indices are trivially known to be equal
  // (because they are the same operand) then use the value that was
  // inserted directly.
  auto *IE = dyn_cast<InsertElementInst>(Vec);
  if (IE && IE->getOperand(2) == Idx)
    return IE->getOperand(1);

  // The index is not relevant if our vector is a splat.
  if (Value *Splat = getSplatValue(Vec))
    return Splat;
}
return nullptr;
5099}

5101Value *llvm::simplifyExtractElementInst(Value *Vec, Value *Idx,
                                      const SimplifyQuery &Q) {
return ::simplifyExtractElementInst(Vec, Idx, Q, RecursionLimit);
5104}

5106/// See if we can fold the given phi. If not, returns null.
5107static Value *simplifyPHINode(PHINode *PN, ArrayRef<Value *> IncomingValues,
                            const SimplifyQuery &Q) {
// WARNING: no matter how worthwhile it may seem, we can not perform PHI CSE
//          here, because the PHI we may succeed simplifying to was not
//          def-reachable from the original PHI!

// If all of the PHI's incoming values are the same then replace the PHI node
// with the common value.
Value *CommonValue = nullptr;
bool HasUndefInput = false;
for (Value *Incoming : IncomingValues) {
  // If the incoming value is the phi node itself, it can safely be skipped.
  if (Incoming == PN)
    continue;
  if (Q.isUndefValue(Incoming)) {
    // Remember that we saw an undef value, but otherwise ignore them.
    HasUndefInput = true;
    continue;
  }
  if (CommonValue && Incoming != CommonValue)
    return nullptr; // Not the same, bail out.
  CommonValue = Incoming;
}

// If CommonValue is null then all of the incoming values were either undef or
// equal to the phi node itself.
if (!CommonValue)
  return UndefValue::get(PN->getType());

if (HasUndefInput) {
  // If we have a PHI node like phi(X, undef, X), where X is defined by some
  // instruction, we cannot return X as the result of the PHI node unless it
  // dominates the PHI block.
  return valueDominatesPHI(CommonValue, PN, Q.DT) ? CommonValue : nullptr;
}

return CommonValue;
5144}

5146static Value *simplifyCastInst(unsigned CastOpc, Value *Op, Type *Ty,
                             const SimplifyQuery &Q, unsigned MaxRecurse) {
if (auto *C = dyn_cast<Constant>(Op))
  return ConstantFoldCastOperand(CastOpc, C, Ty, Q.DL);

if (auto *CI = dyn_cast<CastInst>(Op)) {
  auto *Src = CI->getOperand(0);
  Type *SrcTy = Src->getType();
  Type *MidTy = CI->getType();
  Type *DstTy = Ty;
  if (Src->getType() == Ty) {
    auto FirstOp = static_cast<Instruction::CastOps>(CI->getOpcode());
    auto SecondOp = static_cast<Instruction::CastOps>(CastOpc);
    Type *SrcIntPtrTy =
        SrcTy->isPtrOrPtrVectorTy() ? Q.DL.getIntPtrType(SrcTy) : nullptr;
    Type *MidIntPtrTy =
        MidTy->isPtrOrPtrVectorTy() ? Q.DL.getIntPtrType(MidTy) : nullptr;
    Type *DstIntPtrTy =
        DstTy->isPtrOrPtrVectorTy() ? Q.DL.getIntPtrType(DstTy) : nullptr;
    if (CastInst::isEliminableCastPair(FirstOp, SecondOp, SrcTy, MidTy, DstTy,
                                       SrcIntPtrTy, MidIntPtrTy,
                                       DstIntPtrTy) == Instruction::BitCast)
      return Src;
  }
}

// bitcast x -> x
if (CastOpc == Instruction::BitCast)
  if (Op->getType() == Ty)
    return Op;

return nullptr;
5178}

5180Value *llvm::simplifyCastInst(unsigned CastOpc, Value *Op, Type *Ty,
                            const SimplifyQuery &Q) {
return ::simplifyCastInst(CastOpc, Op, Ty, Q, RecursionLimit);
5183}

5185/// For the given destination element of a shuffle, peek through shuffles to
5186/// match a root vector source operand that contains that element in the same
5187/// vector lane (ie, the same mask index), so we can eliminate the shuffle(s).
5188static Value *foldIdentityShuffles(int DestElt, Value *Op0, Value *Op1,
                                 int MaskVal, Value *RootVec,
                                 unsigned MaxRecurse) {
if (!MaxRecurse--)
  return nullptr;

// Bail out if any mask value is undefined. That kind of shuffle may be
// simplified further based on demanded bits or other folds.
if (MaskVal == -1)
  return nullptr;

// The mask value chooses which source operand we need to look at next.
int InVecNumElts = cast<FixedVectorType>(Op0->getType())->getNumElements();
int RootElt = MaskVal;
Value *SourceOp = Op0;
if (MaskVal >= InVecNumElts) {
  RootElt = MaskVal - InVecNumElts;
  SourceOp = Op1;
}

// If the source operand is a shuffle itself, look through it to find the
// matching root vector.
if (auto *SourceShuf = dyn_cast<ShuffleVectorInst>(SourceOp)) {
  return foldIdentityShuffles(
      DestElt, SourceShuf->getOperand(0), SourceShuf->getOperand(1),
      SourceShuf->getMaskValue(RootElt), RootVec, MaxRecurse);
}

// TODO: Look through bitcasts? What if the bitcast changes the vector element
// size?

// The source operand is not a shuffle. Initialize the root vector value for
// this shuffle if that has not been done yet.
if (!RootVec)
  RootVec = SourceOp;

// Give up as soon as a source operand does not match the existing root value.
if (RootVec != SourceOp)
  return nullptr;

// The element must be coming from the same lane in the source vector
// (although it may have crossed lanes in intermediate shuffles).
if (RootElt != DestElt)
  return nullptr;

return RootVec;
5234}

5236static Value *simplifyShuffleVectorInst(Value *Op0, Value *Op1,
                                      ArrayRef<int> Mask, Type *RetTy,
                                      const SimplifyQuery &Q,
                                      unsigned MaxRecurse) {
if (all_of(Mask, [](int Elem) { return Elem == UndefMaskElem; }))
  return UndefValue::get(RetTy);

auto *InVecTy = cast<VectorType>(Op0->getType());
unsigned MaskNumElts = Mask.size();
ElementCount InVecEltCount = InVecTy->getElementCount();

bool Scalable = InVecEltCount.isScalable();

SmallVector<int, 32> Indices;
Indices.assign(Mask.begin(), Mask.end());

// Canonicalization: If mask does not select elements from an input vector,
// replace that input vector with poison.
if (!Scalable) {
  bool MaskSelects0 = false, MaskSelects1 = false;
  unsigned InVecNumElts = InVecEltCount.getKnownMinValue();
  for (unsigned i = 0; i != MaskNumElts; ++i) {
    if (Indices[i] == -1)
      continue;
    if ((unsigned)Indices[i] < InVecNumElts)
      MaskSelects0 = true;
    else
      MaskSelects1 = true;
  }
  if (!MaskSelects0)
    Op0 = PoisonValue::get(InVecTy);
  if (!MaskSelects1)
    Op1 = PoisonValue::get(InVecTy);
}

auto *Op0Const = dyn_cast<Constant>(Op0);
auto *Op1Const = dyn_cast<Constant>(Op1);

// If all operands are constant, constant fold the shuffle. This
// transformation depends on the value of the mask which is not known at
// compile time for scalable vectors
if (Op0Const && Op1Const)
  return ConstantExpr::getShuffleVector(Op0Const, Op1Const, Mask);

// Canonicalization: if only one input vector is constant, it shall be the
// second one. This transformation depends on the value of the mask which
// is not known at compile time for scalable vectors
if (!Scalable && Op0Const && !Op1Const) {
  std::swap(Op0, Op1);
  ShuffleVectorInst::commuteShuffleMask(Indices,
                                        InVecEltCount.getKnownMinValue());
}

// A splat of an inserted scalar constant becomes a vector constant:
// shuf (inselt ?, C, IndexC), undef, <IndexC, IndexC...> --> <C, C...>
// NOTE: We may have commuted above, so analyze the updated Indices, not the
//       original mask constant.
// NOTE: This transformation depends on the value of the mask which is not
// known at compile time for scalable vectors
Constant *C;
ConstantInt *IndexC;
if (!Scalable && match(Op0, m_InsertElt(m_Value(), m_Constant(C),
                                        m_ConstantInt(IndexC)))) {
  // Match a splat shuffle mask of the insert index allowing undef elements.
  int InsertIndex = IndexC->getZExtValue();
  if (all_of(Indices, [InsertIndex](int MaskElt) {
        return MaskElt == InsertIndex || MaskElt == -1;
      })) {
    assert(isa<UndefValue>(Op1) && "Expected undef operand 1 for splat")(static_cast <bool> (isa<UndefValue>(Op1) &&
 "Expected undef operand 1 for splat") ? void (0) : __assert_fail
 ("isa<UndefValue>(Op1) && \"Expected undef operand 1 for splat\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 5304, __extension__
 __PRETTY_FUNCTION__));

    // Shuffle mask undefs become undefined constant result elements.
    SmallVector<Constant *, 16> VecC(MaskNumElts, C);
    for (unsigned i = 0; i != MaskNumElts; ++i)
      if (Indices[i] == -1)
        VecC[i] = UndefValue::get(C->getType());
    return ConstantVector::get(VecC);
  }
}

// A shuffle of a splat is always the splat itself. Legal if the shuffle's
// value type is same as the input vectors' type.
if (auto *OpShuf = dyn_cast<ShuffleVectorInst>(Op0))
  if (Q.isUndefValue(Op1) && RetTy == InVecTy &&
      all_equal(OpShuf->getShuffleMask()))
    return Op0;

// All remaining transformation depend on the value of the mask, which is
// not known at compile time for scalable vectors.
if (Scalable)
  return nullptr;

// Don't fold a shuffle with undef mask elements. This may get folded in a
// better way using demanded bits or other analysis.
// TODO: Should we allow this?
if (is_contained(Indices, -1))
  return nullptr;

// Check if every element of this shuffle can be mapped back to the
// corresponding element of a single root vector. If so, we don't need this
// shuffle. This handles simple identity shuffles as well as chains of
// shuffles that may widen/narrow and/or move elements across lanes and back.
Value *RootVec = nullptr;
for (unsigned i = 0; i != MaskNumElts; ++i) {
  // Note that recursion is limited for each vector element, so if any element
  // exceeds the limit, this will fail to simplify.
  RootVec =
      foldIdentityShuffles(i, Op0, Op1, Indices[i], RootVec, MaxRecurse);

  // We can't replace a widening/narrowing shuffle with one of its operands.
  if (!RootVec || RootVec->getType() != RetTy)
    return nullptr;
}
return RootVec;
5349}

5351/// Given operands for a ShuffleVectorInst, fold the result or return null.
5352Value *llvm::simplifyShuffleVectorInst(Value *Op0, Value *Op1,
                                     ArrayRef<int> Mask, Type *RetTy,
                                     const SimplifyQuery &Q) {
return ::simplifyShuffleVectorInst(Op0, Op1, Mask, RetTy, Q, RecursionLimit);
5356}

5358static Constant *foldConstant(Instruction::UnaryOps Opcode, Value *&Op,
                            const SimplifyQuery &Q) {
if (auto *C = dyn_cast<Constant>(Op))
  return ConstantFoldUnaryOpOperand(Opcode, C, Q.DL);
return nullptr;
5363}

5365/// Given the operand for an FNeg, see if we can fold the result.  If not, this
5366/// returns null.
5367static Value *simplifyFNegInst(Value *Op, FastMathFlags FMF,
                             const SimplifyQuery &Q, unsigned MaxRecurse) {
if (Constant *C = foldConstant(Instruction::FNeg, Op, Q))
  return C;

Value *X;
// fneg (fneg X) ==> X
if (match(Op, m_FNeg(m_Value(X))))
  return X;

return nullptr;
5378}

5380Value *llvm::simplifyFNegInst(Value *Op, FastMathFlags FMF,
                            const SimplifyQuery &Q) {
return ::simplifyFNegInst(Op, FMF, Q, RecursionLimit);
5383}

5385/// Try to propagate existing NaN values when possible. If not, replace the
5386/// constant or elements in the constant with a canonical NaN.
5387static Constant *propagateNaN(Constant *In) {
Type *Ty = In->getType();
if (auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
  unsigned NumElts = VecTy->getNumElements();
  SmallVector<Constant *, 32> NewC(NumElts);
  for (unsigned i = 0; i != NumElts; ++i) {
    Constant *EltC = In->getAggregateElement(i);
    // Poison elements propagate. NaN propagates except signaling is quieted.
    // Replace unknown or undef elements with canonical NaN.
    if (EltC && isa<PoisonValue>(EltC))
      NewC[i] = EltC;
    else if (EltC && EltC->isNaN())
      NewC[i] = ConstantFP::get(
          EltC->getType(), cast<ConstantFP>(EltC)->getValue().makeQuiet());
    else
      NewC[i] = ConstantFP::getNaN(VecTy->getElementType());
  }
  return ConstantVector::get(NewC);
}

// If it is not a fixed vector, but not a simple NaN either, return a
// canonical NaN.
if (!In->isNaN())
  return ConstantFP::getNaN(Ty);

// Propagate an existing QNaN constant. If it is an SNaN, make it quiet, but
// preserve the sign/payload.
return ConstantFP::get(Ty, cast<ConstantFP>(In)->getValue().makeQuiet());
5415}

5417/// Perform folds that are common to any floating-point operation. This implies
5418/// transforms based on poison/undef/NaN because the operation itself makes no
5419/// difference to the result.
5420static Constant *simplifyFPOp(ArrayRef<Value *> Ops, FastMathFlags FMF,
                            const SimplifyQuery &Q,
                            fp::ExceptionBehavior ExBehavior,
                            RoundingMode Rounding) {
// Poison is independent of anything else. It always propagates from an
// operand to a math result.
if (any_of(Ops, [](Value *V) { return match(V, m_Poison()); }))
  return PoisonValue::get(Ops[0]->getType());

for (Value *V : Ops) {
  bool IsNan = match(V, m_NaN());
  bool IsInf = match(V, m_Inf());
  bool IsUndef = Q.isUndefValue(V);

  // If this operation has 'nnan' or 'ninf' and at least 1 disallowed operand
  // (an undef operand can be chosen to be Nan/Inf), then the result of
  // this operation is poison.
  if (FMF.noNaNs() && (IsNan || IsUndef))
    return PoisonValue::get(V->getType());
  if (FMF.noInfs() && (IsInf || IsUndef))
    return PoisonValue::get(V->getType());

  if (isDefaultFPEnvironment(ExBehavior, Rounding)) {
    // Undef does not propagate because undef means that all bits can take on
    // any value. If this is undef * NaN for example, then the result values
    // (at least the exponent bits) are limited. Assume the undef is a
    // canonical NaN and propagate that.
    if (IsUndef)
      return ConstantFP::getNaN(V->getType());
    if (IsNan)
      return propagateNaN(cast<Constant>(V));
  } else if (ExBehavior != fp::ebStrict) {
    if (IsNan)
      return propagateNaN(cast<Constant>(V));
  }
}
return nullptr;
5457}

5459/// Given operands for an FAdd, see if we can fold the result.  If not, this
5460/// returns null.
5461static Value *
5462simplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
               const SimplifyQuery &Q, unsigned MaxRecurse,
               fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
               RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
if (isDefaultFPEnvironment(ExBehavior, Rounding))
  if (Constant *C = foldOrCommuteConstant(Instruction::FAdd, Op0, Op1, Q))
    return C;

if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
  return C;

// fadd X, -0 ==> X
// With strict/constrained FP, we have these possible edge cases that do
// not simplify to Op0:
// fadd SNaN, -0.0 --> QNaN
// fadd +0.0, -0.0 --> -0.0 (but only with round toward negative)
if (canIgnoreSNaN(ExBehavior, FMF) &&
    (!canRoundingModeBe(Rounding, RoundingMode::TowardNegative) ||
     FMF.noSignedZeros()))
  if (match(Op1, m_NegZeroFP()))
    return Op0;

// fadd X, 0 ==> X, when we know X is not -0
if (canIgnoreSNaN(ExBehavior, FMF))
  if (match(Op1, m_PosZeroFP()) &&
      (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI)))
    return Op0;

if (!isDefaultFPEnvironment(ExBehavior, Rounding))
  return nullptr;

if (FMF.noNaNs()) {
  // With nnan: X + {+/-}Inf --> {+/-}Inf
  if (match(Op1, m_Inf()))
    return Op1;

  // With nnan: -X + X --> 0.0 (and commuted variant)
  // We don't have to explicitly exclude infinities (ninf): INF + -INF == NaN.
  // Negative zeros are allowed because we always end up with positive zero:
  // X = -0.0: (-0.0 - (-0.0)) + (-0.0) == ( 0.0) + (-0.0) == 0.0
  // X = -0.0: ( 0.0 - (-0.0)) + (-0.0) == ( 0.0) + (-0.0) == 0.0
  // X =  0.0: (-0.0 - ( 0.0)) + ( 0.0) == (-0.0) + ( 0.0) == 0.0
  // X =  0.0: ( 0.0 - ( 0.0)) + ( 0.0) == ( 0.0) + ( 0.0) == 0.0
  if (match(Op0, m_FSub(m_AnyZeroFP(), m_Specific(Op1))) ||
      match(Op1, m_FSub(m_AnyZeroFP(), m_Specific(Op0))))
    return ConstantFP::getNullValue(Op0->getType());

  if (match(Op0, m_FNeg(m_Specific(Op1))) ||
      match(Op1, m_FNeg(m_Specific(Op0))))
    return ConstantFP::getNullValue(Op0->getType());
}

// (X - Y) + Y --> X
// Y + (X - Y) --> X
Value *X;
if (FMF.noSignedZeros() && FMF.allowReassoc() &&
    (match(Op0, m_FSub(m_Value(X), m_Specific(Op1))) ||
     match(Op1, m_FSub(m_Value(X), m_Specific(Op0)))))
  return X;

return nullptr;
5523}

5525/// Given operands for an FSub, see if we can fold the result.  If not, this
5526/// returns null.
5527static Value *
5528simplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
               const SimplifyQuery &Q, unsigned MaxRecurse,
               fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
               RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
if (isDefaultFPEnvironment(ExBehavior, Rounding))
  if (Constant *C = foldOrCommuteConstant(Instruction::FSub, Op0, Op1, Q))
    return C;

if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
  return C;

// fsub X, +0 ==> X
if (canIgnoreSNaN(ExBehavior, FMF) &&
    (!canRoundingModeBe(Rounding, RoundingMode::TowardNegative) ||
     FMF.noSignedZeros()))
  if (match(Op1, m_PosZeroFP()))
    return Op0;

// fsub X, -0 ==> X, when we know X is not -0
if (canIgnoreSNaN(ExBehavior, FMF))
  if (match(Op1, m_NegZeroFP()) &&
      (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI)))
    return Op0;

// fsub -0.0, (fsub -0.0, X) ==> X
// fsub -0.0, (fneg X) ==> X
Value *X;
if (canIgnoreSNaN(ExBehavior, FMF))
  if (match(Op0, m_NegZeroFP()) && match(Op1, m_FNeg(m_Value(X))))
    return X;

// fsub 0.0, (fsub 0.0, X) ==> X if signed zeros are ignored.
// fsub 0.0, (fneg X) ==> X if signed zeros are ignored.
if (canIgnoreSNaN(ExBehavior, FMF))
  if (FMF.noSignedZeros() && match(Op0, m_AnyZeroFP()) &&
      (match(Op1, m_FSub(m_AnyZeroFP(), m_Value(X))) ||
       match(Op1, m_FNeg(m_Value(X)))))
    return X;

if (!isDefaultFPEnvironment(ExBehavior, Rounding))
  return nullptr;

if (FMF.noNaNs()) {
  // fsub nnan x, x ==> 0.0
  if (Op0 == Op1)
    return Constant::getNullValue(Op0->getType());

  // With nnan: {+/-}Inf - X --> {+/-}Inf
  if (match(Op0, m_Inf()))
    return Op0;

  // With nnan: X - {+/-}Inf --> {-/+}Inf
  if (match(Op1, m_Inf()))
    return foldConstant(Instruction::FNeg, Op1, Q);
}

// Y - (Y - X) --> X
// (X + Y) - Y --> X
if (FMF.noSignedZeros() && FMF.allowReassoc() &&
    (match(Op1, m_FSub(m_Specific(Op0), m_Value(X))) ||
     match(Op0, m_c_FAdd(m_Specific(Op1), m_Value(X)))))
  return X;

return nullptr;
5592}

5594static Value *simplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
                            const SimplifyQuery &Q, unsigned MaxRecurse,
                            fp::ExceptionBehavior ExBehavior,
                            RoundingMode Rounding) {
if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
  return C;

if (!isDefaultFPEnvironment(ExBehavior, Rounding))
  return nullptr;

// Canonicalize special constants as operand 1.
if (match(Op0, m_FPOne()) || match(Op0, m_AnyZeroFP()))
  std::swap(Op0, Op1);

// X * 1.0 --> X
if (match(Op1, m_FPOne()))
  return Op0;

if (match(Op1, m_AnyZeroFP())) {
  // X * 0.0 --> 0.0 (with nnan and nsz)
  if (FMF.noNaNs() && FMF.noSignedZeros())
    return ConstantFP::getNullValue(Op0->getType());

  // +normal number * (-)0.0 --> (-)0.0
  if (isKnownNeverInfinity(Op0, Q.TLI) && isKnownNeverNaN(Op0, Q.TLI) &&
      SignBitMustBeZero(Op0, Q.TLI))
    return Op1;
}

// sqrt(X) * sqrt(X) --> X, if we can:
// 1. Remove the intermediate rounding (reassociate).
// 2. Ignore non-zero negative numbers because sqrt would produce NAN.
// 3. Ignore -0.0 because sqrt(-0.0) == -0.0, but -0.0 * -0.0 == 0.0.
Value *X;
if (Op0 == Op1 && match(Op0, m_Sqrt(m_Value(X))) && FMF.allowReassoc() &&
    FMF.noNaNs() && FMF.noSignedZeros())
  return X;

return nullptr;
5633}

5635/// Given the operands for an FMul, see if we can fold the result
5636static Value *
5637simplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
               const SimplifyQuery &Q, unsigned MaxRecurse,
               fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
               RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
if (isDefaultFPEnvironment(ExBehavior, Rounding))
  if (Constant *C = foldOrCommuteConstant(Instruction::FMul, Op0, Op1, Q))
    return C;

// Now apply simplifications that do not require rounding.
return simplifyFMAFMul(Op0, Op1, FMF, Q, MaxRecurse, ExBehavior, Rounding);
5647}

5649Value *llvm::simplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                            const SimplifyQuery &Q,
                            fp::ExceptionBehavior ExBehavior,
                            RoundingMode Rounding) {
return ::simplifyFAddInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
                          Rounding);
5655}

5657Value *llvm::simplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                            const SimplifyQuery &Q,
                            fp::ExceptionBehavior ExBehavior,
                            RoundingMode Rounding) {
return ::simplifyFSubInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
                          Rounding);
5663}

5665Value *llvm::simplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                            const SimplifyQuery &Q,
                            fp::ExceptionBehavior ExBehavior,
                            RoundingMode Rounding) {
return ::simplifyFMulInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
                          Rounding);
5671}

5673Value *llvm::simplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
                           const SimplifyQuery &Q,
                           fp::ExceptionBehavior ExBehavior,
                           RoundingMode Rounding) {
return ::simplifyFMAFMul(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
                         Rounding);
5679}

5681static Value *
5682simplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
               const SimplifyQuery &Q, unsigned,
               fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
               RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
if (isDefaultFPEnvironment(ExBehavior, Rounding))
  if (Constant *C = foldOrCommuteConstant(Instruction::FDiv, Op0, Op1, Q))
    return C;

if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
  return C;

if (!isDefaultFPEnvironment(ExBehavior, Rounding))
  return nullptr;

// X / 1.0 -> X
if (match(Op1, m_FPOne()))
  return Op0;

// 0 / X -> 0
// Requires that NaNs are off (X could be zero) and signed zeroes are
// ignored (X could be positive or negative, so the output sign is unknown).
if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZeroFP()))
  return ConstantFP::getNullValue(Op0->getType());

if (FMF.noNaNs()) {
  // X / X -> 1.0 is legal when NaNs are ignored.
  // We can ignore infinities because INF/INF is NaN.
  if (Op0 == Op1)
    return ConstantFP::get(Op0->getType(), 1.0);

  // (X * Y) / Y --> X if we can reassociate to the above form.
  Value *X;
  if (FMF.allowReassoc() && match(Op0, m_c_FMul(m_Value(X), m_Specific(Op1))))
    return X;

  // -X /  X -> -1.0 and
  //  X / -X -> -1.0 are legal when NaNs are ignored.
  // We can ignore signed zeros because +-0.0/+-0.0 is NaN and ignored.
  if (match(Op0, m_FNegNSZ(m_Specific(Op1))) ||
      match(Op1, m_FNegNSZ(m_Specific(Op0))))
    return ConstantFP::get(Op0->getType(), -1.0);

  // nnan ninf X / [-]0.0 -> poison
  if (FMF.noInfs() && match(Op1, m_AnyZeroFP()))
    return PoisonValue::get(Op1->getType());
}

return nullptr;
5730}

5732Value *llvm::simplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                            const SimplifyQuery &Q,
                            fp::ExceptionBehavior ExBehavior,
                            RoundingMode Rounding) {
return ::simplifyFDivInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
                          Rounding);
5738}

5740static Value *
5741simplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
               const SimplifyQuery &Q, unsigned,
               fp::ExceptionBehavior ExBehavior = fp::ebIgnore,
               RoundingMode Rounding = RoundingMode::NearestTiesToEven) {
if (isDefaultFPEnvironment(ExBehavior, Rounding))
  if (Constant *C = foldOrCommuteConstant(Instruction::FRem, Op0, Op1, Q))
    return C;

if (Constant *C = simplifyFPOp({Op0, Op1}, FMF, Q, ExBehavior, Rounding))
  return C;

if (!isDefaultFPEnvironment(ExBehavior, Rounding))
  return nullptr;

// Unlike fdiv, the result of frem always matches the sign of the dividend.
// The constant match may include undef elements in a vector, so return a full
// zero constant as the result.
if (FMF.noNaNs()) {
  // +0 % X -> 0
  if (match(Op0, m_PosZeroFP()))
    return ConstantFP::getNullValue(Op0->getType());
  // -0 % X -> -0
  if (match(Op0, m_NegZeroFP()))
    return ConstantFP::getNegativeZero(Op0->getType());
}

return nullptr;
5768}

5770Value *llvm::simplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                            const SimplifyQuery &Q,
                            fp::ExceptionBehavior ExBehavior,
                            RoundingMode Rounding) {
return ::simplifyFRemInst(Op0, Op1, FMF, Q, RecursionLimit, ExBehavior,
                          Rounding);
5776}

5778//=== Helper functions for higher up the class hierarchy.

5780/// Given the operand for a UnaryOperator, see if we can fold the result.
5781/// If not, this returns null.
5782static Value *simplifyUnOp(unsigned Opcode, Value *Op, const SimplifyQuery &Q,
                         unsigned MaxRecurse) {
switch (Opcode) {
case Instruction::FNeg:
  return simplifyFNegInst(Op, FastMathFlags(), Q, MaxRecurse);
default:
  llvm_unreachable("Unexpected opcode")::llvm::llvm_unreachable_internal("Unexpected opcode", "llvm/lib/Analysis/InstructionSimplify.cpp"
, 5788);
}
5790}

5792/// Given the operand for a UnaryOperator, see if we can fold the result.
5793/// If not, this returns null.
5794/// Try to use FastMathFlags when folding the result.
5795static Value *simplifyFPUnOp(unsigned Opcode, Value *Op,
                           const FastMathFlags &FMF, const SimplifyQuery &Q,
                           unsigned MaxRecurse) {
switch (Opcode) {
case Instruction::FNeg:
  return simplifyFNegInst(Op, FMF, Q, MaxRecurse);
default:
  return simplifyUnOp(Opcode, Op, Q, MaxRecurse);
}
5804}

5806Value *llvm::simplifyUnOp(unsigned Opcode, Value *Op, const SimplifyQuery &Q) {
return ::simplifyUnOp(Opcode, Op, Q, RecursionLimit);
5808}

5810Value *llvm::simplifyUnOp(unsigned Opcode, Value *Op, FastMathFlags FMF,
                        const SimplifyQuery &Q) {
return ::simplifyFPUnOp(Opcode, Op, FMF, Q, RecursionLimit);
5813}

5815/// Given operands for a BinaryOperator, see if we can fold the result.
5816/// If not, this returns null.
5817static Value *simplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                          const SimplifyQuery &Q, unsigned MaxRecurse) {
switch (Opcode) {
case Instruction::Add:
  return simplifyAddInst(LHS, RHS, /* IsNSW */ false, /* IsNUW */ false, Q,
                         MaxRecurse);
case Instruction::Sub:
  return simplifySubInst(LHS, RHS,  /* IsNSW */ false, /* IsNUW */ false, Q,
                         MaxRecurse);
case Instruction::Mul:
  return simplifyMulInst(LHS, RHS, /* IsNSW */ false, /* IsNUW */ false, Q,
                         MaxRecurse);
case Instruction::SDiv:
  return simplifySDivInst(LHS, RHS, /* IsExact */ false, Q, MaxRecurse);
case Instruction::UDiv:
  return simplifyUDivInst(LHS, RHS, /* IsExact */ false, Q, MaxRecurse);
case Instruction::SRem:
  return simplifySRemInst(LHS, RHS, Q, MaxRecurse);
case Instruction::URem:
  return simplifyURemInst(LHS, RHS, Q, MaxRecurse);
case Instruction::Shl:
  return simplifyShlInst(LHS, RHS, /* IsNSW */ false, /* IsNUW */ false, Q,
                         MaxRecurse);
case Instruction::LShr:
  return simplifyLShrInst(LHS, RHS, /* IsExact */ false, Q, MaxRecurse);
case Instruction::AShr:
  return simplifyAShrInst(LHS, RHS, /* IsExact */ false, Q, MaxRecurse);
case Instruction::And:
  return simplifyAndInst(LHS, RHS, Q, MaxRecurse);
case Instruction::Or:
  return simplifyOrInst(LHS, RHS, Q, MaxRecurse);
case Instruction::Xor:
  return simplifyXorInst(LHS, RHS, Q, MaxRecurse);
case Instruction::FAdd:
  return simplifyFAddInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse);
case Instruction::FSub:
  return simplifyFSubInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse);
case Instruction::FMul:
  return simplifyFMulInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse);
case Instruction::FDiv:
  return simplifyFDivInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse);
case Instruction::FRem:
  return simplifyFRemInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse);
default:
  llvm_unreachable("Unexpected opcode")::llvm::llvm_unreachable_internal("Unexpected opcode", "llvm/lib/Analysis/InstructionSimplify.cpp"
, 5861);
}
5863}

5865/// Given operands for a BinaryOperator, see if we can fold the result.
5866/// If not, this returns null.
5867/// Try to use FastMathFlags when folding the result.
5868static Value *simplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                          const FastMathFlags &FMF, const SimplifyQuery &Q,
                          unsigned MaxRecurse) {
switch (Opcode) {
case Instruction::FAdd:
  return simplifyFAddInst(LHS, RHS, FMF, Q, MaxRecurse);
case Instruction::FSub:
  return simplifyFSubInst(LHS, RHS, FMF, Q, MaxRecurse);
case Instruction::FMul:
  return simplifyFMulInst(LHS, RHS, FMF, Q, MaxRecurse);
case Instruction::FDiv:
  return simplifyFDivInst(LHS, RHS, FMF, Q, MaxRecurse);
default:
  return simplifyBinOp(Opcode, LHS, RHS, Q, MaxRecurse);
}
5883}

5885Value *llvm::simplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                         const SimplifyQuery &Q) {
return ::simplifyBinOp(Opcode, LHS, RHS, Q, RecursionLimit);
5888}

5890Value *llvm::simplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                         FastMathFlags FMF, const SimplifyQuery &Q) {
return ::simplifyBinOp(Opcode, LHS, RHS, FMF, Q, RecursionLimit);
5893}

5895/// Given operands for a CmpInst, see if we can fold the result.
5896static Value *simplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                            const SimplifyQuery &Q, unsigned MaxRecurse) {
if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate))
  return simplifyICmpInst(Predicate, LHS, RHS, Q, MaxRecurse);
return simplifyFCmpInst(Predicate, LHS, RHS, FastMathFlags(), Q, MaxRecurse);
5901}

5903Value *llvm::simplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                           const SimplifyQuery &Q) {
return ::simplifyCmpInst(Predicate, LHS, RHS, Q, RecursionLimit);
5906}

5908static bool isIdempotent(Intrinsic::ID ID) {
switch (ID) {
default:
  return false;

// Unary idempotent: f(f(x)) = f(x)
case Intrinsic::fabs:
case Intrinsic::floor:
case Intrinsic::ceil:
case Intrinsic::trunc:
case Intrinsic::rint:
case Intrinsic::nearbyint:
case Intrinsic::round:
case Intrinsic::roundeven:
case Intrinsic::canonicalize:
case Intrinsic::arithmetic_fence:
  return true;
}
5926}

5928/// Return true if the intrinsic rounds a floating-point value to an integral
5929/// floating-point value (not an integer type).
5930static bool removesFPFraction(Intrinsic::ID ID) {
switch (ID) {
default:
  return false;

case Intrinsic::floor:
case Intrinsic::ceil:
case Intrinsic::trunc:
case Intrinsic::rint:
case Intrinsic::nearbyint:
case Intrinsic::round:
case Intrinsic::roundeven:
  return true;
}
5944}

5946static Value *simplifyRelativeLoad(Constant *Ptr, Constant *Offset,
                                 const DataLayout &DL) {
GlobalValue *PtrSym;
APInt PtrOffset;
if (!IsConstantOffsetFromGlobal(Ptr, PtrSym, PtrOffset, DL))
  return nullptr;

Type *Int8PtrTy = Type::getInt8PtrTy(Ptr->getContext());
Type *Int32Ty = Type::getInt32Ty(Ptr->getContext());
Type *Int32PtrTy = Int32Ty->getPointerTo();
Type *Int64Ty = Type::getInt64Ty(Ptr->getContext());

auto *OffsetConstInt = dyn_cast<ConstantInt>(Offset);
if (!OffsetConstInt || OffsetConstInt->getType()->getBitWidth() > 64)
  return nullptr;

uint64_t OffsetInt = OffsetConstInt->getSExtValue();
if (OffsetInt % 4 != 0)
  return nullptr;

Constant *C = ConstantExpr::getGetElementPtr(
    Int32Ty, ConstantExpr::getBitCast(Ptr, Int32PtrTy),
    ConstantInt::get(Int64Ty, OffsetInt / 4));
Constant *Loaded = ConstantFoldLoadFromConstPtr(C, Int32Ty, DL);
if (!Loaded)
  return nullptr;

auto *LoadedCE = dyn_cast<ConstantExpr>(Loaded);
if (!LoadedCE)
  return nullptr;

if (LoadedCE->getOpcode() == Instruction::Trunc) {
  LoadedCE = dyn_cast<ConstantExpr>(LoadedCE->getOperand(0));
  if (!LoadedCE)
    return nullptr;
}

if (LoadedCE->getOpcode() != Instruction::Sub)
  return nullptr;

auto *LoadedLHS = dyn_cast<ConstantExpr>(LoadedCE->getOperand(0));
if (!LoadedLHS || LoadedLHS->getOpcode() != Instruction::PtrToInt)
  return nullptr;
auto *LoadedLHSPtr = LoadedLHS->getOperand(0);

Constant *LoadedRHS = LoadedCE->getOperand(1);
GlobalValue *LoadedRHSSym;
APInt LoadedRHSOffset;
if (!IsConstantOffsetFromGlobal(LoadedRHS, LoadedRHSSym, LoadedRHSOffset,
                                DL) ||
    PtrSym != LoadedRHSSym || PtrOffset != LoadedRHSOffset)
  return nullptr;

return ConstantExpr::getBitCast(LoadedLHSPtr, Int8PtrTy);
6000}

6002static Value *simplifyUnaryIntrinsic(Function *F, Value *Op0,
                                   const SimplifyQuery &Q) {
// Idempotent functions return the same result when called repeatedly.
Intrinsic::ID IID = F->getIntrinsicID();
if (isIdempotent(IID))
  if (auto *II = dyn_cast<IntrinsicInst>(Op0))
    if (II->getIntrinsicID() == IID)
      return II;

if (removesFPFraction(IID)) {
  // Converting from int or calling a rounding function always results in a
  // finite integral number or infinity. For those inputs, rounding functions
  // always return the same value, so the (2nd) rounding is eliminated. Ex:
  // floor (sitofp x) -> sitofp x
  // round (ceil x) -> ceil x
  auto *II = dyn_cast<IntrinsicInst>(Op0);
  if ((II && removesFPFraction(II->getIntrinsicID())) ||
      match(Op0, m_SIToFP(m_Value())) || match(Op0, m_UIToFP(m_Value())))
    return Op0;
}

Value *X;
switch (IID) {
case Intrinsic::fabs:
  if (SignBitMustBeZero(Op0, Q.TLI))
    return Op0;
  break;
case Intrinsic::bswap:
  // bswap(bswap(x)) -> x
  if (match(Op0, m_BSwap(m_Value(X))))
    return X;
  break;
case Intrinsic::bitreverse:
  // bitreverse(bitreverse(x)) -> x
  if (match(Op0, m_BitReverse(m_Value(X))))
    return X;
  break;
case Intrinsic::ctpop: {
  // ctpop(X) -> 1 iff X is non-zero power of 2.
  if (isKnownToBeAPowerOfTwo(Op0, Q.DL, /*OrZero*/ false, 0, Q.AC, Q.CxtI,
                             Q.DT))
    return ConstantInt::get(Op0->getType(), 1);
  // If everything but the lowest bit is zero, that bit is the pop-count. Ex:
  // ctpop(and X, 1) --> and X, 1
  unsigned BitWidth = Op0->getType()->getScalarSizeInBits();
  if (MaskedValueIsZero(Op0, APInt::getHighBitsSet(BitWidth, BitWidth - 1),
                        Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
    return Op0;
  break;
}
case Intrinsic::exp:
  // exp(log(x)) -> x
  if (Q.CxtI->hasAllowReassoc() &&
      match(Op0, m_Intrinsic<Intrinsic::log>(m_Value(X))))
    return X;
  break;
case Intrinsic::exp2:
  // exp2(log2(x)) -> x
  if (Q.CxtI->hasAllowReassoc() &&
      match(Op0, m_Intrinsic<Intrinsic::log2>(m_Value(X))))
    return X;
  break;
case Intrinsic::log:
  // log(exp(x)) -> x
  if (Q.CxtI->hasAllowReassoc() &&
      match(Op0, m_Intrinsic<Intrinsic::exp>(m_Value(X))))
    return X;
  break;
case Intrinsic::log2:
  // log2(exp2(x)) -> x
  if (Q.CxtI->hasAllowReassoc() &&
      (match(Op0, m_Intrinsic<Intrinsic::exp2>(m_Value(X))) ||
       match(Op0,
             m_Intrinsic<Intrinsic::pow>(m_SpecificFP(2.0), m_Value(X)))))
    return X;
  break;
case Intrinsic::log10:
  // log10(pow(10.0, x)) -> x
  if (Q.CxtI->hasAllowReassoc() &&
      match(Op0, m_Intrinsic<Intrinsic::pow>(m_SpecificFP(10.0), m_Value(X))))
    return X;
  break;
case Intrinsic::experimental_vector_reverse:
  // experimental.vector.reverse(experimental.vector.reverse(x)) -> x
  if (match(Op0, m_VecReverse(m_Value(X))))
    return X;
  // experimental.vector.reverse(splat(X)) -> splat(X)
  if (isSplatValue(Op0))
    return Op0;
  break;
default:
  break;
}

return nullptr;
6097}

6099/// Given a min/max intrinsic, see if it can be removed based on having an
6100/// operand that is another min/max intrinsic with shared operand(s). The caller
6101/// is expected to swap the operand arguments to handle commutation.
6102static Value *foldMinMaxSharedOp(Intrinsic::ID IID, Value *Op0, Value *Op1) {
Value *X, *Y;
if (!match(Op0, m_MaxOrMin(m_Value(X), m_Value(Y))))
  return nullptr;

auto *MM0 = dyn_cast<IntrinsicInst>(Op0);
if (!MM0)
  return nullptr;
Intrinsic::ID IID0 = MM0->getIntrinsicID();

if (Op1 == X || Op1 == Y ||
    match(Op1, m_c_MaxOrMin(m_Specific(X), m_Specific(Y)))) {
  // max (max X, Y), X --> max X, Y
  if (IID0 == IID)
    return MM0;
  // max (min X, Y), X --> X
  if (IID0 == getInverseMinMaxIntrinsic(IID))
    return Op1;
}
return nullptr;
6122}

6124static Value *simplifyBinaryIntrinsic(Function *F, Value *Op0, Value *Op1,
                                    const SimplifyQuery &Q) {
Intrinsic::ID IID = F->getIntrinsicID();
Type *ReturnType = F->getReturnType();
unsigned BitWidth = ReturnType->getScalarSizeInBits();
switch (IID) {
case Intrinsic::abs:
  // abs(abs(x)) -> abs(x). We don't need to worry about the nsw arg here.
  // It is always ok to pick the earlier abs. We'll just lose nsw if its only
  // on the outer abs.
  if (match(Op0, m_Intrinsic<Intrinsic::abs>(m_Value(), m_Value())))
    return Op0;
  break;

case Intrinsic::cttz: {
  Value *X;
  if (match(Op0, m_Shl(m_One(), m_Value(X))))
    return X;
  break;
}
case Intrinsic::ctlz: {
  Value *X;
  if (match(Op0, m_LShr(m_Negative(), m_Value(X))))
    return X;
  if (match(Op0, m_AShr(m_Negative(), m_Value())))
    return Constant::getNullValue(ReturnType);
  break;
}
case Intrinsic::smax:
case Intrinsic::smin:
case Intrinsic::umax:
case Intrinsic::umin: {
  // If the arguments are the same, this is a no-op.
  if (Op0 == Op1)
    return Op0;

  // Canonicalize immediate constant operand as Op1.
  if (match(Op0, m_ImmConstant()))
    std::swap(Op0, Op1);

  // Assume undef is the limit value.
  if (Q.isUndefValue(Op1))
    return ConstantInt::get(
        ReturnType, MinMaxIntrinsic::getSaturationPoint(IID, BitWidth));

  const APInt *C;
  if (match(Op1, m_APIntAllowUndef(C))) {
    // Clamp to limit value. For example:
    // umax(i8 %x, i8 255) --> 255
    if (*C == MinMaxIntrinsic::getSaturationPoint(IID, BitWidth))
      return ConstantInt::get(ReturnType, *C);

    // If the constant op is the opposite of the limit value, the other must
    // be larger/smaller or equal. For example:
    // umin(i8 %x, i8 255) --> %x
    if (*C == MinMaxIntrinsic::getSaturationPoint(
                  getInverseMinMaxIntrinsic(IID), BitWidth))
      return Op0;

    // Remove nested call if constant operands allow it. Example:
    // max (max X, 7), 5 -> max X, 7
    auto *MinMax0 = dyn_cast<IntrinsicInst>(Op0);
    if (MinMax0 && MinMax0->getIntrinsicID() == IID) {
      // TODO: loosen undef/splat restrictions for vector constants.
      Value *M00 = MinMax0->getOperand(0), *M01 = MinMax0->getOperand(1);
      const APInt *InnerC;
      if ((match(M00, m_APInt(InnerC)) || match(M01, m_APInt(InnerC))) &&
          ICmpInst::compare(*InnerC, *C,
                            ICmpInst::getNonStrictPredicate(
                                MinMaxIntrinsic::getPredicate(IID))))
        return Op0;
    }
  }

  if (Value *V = foldMinMaxSharedOp(IID, Op0, Op1))
    return V;
  if (Value *V = foldMinMaxSharedOp(IID, Op1, Op0))
    return V;

  ICmpInst::Predicate Pred =
      ICmpInst::getNonStrictPredicate(MinMaxIntrinsic::getPredicate(IID));
  if (isICmpTrue(Pred, Op0, Op1, Q.getWithoutUndef(), RecursionLimit))
    return Op0;
  if (isICmpTrue(Pred, Op1, Op0, Q.getWithoutUndef(), RecursionLimit))
    return Op1;

  break;
}
case Intrinsic::usub_with_overflow:
case Intrinsic::ssub_with_overflow:
  // X - X -> { 0, false }
  // X - undef -> { 0, false }
  // undef - X -> { 0, false }
  if (Op0 == Op1 || Q.isUndefValue(Op0) || Q.isUndefValue(Op1))
    return Constant::getNullValue(ReturnType);
  break;
case Intrinsic::uadd_with_overflow:
case Intrinsic::sadd_with_overflow:
  // X + undef -> { -1, false }
  // undef + x -> { -1, false }
  if (Q.isUndefValue(Op0) || Q.isUndefValue(Op1)) {
    return ConstantStruct::get(
        cast<StructType>(ReturnType),
        {Constant::getAllOnesValue(ReturnType->getStructElementType(0)),
         Constant::getNullValue(ReturnType->getStructElementType(1))});
  }
  break;
case Intrinsic::umul_with_overflow:
case Intrinsic::smul_with_overflow:
  // 0 * X -> { 0, false }
  // X * 0 -> { 0, false }
  if (match(Op0, m_Zero()) || match(Op1, m_Zero()))
    return Constant::getNullValue(ReturnType);
  // undef * X -> { 0, false }
  // X * undef -> { 0, false }
  if (Q.isUndefValue(Op0) || Q.isUndefValue(Op1))
    return Constant::getNullValue(ReturnType);
  break;
case Intrinsic::uadd_sat:
  // sat(MAX + X) -> MAX
  // sat(X + MAX) -> MAX
  if (match(Op0, m_AllOnes()) || match(Op1, m_AllOnes()))
    return Constant::getAllOnesValue(ReturnType);
  [[fallthrough]];
case Intrinsic::sadd_sat:
  // sat(X + undef) -> -1
  // sat(undef + X) -> -1
  // For unsigned: Assume undef is MAX, thus we saturate to MAX (-1).
  // For signed: Assume undef is ~X, in which case X + ~X = -1.
  if (Q.isUndefValue(Op0) || Q.isUndefValue(Op1))
    return Constant::getAllOnesValue(ReturnType);

  // X + 0 -> X
  if (match(Op1, m_Zero()))
    return Op0;
  // 0 + X -> X
  if (match(Op0, m_Zero()))
    return Op1;
  break;
case Intrinsic::usub_sat:
  // sat(0 - X) -> 0, sat(X - MAX) -> 0
  if (match(Op0, m_Zero()) || match(Op1, m_AllOnes()))
    return Constant::getNullValue(ReturnType);
  [[fallthrough]];
case Intrinsic::ssub_sat:
  // X - X -> 0, X - undef -> 0, undef - X -> 0
  if (Op0 == Op1 || Q.isUndefValue(Op0) || Q.isUndefValue(Op1))
    return Constant::getNullValue(ReturnType);
  // X - 0 -> X
  if (match(Op1, m_Zero()))
    return Op0;
  break;
case Intrinsic::load_relative:
  if (auto *C0 = dyn_cast<Constant>(Op0))
    if (auto *C1 = dyn_cast<Constant>(Op1))
      return simplifyRelativeLoad(C0, C1, Q.DL);
  break;
case Intrinsic::powi:
  if (auto *Power = dyn_cast<ConstantInt>(Op1)) {
    // powi(x, 0) -> 1.0
    if (Power->isZero())
      return ConstantFP::get(Op0->getType(), 1.0);
    // powi(x, 1) -> x
    if (Power->isOne())
      return Op0;
  }
  break;
case Intrinsic::copysign:
  // copysign X, X --> X
  if (Op0 == Op1)
    return Op0;
  // copysign -X, X --> X
  // copysign X, -X --> -X
  if (match(Op0, m_FNeg(m_Specific(Op1))) ||
      match(Op1, m_FNeg(m_Specific(Op0))))
    return Op1;
  break;
case Intrinsic::is_fpclass: {
  if (isa<PoisonValue>(Op0))
    return PoisonValue::get(ReturnType);

  uint64_t Mask = cast<ConstantInt>(Op1)->getZExtValue();
  // If all tests are made, it doesn't matter what the value is.
  if ((Mask & fcAllFlags) == fcAllFlags)
    return ConstantInt::get(ReturnType, true);
  if ((Mask & fcAllFlags) == 0)
    return ConstantInt::get(ReturnType, false);
  if (Q.isUndefValue(Op0))
    return UndefValue::get(ReturnType);
  break;
}
case Intrinsic::maxnum:
case Intrinsic::minnum:
case Intrinsic::maximum:
case Intrinsic::minimum: {
  // If the arguments are the same, this is a no-op.
  if (Op0 == Op1)
    return Op0;

  // Canonicalize constant operand as Op1.
  if (isa<Constant>(Op0))
    std::swap(Op0, Op1);

  // If an argument is undef, return the other argument.
  if (Q.isUndefValue(Op1))
    return Op0;

  bool PropagateNaN = IID == Intrinsic::minimum || IID == Intrinsic::maximum;
  bool IsMin = IID == Intrinsic::minimum || IID == Intrinsic::minnum;

  // minnum(X, nan) -> X
  // maxnum(X, nan) -> X
  // minimum(X, nan) -> nan
  // maximum(X, nan) -> nan
  if (match(Op1, m_NaN()))
    return PropagateNaN ? propagateNaN(cast<Constant>(Op1)) : Op0;

  // In the following folds, inf can be replaced with the largest finite
  // float, if the ninf flag is set.
  const APFloat *C;
  if (match(Op1, m_APFloat(C)) &&
      (C->isInfinity() || (Q.CxtI->hasNoInfs() && C->isLargest()))) {
    // minnum(X, -inf) -> -inf
    // maxnum(X, +inf) -> +inf
    // minimum(X, -inf) -> -inf if nnan
    // maximum(X, +inf) -> +inf if nnan
    if (C->isNegative() == IsMin && (!PropagateNaN || Q.CxtI->hasNoNaNs()))
      return ConstantFP::get(ReturnType, *C);

    // minnum(X, +inf) -> X if nnan
    // maxnum(X, -inf) -> X if nnan
    // minimum(X, +inf) -> X
    // maximum(X, -inf) -> X
    if (C->isNegative() != IsMin && (PropagateNaN || Q.CxtI->hasNoNaNs()))
      return Op0;
  }

  // Min/max of the same operation with common operand:
  // m(m(X, Y)), X --> m(X, Y) (4 commuted variants)
  if (auto *M0 = dyn_cast<IntrinsicInst>(Op0))
    if (M0->getIntrinsicID() == IID &&
        (M0->getOperand(0) == Op1 || M0->getOperand(1) == Op1))
      return Op0;
  if (auto *M1 = dyn_cast<IntrinsicInst>(Op1))
    if (M1->getIntrinsicID() == IID &&
        (M1->getOperand(0) == Op0 || M1->getOperand(1) == Op0))
      return Op1;

  break;
}
case Intrinsic::vector_extract: {
  Type *ReturnType = F->getReturnType();

  // (extract_vector (insert_vector _, X, 0), 0) -> X
  unsigned IdxN = cast<ConstantInt>(Op1)->getZExtValue();
  Value *X = nullptr;
  if (match(Op0, m_Intrinsic<Intrinsic::vector_insert>(m_Value(), m_Value(X),
                                                       m_Zero())) &&
      IdxN == 0 && X->getType() == ReturnType)
    return X;

  break;
}
default:
  break;
}

return nullptr;
6392}

6394static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) {

unsigned NumOperands = Call->arg_size();
Function *F = cast<Function>(Call->getCalledFunction());
Intrinsic::ID IID = F->getIntrinsicID();

// Most of the intrinsics with no operands have some kind of side effect.
// Don't simplify.
if (!NumOperands) {
5
←
Assuming 'NumOperands' is not equal to 0→
6
←
Taking false branch→
  switch (IID) {
  case Intrinsic::vscale: {
    // Call may not be inserted into the IR yet at point of calling simplify.
    if (!Call->getParent() || !Call->getParent()->getParent())
      return nullptr;
    auto Attr = Call->getFunction()->getFnAttribute(Attribute::VScaleRange);
    if (!Attr.isValid())
      return nullptr;
    unsigned VScaleMin = Attr.getVScaleRangeMin();
    std::optional<unsigned> VScaleMax = Attr.getVScaleRangeMax();
    if (VScaleMax && VScaleMin == VScaleMax)
      return ConstantInt::get(F->getReturnType(), VScaleMin);
    return nullptr;
  }
  default:
    return nullptr;
  }
}

if (NumOperands == 1)
7
←
Assuming 'NumOperands' is not equal to 1→
8
←
Taking false branch→
  return simplifyUnaryIntrinsic(F, Call->getArgOperand(0), Q);

if (NumOperands == 2)
9
←
Assuming 'NumOperands' is not equal to 2→
10
←
Taking false branch→
  return simplifyBinaryIntrinsic(F, Call->getArgOperand(0),
                                 Call->getArgOperand(1), Q);

// Handle intrinsics with 3 or more arguments.
switch (IID) {
11
←
Control jumps to 'case vector_insert:'  at line 6522→
case Intrinsic::masked_load:
case Intrinsic::masked_gather: {
  Value *MaskArg = Call->getArgOperand(2);
  Value *PassthruArg = Call->getArgOperand(3);
  // If the mask is all zeros or undef, the "passthru" argument is the result.
  if (maskIsAllZeroOrUndef(MaskArg))
    return PassthruArg;
  return nullptr;
}
case Intrinsic::fshl:
case Intrinsic::fshr: {
  Value *Op0 = Call->getArgOperand(0), *Op1 = Call->getArgOperand(1),
        *ShAmtArg = Call->getArgOperand(2);

  // If both operands are undef, the result is undef.
  if (Q.isUndefValue(Op0) && Q.isUndefValue(Op1))
    return UndefValue::get(F->getReturnType());

  // If shift amount is undef, assume it is zero.
  if (Q.isUndefValue(ShAmtArg))
    return Call->getArgOperand(IID == Intrinsic::fshl ? 0 : 1);

  const APInt *ShAmtC;
  if (match(ShAmtArg, m_APInt(ShAmtC))) {
    // If there's effectively no shift, return the 1st arg or 2nd arg.
    APInt BitWidth = APInt(ShAmtC->getBitWidth(), ShAmtC->getBitWidth());
    if (ShAmtC->urem(BitWidth).isZero())
      return Call->getArgOperand(IID == Intrinsic::fshl ? 0 : 1);
  }

  // Rotating zero by anything is zero.
  if (match(Op0, m_Zero()) && match(Op1, m_Zero()))
    return ConstantInt::getNullValue(F->getReturnType());

  // Rotating -1 by anything is -1.
  if (match(Op0, m_AllOnes()) && match(Op1, m_AllOnes()))
    return ConstantInt::getAllOnesValue(F->getReturnType());

  return nullptr;
}
case Intrinsic::experimental_constrained_fma: {
  Value *Op0 = Call->getArgOperand(0);
  Value *Op1 = Call->getArgOperand(1);
  Value *Op2 = Call->getArgOperand(2);
  auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
  if (Value *V =
          simplifyFPOp({Op0, Op1, Op2}, {}, Q, *FPI->getExceptionBehavior(),
                       *FPI->getRoundingMode()))
    return V;
  return nullptr;
}
case Intrinsic::fma:
case Intrinsic::fmuladd: {
  Value *Op0 = Call->getArgOperand(0);
  Value *Op1 = Call->getArgOperand(1);
  Value *Op2 = Call->getArgOperand(2);
  if (Value *V = simplifyFPOp({Op0, Op1, Op2}, {}, Q, fp::ebIgnore,
                              RoundingMode::NearestTiesToEven))
    return V;
  return nullptr;
}
case Intrinsic::smul_fix:
case Intrinsic::smul_fix_sat: {
  Value *Op0 = Call->getArgOperand(0);
  Value *Op1 = Call->getArgOperand(1);
  Value *Op2 = Call->getArgOperand(2);
  Type *ReturnType = F->getReturnType();

  // Canonicalize constant operand as Op1 (ConstantFolding handles the case
  // when both Op0 and Op1 are constant so we do not care about that special
  // case here).
  if (isa<Constant>(Op0))
    std::swap(Op0, Op1);

  // X * 0 -> 0
  if (match(Op1, m_Zero()))
    return Constant::getNullValue(ReturnType);

  // X * undef -> 0
  if (Q.isUndefValue(Op1))
    return Constant::getNullValue(ReturnType);

  // X * (1 << Scale) -> X
  APInt ScaledOne =
      APInt::getOneBitSet(ReturnType->getScalarSizeInBits(),
                          cast<ConstantInt>(Op2)->getZExtValue());
  if (ScaledOne.isNonNegative() && match(Op1, m_SpecificInt(ScaledOne)))
    return Op0;

  return nullptr;
}
case Intrinsic::vector_insert: {
  Value *Vec = Call->getArgOperand(0);
  Value *SubVec = Call->getArgOperand(1);
  Value *Idx = Call->getArgOperand(2);
  Type *ReturnType = F->getReturnType();

  // (insert_vector Y, (extract_vector X, 0), 0) -> X
  // where: Y is X, or Y is undef
  unsigned IdxN = cast<ConstantInt>(Idx)->getZExtValue();
  Value *X = nullptr;
  if (match(SubVec,
29
←
Calling 'match<llvm::Value, llvm::PatternMatch::match_combine_and<llvm::PatternMatch::match_combine_and<llvm::PatternMatch::IntrinsicID_match, llvm::PatternMatch::Argument_match<llvm::PatternMatch::bind_ty<llvm::Value>>>, llvm::PatternMatch::Argument_match<llvm::PatternMatch::is_zero>>>'→
44
←
Returning from 'match<llvm::Value, llvm::PatternMatch::match_combine_and<llvm::PatternMatch::match_combine_and<llvm::PatternMatch::IntrinsicID_match, llvm::PatternMatch::Argument_match<llvm::PatternMatch::bind_ty<llvm::Value>>>, llvm::PatternMatch::Argument_match<llvm::PatternMatch::is_zero>>>'→
            m_Intrinsic<Intrinsic::vector_extract>(m_Value(X), m_Zero())) &&
12
←
Calling 'm_Value'→
16
←
Returning from 'm_Value'→
17
←
Calling 'm_Intrinsic<318U, llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::is_zero>'→
28
←
Returning from 'm_Intrinsic<318U, llvm::PatternMatch::bind_ty<llvm::Value>, llvm::PatternMatch::is_zero>'→
      (Q.isUndefValue(Vec) || Vec == X) && IdxN == 0 &&
45
←
Assuming 'Vec' is equal to 'X'→
46
←
Assuming 'IdxN' is equal to 0→
      X->getType() == ReturnType)
47
←
Called C++ object pointer is null
    return X;

  return nullptr;
}
case Intrinsic::experimental_constrained_fadd: {
  auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
  return simplifyFAddInst(
      FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(),
      Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode());
}
case Intrinsic::experimental_constrained_fsub: {
  auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
  return simplifyFSubInst(
      FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(),
      Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode());
}
case Intrinsic::experimental_constrained_fmul: {
  auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
  return simplifyFMulInst(
      FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(),
      Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode());
}
case Intrinsic::experimental_constrained_fdiv: {
  auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
  return simplifyFDivInst(
      FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(),
      Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode());
}
case Intrinsic::experimental_constrained_frem: {
  auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
  return simplifyFRemInst(
      FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(),
      Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode());
}
default:
  return nullptr;
}
6573}

6575static Value *tryConstantFoldCall(CallBase *Call, const SimplifyQuery &Q) {
auto *F = dyn_cast<Function>(Call->getCalledOperand());
if (!F || !canConstantFoldCallTo(Call, F))
  return nullptr;

SmallVector<Constant *, 4> ConstantArgs;
unsigned NumArgs = Call->arg_size();
ConstantArgs.reserve(NumArgs);
for (auto &Arg : Call->args()) {
  Constant *C = dyn_cast<Constant>(&Arg);
  if (!C) {
    if (isa<MetadataAsValue>(Arg.get()))
      continue;
    return nullptr;
  }
  ConstantArgs.push_back(C);
}

return ConstantFoldCall(Call, F, ConstantArgs, Q.TLI);
6594}

6596Value *llvm::simplifyCall(CallBase *Call, const SimplifyQuery &Q) {
// musttail calls can only be simplified if they are also DCEd.
// As we can't guarantee this here, don't simplify them.
if (Call->isMustTailCall())
  return nullptr;

// call undef -> poison
// call null -> poison
Value *Callee = Call->getCalledOperand();
if (isa<UndefValue>(Callee) || isa<ConstantPointerNull>(Callee))
  return PoisonValue::get(Call->getType());

if (Value *V = tryConstantFoldCall(Call, Q))
  return V;

auto *F = dyn_cast<Function>(Callee);
if (F && F->isIntrinsic())
  if (Value *Ret = simplifyIntrinsic(Call, Q))
    return Ret;

return nullptr;
6617}

6619Value *llvm::simplifyConstrainedFPCall(CallBase *Call, const SimplifyQuery &Q) {
assert(isa<ConstrainedFPIntrinsic>(Call))(static_cast <bool> (isa<ConstrainedFPIntrinsic>(
Call)) ? void (0) : __assert_fail ("isa<ConstrainedFPIntrinsic>(Call)"
, "llvm/lib/Analysis/InstructionSimplify.cpp", 6620, __extension__
 __PRETTY_FUNCTION__));
1
Assuming 'Call' is a 'class llvm::ConstrainedFPIntrinsic &'→
2
←
'?' condition is true→
if (Value *V2.1
'V' is null
1
'V' is null
 = tryConstantFoldCall(Call, Q))
3
←
Taking false branch→
  return V;
if (Value *Ret = simplifyIntrinsic(Call, Q))
4
←
Calling 'simplifyIntrinsic'→
  return Ret;
return nullptr;
6626}

6628/// Given operands for a Freeze, see if we can fold the result.
6629static Value *simplifyFreezeInst(Value *Op0, const SimplifyQuery &Q) {
// Use a utility function defined in ValueTracking.
if (llvm::isGuaranteedNotToBeUndefOrPoison(Op0, Q.AC, Q.CxtI, Q.DT))
  return Op0;
// We have room for improvement.
return nullptr;
6635}

6637Value *llvm::simplifyFreezeInst(Value *Op0, const SimplifyQuery &Q) {
return ::simplifyFreezeInst(Op0, Q);
6639}

6641Value *llvm::simplifyLoadInst(LoadInst *LI, Value *PtrOp,
                            const SimplifyQuery &Q) {
if (LI->isVolatile())
  return nullptr;

if (auto *PtrOpC = dyn_cast<Constant>(PtrOp))
  return ConstantFoldLoadFromConstPtr(PtrOpC, LI->getType(), Q.DL);

// We can only fold the load if it is from a constant global with definitive
// initializer. Skip expensive logic if this is not the case.
auto *GV = dyn_cast<GlobalVariable>(getUnderlyingObject(PtrOp));
if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())
  return nullptr;

// If GlobalVariable's initializer is uniform, then return the constant
// regardless of its offset.
if (Constant *C =
        ConstantFoldLoadFromUniformValue(GV->getInitializer(), LI->getType()))
  return C;

// Try to convert operand into a constant by stripping offsets while looking
// through invariant.group intrinsics.
APInt Offset(Q.DL.getIndexTypeSizeInBits(PtrOp->getType()), 0);
PtrOp = PtrOp->stripAndAccumulateConstantOffsets(
    Q.DL, Offset, /* AllowNonInbounts */ true,
    /* AllowInvariantGroup */ true);
if (PtrOp == GV) {
  // Index size may have changed due to address space casts.
  Offset = Offset.sextOrTrunc(Q.DL.getIndexTypeSizeInBits(PtrOp->getType()));
  return ConstantFoldLoadFromConstPtr(GV, LI->getType(), Offset, Q.DL);
}

return nullptr;
6674}

6676/// See if we can compute a simplified version of this instruction.
6677/// If not, this returns null.

6679static Value *simplifyInstructionWithOperands(Instruction *I,
                                            ArrayRef<Value *> NewOps,
                                            const SimplifyQuery &SQ,
                                            OptimizationRemarkEmitter *ORE) {
const SimplifyQuery Q = SQ.CxtI ? SQ : SQ.getWithInstruction(I);

switch (I->getOpcode()) {
default:
  if (llvm::all_of(NewOps, [](Value *V) { return isa<Constant>(V); })) {
    SmallVector<Constant *, 8> NewConstOps(NewOps.size());
    transform(NewOps, NewConstOps.begin(),
              [](Value *V) { return cast<Constant>(V); });
    return ConstantFoldInstOperands(I, NewConstOps, Q.DL, Q.TLI);
  }
  return nullptr;
case Instruction::FNeg:
  return simplifyFNegInst(NewOps[0], I->getFastMathFlags(), Q);
case Instruction::FAdd:
  return simplifyFAddInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
case Instruction::Add:
  return simplifyAddInst(NewOps[0], NewOps[1],
                         Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
                         Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q);
case Instruction::FSub:
  return simplifyFSubInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
case Instruction::Sub:
  return simplifySubInst(NewOps[0], NewOps[1],
                         Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
                         Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q);
case Instruction::FMul:
  return simplifyFMulInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
case Instruction::Mul:
  return simplifyMulInst(NewOps[0], NewOps[1],
                         Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
                         Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q);
case Instruction::SDiv:
  return simplifySDivInst(NewOps[0], NewOps[1],
                          Q.IIQ.isExact(cast<BinaryOperator>(I)), Q);
case Instruction::UDiv:
  return simplifyUDivInst(NewOps[0], NewOps[1],
                          Q.IIQ.isExact(cast<BinaryOperator>(I)), Q);
case Instruction::FDiv:
  return simplifyFDivInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
case Instruction::SRem:
  return simplifySRemInst(NewOps[0], NewOps[1], Q);
case Instruction::URem:
  return simplifyURemInst(NewOps[0], NewOps[1], Q);
case Instruction::FRem:
  return simplifyFRemInst(NewOps[0], NewOps[1], I->getFastMathFlags(), Q);
case Instruction::Shl:
  return simplifyShlInst(NewOps[0], NewOps[1],
                         Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),
                         Q.IIQ.hasNoUnsignedWrap(cast<BinaryOperator>(I)), Q);
case Instruction::LShr:
  return simplifyLShrInst(NewOps[0], NewOps[1],
                          Q.IIQ.isExact(cast<BinaryOperator>(I)), Q);
case Instruction::AShr:
  return simplifyAShrInst(NewOps[0], NewOps[1],
                          Q.IIQ.isExact(cast<BinaryOperator>(I)), Q);
case Instruction::And:
  return simplifyAndInst(NewOps[0], NewOps[1], Q);
case Instruction::Or:
  return simplifyOrInst(NewOps[0], NewOps[1], Q);
case Instruction::Xor:
  return simplifyXorInst(NewOps[0], NewOps[1], Q);
case Instruction::ICmp:
  return simplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), NewOps[0],
                          NewOps[1], Q);
case Instruction::FCmp:
  return simplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), NewOps[0],
                          NewOps[1], I->getFastMathFlags(), Q);
case Instruction::Select:
  return simplifySelectInst(NewOps[0], NewOps[1], NewOps[2], Q);
  break;
case Instruction::GetElementPtr: {
  auto *GEPI = cast<GetElementPtrInst>(I);
  return simplifyGEPInst(GEPI->getSourceElementType(), NewOps[0],
                         ArrayRef(NewOps).slice(1), GEPI->isInBounds(), Q);
}
case Instruction::InsertValue: {
  InsertValueInst *IV = cast<InsertValueInst>(I);
  return simplifyInsertValueInst(NewOps[0], NewOps[1], IV->getIndices(), Q);
}
case Instruction::InsertElement:
  return simplifyInsertElementInst(NewOps[0], NewOps[1], NewOps[2], Q);
case Instruction::ExtractValue: {
  auto *EVI = cast<ExtractValueInst>(I);
  return simplifyExtractValueInst(NewOps[0], EVI->getIndices(), Q);
}
case Instruction::ExtractElement:
  return simplifyExtractElementInst(NewOps[0], NewOps[1], Q);
case Instruction::ShuffleVector: {
  auto *SVI = cast<ShuffleVectorInst>(I);
  return simplifyShuffleVectorInst(NewOps[0], NewOps[1],
                                   SVI->getShuffleMask(), SVI->getType(), Q);
}
case Instruction::PHI:
  return simplifyPHINode(cast<PHINode>(I), NewOps, Q);
case Instruction::Call:
  // TODO: Use NewOps
  return simplifyCall(cast<CallInst>(I), Q);
case Instruction::Freeze:
  return llvm::simplifyFreezeInst(NewOps[0], Q);
6782#define HANDLE_CAST_INST(num, opc, clas) case Instruction::opc:
6783#include "llvm/IR/Instruction.def"
6784#undef HANDLE_CAST_INST
  return simplifyCastInst(I->getOpcode(), NewOps[0], I->getType(), Q);
case Instruction::Alloca:
  // No simplifications for Alloca and it can't be constant folded.
  return nullptr;
case Instruction::Load:
  return simplifyLoadInst(cast<LoadInst>(I), NewOps[0], Q);
}
6792}

6794Value *llvm::simplifyInstructionWithOperands(Instruction *I,
                                           ArrayRef<Value *> NewOps,
                                           const SimplifyQuery &SQ,
                                           OptimizationRemarkEmitter *ORE) {
assert(NewOps.size() == I->getNumOperands() &&(static_cast <bool> (NewOps.size() == I->getNumOperands
() && "Number of operands should match the instruction!"
) ? void (0) : __assert_fail ("NewOps.size() == I->getNumOperands() && \"Number of operands should match the instruction!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 6799, __extension__
 __PRETTY_FUNCTION__))
       "Number of operands should match the instruction!")(static_cast <bool> (NewOps.size() == I->getNumOperands
() && "Number of operands should match the instruction!"
) ? void (0) : __assert_fail ("NewOps.size() == I->getNumOperands() && \"Number of operands should match the instruction!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 6799, __extension__
 __PRETTY_FUNCTION__));
return ::simplifyInstructionWithOperands(I, NewOps, SQ, ORE);
6801}

6803Value *llvm::simplifyInstruction(Instruction *I, const SimplifyQuery &SQ,
                               OptimizationRemarkEmitter *ORE) {
SmallVector<Value *, 8> Ops(I->operands());
Value *Result = ::simplifyInstructionWithOperands(I, Ops, SQ, ORE);

/// If called on unreachable code, the instruction may simplify to itself.
/// Make life easier for users by detecting that case here, and returning a
/// safe value instead.
return Result == I ? UndefValue::get(I->getType()) : Result;
6812}

6814/// Implementation of recursive simplification through an instruction's
6815/// uses.
6816///
6817/// This is the common implementation of the recursive simplification routines.
6818/// If we have a pre-simplified value in 'SimpleV', that is forcibly used to
6819/// replace the instruction 'I'. Otherwise, we simply add 'I' to the list of
6820/// instructions to process and attempt to simplify it using
6821/// InstructionSimplify. Recursively visited users which could not be
6822/// simplified themselves are to the optional UnsimplifiedUsers set for
6823/// further processing by the caller.
6824///
6825/// This routine returns 'true' only when *it* simplifies something. The passed
6826/// in simplified value does not count toward this.
6827static bool replaceAndRecursivelySimplifyImpl(
  Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI,
  const DominatorTree *DT, AssumptionCache *AC,
  SmallSetVector<Instruction *, 8> *UnsimplifiedUsers = nullptr) {
bool Simplified = false;
SmallSetVector<Instruction *, 8> Worklist;
const DataLayout &DL = I->getModule()->getDataLayout();

// If we have an explicit value to collapse to, do that round of the
// simplification loop by hand initially.
if (SimpleV) {
  for (User *U : I->users())
    if (U != I)
      Worklist.insert(cast<Instruction>(U));

  // Replace the instruction with its simplified value.
  I->replaceAllUsesWith(SimpleV);

  // Gracefully handle edge cases where the instruction is not wired into any
  // parent block.
  if (I->getParent() && !I->isEHPad() && !I->isTerminator() &&
      !I->mayHaveSideEffects())
    I->eraseFromParent();
} else {
  Worklist.insert(I);
}

// Note that we must test the size on each iteration, the worklist can grow.
for (unsigned Idx = 0; Idx != Worklist.size(); ++Idx) {
  I = Worklist[Idx];

  // See if this instruction simplifies.
  SimpleV = simplifyInstruction(I, {DL, TLI, DT, AC});
  if (!SimpleV) {
    if (UnsimplifiedUsers)
      UnsimplifiedUsers->insert(I);
    continue;
  }

  Simplified = true;

  // Stash away all the uses of the old instruction so we can check them for
  // recursive simplifications after a RAUW. This is cheaper than checking all
  // uses of To on the recursive step in most cases.
  for (User *U : I->users())
    Worklist.insert(cast<Instruction>(U));

  // Replace the instruction with its simplified value.
  I->replaceAllUsesWith(SimpleV);

  // Gracefully handle edge cases where the instruction is not wired into any
  // parent block.
  if (I->getParent() && !I->isEHPad() && !I->isTerminator() &&
      !I->mayHaveSideEffects())
    I->eraseFromParent();
}
return Simplified;
6884}

6886bool llvm::replaceAndRecursivelySimplify(
  Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI,
  const DominatorTree *DT, AssumptionCache *AC,
  SmallSetVector<Instruction *, 8> *UnsimplifiedUsers) {
assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!")(static_cast <bool> (I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!"
) ? void (0) : __assert_fail ("I != SimpleV && \"replaceAndRecursivelySimplify(X,X) is not valid!\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 6890, __extension__
 __PRETTY_FUNCTION__));
assert(SimpleV && "Must provide a simplified value.")(static_cast <bool> (SimpleV && "Must provide a simplified value."
) ? void (0) : __assert_fail ("SimpleV && \"Must provide a simplified value.\""
, "llvm/lib/Analysis/InstructionSimplify.cpp", 6891, __extension__
 __PRETTY_FUNCTION__));
return replaceAndRecursivelySimplifyImpl(I, SimpleV, TLI, DT, AC,
                                         UnsimplifiedUsers);
6894}

6896namespace llvm {
6897const SimplifyQuery getBestSimplifyQuery(Pass &P, Function &F) {
auto *DTWP = P.getAnalysisIfAvailable<DominatorTreeWrapperPass>();
auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
auto *TLIWP = P.getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
auto *TLI = TLIWP ? &TLIWP->getTLI(F) : nullptr;
auto *ACWP = P.getAnalysisIfAvailable<AssumptionCacheTracker>();
auto *AC = ACWP ? &ACWP->getAssumptionCache(F) : nullptr;
return {F.getParent()->getDataLayout(), TLI, DT, AC};
6905}

6907const SimplifyQuery getBestSimplifyQuery(LoopStandardAnalysisResults &AR,
                                       const DataLayout &DL) {
return {DL, &AR.TLI, &AR.DT, &AR.AC};
6910}

6912template <class T, class... TArgs>
6913const SimplifyQuery getBestSimplifyQuery(AnalysisManager<T, TArgs...> &AM,
                                       Function &F) {
auto *DT = AM.template getCachedResult<DominatorTreeAnalysis>(F);
auto *TLI = AM.template getCachedResult<TargetLibraryAnalysis>(F);
auto *AC = AM.template getCachedResult<AssumptionAnalysis>(F);
return {F.getParent()->getDataLayout(), TLI, DT, AC};
6919}
6920template const SimplifyQuery getBestSimplifyQuery(AnalysisManager<Function> &,
                                                Function &);
6922} // namespace llvm

6924void InstSimplifyFolder::anchor() {}

←

/build/source/llvm/include/llvm/IR/PatternMatch.h

1//===- PatternMatch.h - Match on the LLVM IR --------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file provides a simple and efficient mechanism for performing general
10// tree-based pattern matches on the LLVM IR. The power of these routines is
11// that it allows you to write concise patterns that are expressive and easy to
12// understand. The other major advantage of this is that it allows you to
13// trivially capture/bind elements in the pattern to variables. For example,
14// you can do something like this:
15//
16//  Value *Exp = ...
17//  Value *X, *Y;  ConstantInt *C1, *C2;      // (X & C1) | (Y & C2)
18//  if (match(Exp, m_Or(m_And(m_Value(X), m_ConstantInt(C1)),
19//                      m_And(m_Value(Y), m_ConstantInt(C2))))) {
20//    ... Pattern is matched and variables are bound ...
21//  }
22//
23// This is primarily useful to things like the instruction combiner, but can
24// also be useful for static analysis tools or code generators.
25//
26//===----------------------------------------------------------------------===//
27 
28#ifndef LLVM_IR_PATTERNMATCH_H
29#define LLVM_IR_PATTERNMATCH_H
30 
31#include "llvm/ADT/APFloat.h"
32#include "llvm/ADT/APInt.h"
33#include "llvm/IR/Constant.h"
34#include "llvm/IR/Constants.h"
35#include "llvm/IR/DataLayout.h"
36#include "llvm/IR/InstrTypes.h"
37#include "llvm/IR/Instruction.h"
38#include "llvm/IR/Instructions.h"
39#include "llvm/IR/IntrinsicInst.h"
40#include "llvm/IR/Intrinsics.h"
41#include "llvm/IR/Operator.h"
42#include "llvm/IR/Value.h"
43#include "llvm/Support/Casting.h"
44#include <cstdint>
45 
46namespace llvm {
47namespace PatternMatch {
48 
49template <typename Val, typename Pattern> bool match(Val *V, const Pattern &P) {
50  return const_cast<Pattern &>(P).match(V);
30
←
Calling 'match_combine_and::match'→
43
←
Returning from 'match_combine_and::match'→
51}
52 
53template <typename Pattern> bool match(ArrayRef<int> Mask, const Pattern &P) {
54  return const_cast<Pattern &>(P).match(Mask);
55}
56 
57template <typename SubPattern_t> struct OneUse_match {
58  SubPattern_t SubPattern;
59 
60  OneUse_match(const SubPattern_t &SP) : SubPattern(SP) {}
61 
62  template <typename OpTy> bool match(OpTy *V) {
63    return V->hasOneUse() && SubPattern.match(V);
64  }
65};
66 
67template <typename T> inline OneUse_match<T> m_OneUse(const T &SubPattern) {
68  return SubPattern;
69}
70 
71template <typename Class> struct class_match {
72  template <typename ITy> bool match(ITy *V) { return isa<Class>(V); }
73};
74 
75/// Match an arbitrary value and ignore it.
76inline class_match<Value> m_Value() { return class_match<Value>(); }
77 
78/// Match an arbitrary unary operation and ignore it.
79inline class_match<UnaryOperator> m_UnOp() {
80  return class_match<UnaryOperator>();
81}
82 
83/// Match an arbitrary binary operation and ignore it.
84inline class_match<BinaryOperator> m_BinOp() {
85  return class_match<BinaryOperator>();
86}
87 
88/// Matches any compare instruction and ignore it.
89inline class_match<CmpInst> m_Cmp() { return class_match<CmpInst>(); }
90 
91struct undef_match {
92  static bool check(const Value *V) {
93    if (isa<UndefValue>(V))
94      return true;
95 
96    const auto *CA = dyn_cast<ConstantAggregate>(V);
97    if (!CA)
98      return false;
99 
100    SmallPtrSet<const ConstantAggregate *, 8> Seen;
101    SmallVector<const ConstantAggregate *, 8> Worklist;
102 
103    // Either UndefValue, PoisonValue, or an aggregate that only contains
104    // these is accepted by matcher.
105    // CheckValue returns false if CA cannot satisfy this constraint.
106    auto CheckValue = [&](const ConstantAggregate *CA) {
107      for (const Value *Op : CA->operand_values()) {
108        if (isa<UndefValue>(Op))
109          continue;
110 
111        const auto *CA = dyn_cast<ConstantAggregate>(Op);
112        if (!CA)
113          return false;
114        if (Seen.insert(CA).second)
115          Worklist.emplace_back(CA);
116      }
117 
118      return true;
119    };
120 
121    if (!CheckValue(CA))
122      return false;
123 
124    while (!Worklist.empty()) {
125      if (!CheckValue(Worklist.pop_back_val()))
126        return false;
127    }
128    return true;
129  }
130  template <typename ITy> bool match(ITy *V) { return check(V); }
131};
132 
133/// Match an arbitrary undef constant. This matches poison as well.
134/// If this is an aggregate and contains a non-aggregate element that is
135/// neither undef nor poison, the aggregate is not matched.
136inline auto m_Undef() { return undef_match(); }
137 
138/// Match an arbitrary poison constant.
139inline class_match<PoisonValue> m_Poison() {
140  return class_match<PoisonValue>();
141}
142 
143/// Match an arbitrary Constant and ignore it.
144inline class_match<Constant> m_Constant() { return class_match<Constant>(); }
145 
146/// Match an arbitrary ConstantInt and ignore it.
147inline class_match<ConstantInt> m_ConstantInt() {
148  return class_match<ConstantInt>();
149}
150 
151/// Match an arbitrary ConstantFP and ignore it.
152inline class_match<ConstantFP> m_ConstantFP() {
153  return class_match<ConstantFP>();
154}
155 
156struct constantexpr_match {
157  template <typename ITy> bool match(ITy *V) {
158    auto *C = dyn_cast<Constant>(V);
159    return C && (isa<ConstantExpr>(C) || C->containsConstantExpression());
160  }
161};
162 
163/// Match a constant expression or a constant that contains a constant
164/// expression.
165inline constantexpr_match m_ConstantExpr() { return constantexpr_match(); }
166 
167/// Match an arbitrary basic block value and ignore it.
168inline class_match<BasicBlock> m_BasicBlock() {
169  return class_match<BasicBlock>();
170}
171 
172/// Inverting matcher
173template <typename Ty> struct match_unless {
174  Ty M;
175 
176  match_unless(const Ty &Matcher) : M(Matcher) {}
177 
178  template <typename ITy> bool match(ITy *V) { return !M.match(V); }
179};
180 
181/// Match if the inner matcher does *NOT* match.
182template <typename Ty> inline match_unless<Ty> m_Unless(const Ty &M) {
183  return match_unless<Ty>(M);
184}
185 
186/// Matching combinators
187template <typename LTy, typename RTy> struct match_combine_or {
188  LTy L;
189  RTy R;
190 
191  match_combine_or(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
192 
193  template <typename ITy> bool match(ITy *V) {
194    if (L.match(V))
195      return true;
196    if (R.match(V))
197      return true;
198    return false;
199  }
200};
201 
202template <typename LTy, typename RTy> struct match_combine_and {
203  LTy L;
204  RTy R;
205 
206  match_combine_and(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
207 
208  template <typename ITy> bool match(ITy *V) {
209    if (L.match(V))
31
←
Calling 'match_combine_and::match'→
32
←
Taking true branch→
40
←
Returning from 'match_combine_and::match'→
41
←
Taking true branch→
210      if (R.match(V))
33
←
Calling 'Argument_match::match'→
37
←
Returning from 'Argument_match::match'→
38
←
Assuming the condition is true→
39
←
Taking true branch→
42
←
Taking true branch→
211        return true;
212    return false;
213  }
214};
215 
216/// Combine two pattern matchers matching L || R
217template <typename LTy, typename RTy>
218inline match_combine_or<LTy, RTy> m_CombineOr(const LTy &L, const RTy &R) {
219  return match_combine_or<LTy, RTy>(L, R);
220}
221 
222/// Combine two pattern matchers matching L && R
223template <typename LTy, typename RTy>
224inline match_combine_and<LTy, RTy> m_CombineAnd(const LTy &L, const RTy &R) {
225  return match_combine_and<LTy, RTy>(L, R);
23
←
Returning without writing to 'R.Val.VR'→
226}
227 
228struct apint_match {
229  const APInt *&Res;
230  bool AllowUndef;
231 
232  apint_match(const APInt *&Res, bool AllowUndef)
233      : Res(Res), AllowUndef(AllowUndef) {}
234 
235  template <typename ITy> bool match(ITy *V) {
236    if (auto *CI = dyn_cast<ConstantInt>(V)) {
237      Res = &CI->getValue();
238      return true;
239    }
240    if (V->getType()->isVectorTy())
241      if (const auto *C = dyn_cast<Constant>(V))
242        if (auto *CI =
243                dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndef))) {
244          Res = &CI->getValue();
245          return true;
246        }
247    return false;
248  }
249};
250// Either constexpr if or renaming ConstantFP::getValueAPF to
251// ConstantFP::getValue is needed to do it via single template
252// function for both apint/apfloat.
253struct apfloat_match {
254  const APFloat *&Res;
255  bool AllowUndef;
256 
257  apfloat_match(const APFloat *&Res, bool AllowUndef)
258      : Res(Res), AllowUndef(AllowUndef) {}
259 
260  template <typename ITy> bool match(ITy *V) {
261    if (auto *CI = dyn_cast<ConstantFP>(V)) {
262      Res = &CI->getValueAPF();
263      return true;
264    }
265    if (V->getType()->isVectorTy())
266      if (const auto *C = dyn_cast<Constant>(V))
267        if (auto *CI =
268                dyn_cast_or_null<ConstantFP>(C->getSplatValue(AllowUndef))) {
269          Res = &CI->getValueAPF();
270          return true;
271        }
272    return false;
273  }
274};
275 
276/// Match a ConstantInt or splatted ConstantVector, binding the
277/// specified pointer to the contained APInt.
278inline apint_match m_APInt(const APInt *&Res) {
279  // Forbid undefs by default to maintain previous behavior.
280  return apint_match(Res, /* AllowUndef */ false);
281}
282 
283/// Match APInt while allowing undefs in splat vector constants.
284inline apint_match m_APIntAllowUndef(const APInt *&Res) {
285  return apint_match(Res, /* AllowUndef */ true);
286}
287 
288/// Match APInt while forbidding undefs in splat vector constants.
289inline apint_match m_APIntForbidUndef(const APInt *&Res) {
290  return apint_match(Res, /* AllowUndef */ false);
291}
292 
293/// Match a ConstantFP or splatted ConstantVector, binding the
294/// specified pointer to the contained APFloat.
295inline apfloat_match m_APFloat(const APFloat *&Res) {
296  // Forbid undefs by default to maintain previous behavior.
297  return apfloat_match(Res, /* AllowUndef */ false);
298}
299 
300/// Match APFloat while allowing undefs in splat vector constants.
301inline apfloat_match m_APFloatAllowUndef(const APFloat *&Res) {
302  return apfloat_match(Res, /* AllowUndef */ true);
303}
304 
305/// Match APFloat while forbidding undefs in splat vector constants.
306inline apfloat_match m_APFloatForbidUndef(const APFloat *&Res) {
307  return apfloat_match(Res, /* AllowUndef */ false);
308}
309 
310template <int64_t Val> struct constantint_match {
311  template <typename ITy> bool match(ITy *V) {
312    if (const auto *CI = dyn_cast<ConstantInt>(V)) {
313      const APInt &CIV = CI->getValue();
314      if (Val >= 0)
315        return CIV == static_cast<uint64_t>(Val);
316      // If Val is negative, and CI is shorter than it, truncate to the right
317      // number of bits.  If it is larger, then we have to sign extend.  Just
318      // compare their negated values.
319      return -CIV == -Val;
320    }
321    return false;
322  }
323};
324 
325/// Match a ConstantInt with a specific value.
326template <int64_t Val> inline constantint_match<Val> m_ConstantInt() {
327  return constantint_match<Val>();
328}
329 
330/// This helper class is used to match constant scalars, vector splats,
331/// and fixed width vectors that satisfy a specified predicate.
332/// For fixed width vector constants, undefined elements are ignored.
333template <typename Predicate, typename ConstantVal>
334struct cstval_pred_ty : public Predicate {
335  template <typename ITy> bool match(ITy *V) {
336    if (const auto *CV = dyn_cast<ConstantVal>(V))
337      return this->isValue(CV->getValue());
338    if (const auto *VTy = dyn_cast<VectorType>(V->getType())) {
339      if (const auto *C = dyn_cast<Constant>(V)) {
340        if (const auto *CV = dyn_cast_or_null<ConstantVal>(C->getSplatValue()))
341          return this->isValue(CV->getValue());
342 
343        // Number of elements of a scalable vector unknown at compile time
344        auto *FVTy = dyn_cast<FixedVectorType>(VTy);
345        if (!FVTy)
346          return false;
347 
348        // Non-splat vector constant: check each element for a match.
349        unsigned NumElts = FVTy->getNumElements();
350        assert(NumElts != 0 && "Constant vector with no elements?")(static_cast <bool> (NumElts != 0 && "Constant vector with no elements?"
) ? void (0) : __assert_fail ("NumElts != 0 && \"Constant vector with no elements?\""
, "llvm/include/llvm/IR/PatternMatch.h", 350, __extension__ __PRETTY_FUNCTION__
));
351        bool HasNonUndefElements = false;
352        for (unsigned i = 0; i != NumElts; ++i) {
353          Constant *Elt = C->getAggregateElement(i);
354          if (!Elt)
355            return false;
356          if (isa<UndefValue>(Elt))
357            continue;
358          auto *CV = dyn_cast<ConstantVal>(Elt);
359          if (!CV || !this->isValue(CV->getValue()))
360            return false;
361          HasNonUndefElements = true;
362        }
363        return HasNonUndefElements;
364      }
365    }
366    return false;
367  }
368};
369 
370/// specialization of cstval_pred_ty for ConstantInt
371template <typename Predicate>
372using cst_pred_ty = cstval_pred_ty<Predicate, ConstantInt>;
373 
374/// specialization of cstval_pred_ty for ConstantFP
375template <typename Predicate>
376using cstfp_pred_ty = cstval_pred_ty<Predicate, ConstantFP>;
377 
378/// This helper class is used to match scalar and vector constants that
379/// satisfy a specified predicate, and bind them to an APInt.
380template <typename Predicate> struct api_pred_ty : public Predicate {
381  const APInt *&Res;
382 
383  api_pred_ty(const APInt *&R) : Res(R) {}
384 
385  template <typename ITy> bool match(ITy *V) {
386    if (const auto *CI = dyn_cast<ConstantInt>(V))
387      if (this->isValue(CI->getValue())) {
388        Res = &CI->getValue();
389        return true;
390      }
391    if (V->getType()->isVectorTy())
392      if (const auto *C = dyn_cast<Constant>(V))
393        if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue()))
394          if (this->isValue(CI->getValue())) {
395            Res = &CI->getValue();
396            return true;
397          }
398 
399    return false;
400  }
401};
402 
403/// This helper class is used to match scalar and vector constants that
404/// satisfy a specified predicate, and bind them to an APFloat.
405/// Undefs are allowed in splat vector constants.
406template <typename Predicate> struct apf_pred_ty : public Predicate {
407  const APFloat *&Res;
408 
409  apf_pred_ty(const APFloat *&R) : Res(R) {}
410 
411  template <typename ITy> bool match(ITy *V) {
412    if (const auto *CI = dyn_cast<ConstantFP>(V))
413      if (this->isValue(CI->getValue())) {
414        Res = &CI->getValue();
415        return true;
416      }
417    if (V->getType()->isVectorTy())
418      if (const auto *C = dyn_cast<Constant>(V))
419        if (auto *CI = dyn_cast_or_null<ConstantFP>(
420                C->getSplatValue(/* AllowUndef */ true)))
421          if (this->isValue(CI->getValue())) {
422            Res = &CI->getValue();
423            return true;
424          }
425 
426    return false;
427  }
428};
429 
430///////////////////////////////////////////////////////////////////////////////
431//
432// Encapsulate constant value queries for use in templated predicate matchers.
433// This allows checking if constants match using compound predicates and works
434// with vector constants, possibly with relaxed constraints. For example, ignore
435// undef values.
436//
437///////////////////////////////////////////////////////////////////////////////
438 
439struct is_any_apint {
440  bool isValue(const APInt &C) { return true; }
441};
442/// Match an integer or vector with any integral constant.
443/// For vectors, this includes constants with undefined elements.
444inline cst_pred_ty<is_any_apint> m_AnyIntegralConstant() {
445  return cst_pred_ty<is_any_apint>();
446}
447 
448struct is_all_ones {
449  bool isValue(const APInt &C) { return C.isAllOnes(); }
450};
451/// Match an integer or vector with all bits set.
452/// For vectors, this includes constants with undefined elements.
453inline cst_pred_ty<is_all_ones> m_AllOnes() {
454  return cst_pred_ty<is_all_ones>();
455}
456 
457struct is_maxsignedvalue {
458  bool isValue(const APInt &C) { return C.isMaxSignedValue(); }
459};
460/// Match an integer or vector with values having all bits except for the high
461/// bit set (0x7f...).
462/// For vectors, this includes constants with undefined elements.
463inline cst_pred_ty<is_maxsignedvalue> m_MaxSignedValue() {
464  return cst_pred_ty<is_maxsignedvalue>();
465}
466inline api_pred_ty<is_maxsignedvalue> m_MaxSignedValue(const APInt *&V) {
467  return V;
468}
469 
470struct is_negative {
471  bool isValue(const APInt &C) { return C.isNegative(); }
472};
473/// Match an integer or vector of negative values.
474/// For vectors, this includes constants with undefined elements.
475inline cst_pred_ty<is_negative> m_Negative() {
476  return cst_pred_ty<is_negative>();
477}
478inline api_pred_ty<is_negative> m_Negative(const APInt *&V) { return V; }
479 
480struct is_nonnegative {
481  bool isValue(const APInt &C) { return C.isNonNegative(); }
482};
483/// Match an integer or vector of non-negative values.
484/// For vectors, this includes constants with undefined elements.
485inline cst_pred_ty<is_nonnegative> m_NonNegative() {
486  return cst_pred_ty<is_nonnegative>();
487}
488inline api_pred_ty<is_nonnegative> m_NonNegative(const APInt *&V) { return V; }
489 
490struct is_strictlypositive {
491  bool isValue(const APInt &C) { return C.isStrictlyPositive(); }
492};
493/// Match an integer or vector of strictly positive values.
494/// For vectors, this includes constants with undefined elements.
495inline cst_pred_ty<is_strictlypositive> m_StrictlyPositive() {
496  return cst_pred_ty<is_strictlypositive>();
497}
498inline api_pred_ty<is_strictlypositive> m_StrictlyPositive(const APInt *&V) {
499  return V;
500}
501 
502struct is_nonpositive {
503  bool isValue(const APInt &C) { return C.isNonPositive(); }
504};
505/// Match an integer or vector of non-positive values.
506/// For vectors, this includes constants with undefined elements.
507inline cst_pred_ty<is_nonpositive> m_NonPositive() {
508  return cst_pred_ty<is_nonpositive>();
509}
510inline api_pred_ty<is_nonpositive> m_NonPositive(const APInt *&V) { return V; }
511 
512struct is_one {
513  bool isValue(const APInt &C) { return C.isOne(); }
514};
515/// Match an integer 1 or a vector with all elements equal to 1.
516/// For vectors, this includes constants with undefined elements.
517inline cst_pred_ty<is_one> m_One() { return cst_pred_ty<is_one>(); }
518 
519struct is_zero_int {
520  bool isValue(const APInt &C) { return C.isZero(); }
521};
522/// Match an integer 0 or a vector with all elements equal to 0.
523/// For vectors, this includes constants with undefined elements.
524inline cst_pred_ty<is_zero_int> m_ZeroInt() {
525  return cst_pred_ty<is_zero_int>();
526}
527 
528struct is_zero {
529  template <typename ITy> bool match(ITy *V) {
530    auto *C = dyn_cast<Constant>(V);
531    // FIXME: this should be able to do something for scalable vectors
532    return C && (C->isNullValue() || cst_pred_ty<is_zero_int>().match(C));
533  }
534};
535/// Match any null constant or a vector with all elements equal to 0.
536/// For vectors, this includes constants with undefined elements.
537inline is_zero m_Zero() { return is_zero(); }
538 
539struct is_power2 {
540  bool isValue(const APInt &C) { return C.isPowerOf2(); }
541};
542/// Match an integer or vector power-of-2.
543/// For vectors, this includes constants with undefined elements.
544inline cst_pred_ty<is_power2> m_Power2() { return cst_pred_ty<is_power2>(); }
545inline api_pred_ty<is_power2> m_Power2(const APInt *&V) { return V; }
546 
547struct is_negated_power2 {
548  bool isValue(const APInt &C) { return C.isNegatedPowerOf2(); }
549};
550/// Match a integer or vector negated power-of-2.
551/// For vectors, this includes constants with undefined elements.
552inline cst_pred_ty<is_negated_power2> m_NegatedPower2() {
553  return cst_pred_ty<is_negated_power2>();
554}
555inline api_pred_ty<is_negated_power2> m_NegatedPower2(const APInt *&V) {
556  return V;
557}
558 
559struct is_power2_or_zero {
560  bool isValue(const APInt &C) { return !C || C.isPowerOf2(); }
561};
562/// Match an integer or vector of 0 or power-of-2 values.
563/// For vectors, this includes constants with undefined elements.
564inline cst_pred_ty<is_power2_or_zero> m_Power2OrZero() {
565  return cst_pred_ty<is_power2_or_zero>();
566}
567inline api_pred_ty<is_power2_or_zero> m_Power2OrZero(const APInt *&V) {
568  return V;
569}
570 
571struct is_sign_mask {
572  bool isValue(const APInt &C) { return C.isSignMask(); }
573};
574/// Match an integer or vector with only the sign bit(s) set.
575/// For vectors, this includes constants with undefined elements.
576inline cst_pred_ty<is_sign_mask> m_SignMask() {
577  return cst_pred_ty<is_sign_mask>();
578}
579 
580struct is_lowbit_mask {
581  bool isValue(const APInt &C) { return C.isMask(); }
582};
583/// Match an integer or vector with only the low bit(s) set.
584/// For vectors, this includes constants with undefined elements.
585inline cst_pred_ty<is_lowbit_mask> m_LowBitMask() {
586  return cst_pred_ty<is_lowbit_mask>();
587}
588inline api_pred_ty<is_lowbit_mask> m_LowBitMask(const APInt *&V) { return V; }
589 
590struct icmp_pred_with_threshold {
591  ICmpInst::Predicate Pred;
592  const APInt *Thr;
593  bool isValue(const APInt &C) { return ICmpInst::compare(C, *Thr, Pred); }
594};
595/// Match an integer or vector with every element comparing 'pred' (eg/ne/...)
596/// to Threshold. For vectors, this includes constants with undefined elements.
597inline cst_pred_ty<icmp_pred_with_threshold>
598m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold) {
599  cst_pred_ty<icmp_pred_with_threshold> P;
600  P.Pred = Predicate;
601  P.Thr = &Threshold;
602  return P;
603}
604 
605struct is_nan {
606  bool isValue(const APFloat &C) { return C.isNaN(); }
607};
608/// Match an arbitrary NaN constant. This includes quiet and signalling nans.
609/// For vectors, this includes constants with undefined elements.
610inline cstfp_pred_ty<is_nan> m_NaN() { return cstfp_pred_ty<is_nan>(); }
611 
612struct is_nonnan {
613  bool isValue(const APFloat &C) { return !C.isNaN(); }
614};
615/// Match a non-NaN FP constant.
616/// For vectors, this includes constants with undefined elements.
617inline cstfp_pred_ty<is_nonnan> m_NonNaN() {
618  return cstfp_pred_ty<is_nonnan>();
619}
620 
621struct is_inf {
622  bool isValue(const APFloat &C) { return C.isInfinity(); }
623};
624/// Match a positive or negative infinity FP constant.
625/// For vectors, this includes constants with undefined elements.
626inline cstfp_pred_ty<is_inf> m_Inf() { return cstfp_pred_ty<is_inf>(); }
627 
628struct is_noninf {
629  bool isValue(const APFloat &C) { return !C.isInfinity(); }
630};
631/// Match a non-infinity FP constant, i.e. finite or NaN.
632/// For vectors, this includes constants with undefined elements.
633inline cstfp_pred_ty<is_noninf> m_NonInf() {
634  return cstfp_pred_ty<is_noninf>();
635}
636 
637struct is_finite {
638  bool isValue(const APFloat &C) { return C.isFinite(); }
639};
640/// Match a finite FP constant, i.e. not infinity or NaN.
641/// For vectors, this includes constants with undefined elements.
642inline cstfp_pred_ty<is_finite> m_Finite() {
643  return cstfp_pred_ty<is_finite>();
644}
645inline apf_pred_ty<is_finite> m_Finite(const APFloat *&V) { return V; }
646 
647struct is_finitenonzero {
648  bool isValue(const APFloat &C) { return C.isFiniteNonZero(); }
649};
650/// Match a finite non-zero FP constant.
651/// For vectors, this includes constants with undefined elements.
652inline cstfp_pred_ty<is_finitenonzero> m_FiniteNonZero() {
653  return cstfp_pred_ty<is_finitenonzero>();
654}
655inline apf_pred_ty<is_finitenonzero> m_FiniteNonZero(const APFloat *&V) {
656  return V;
657}
658 
659struct is_any_zero_fp {
660  bool isValue(const APFloat &C) { return C.isZero(); }
661};
662/// Match a floating-point negative zero or positive zero.
663/// For vectors, this includes constants with undefined elements.
664inline cstfp_pred_ty<is_any_zero_fp> m_AnyZeroFP() {
665  return cstfp_pred_ty<is_any_zero_fp>();
666}
667 
668struct is_pos_zero_fp {
669  bool isValue(const APFloat &C) { return C.isPosZero(); }
670};
671/// Match a floating-point positive zero.
672/// For vectors, this includes constants with undefined elements.
673inline cstfp_pred_ty<is_pos_zero_fp> m_PosZeroFP() {
674  return cstfp_pred_ty<is_pos_zero_fp>();
675}
676 
677struct is_neg_zero_fp {
678  bool isValue(const APFloat &C) { return C.isNegZero(); }
679};
680/// Match a floating-point negative zero.
681/// For vectors, this includes constants with undefined elements.
682inline cstfp_pred_ty<is_neg_zero_fp> m_NegZeroFP() {
683  return cstfp_pred_ty<is_neg_zero_fp>();
684}
685 
686struct is_non_zero_fp {
687  bool isValue(const APFloat &C) { return C.isNonZero(); }
688};
689/// Match a floating-point non-zero.
690/// For vectors, this includes constants with undefined elements.
691inline cstfp_pred_ty<is_non_zero_fp> m_NonZeroFP() {
692  return cstfp_pred_ty<is_non_zero_fp>();
693}
694 
695///////////////////////////////////////////////////////////////////////////////
696 
697template <typename Class> struct bind_ty {
698  Class *&VR;
699 
700  bind_ty(Class *&V) : VR(V) {}
701 
702  template <typename ITy> bool match(ITy *V) {
703    if (auto *CV = dyn_cast<Class>(V)) {
704      VR = CV;
705      return true;
706    }
707    return false;
708  }
709};
710 
711/// Match a value, capturing it if we match.
712inline bind_ty<Value> m_Value(Value *&V) { return V; }
13
←
Calling constructor for 'bind_ty<llvm::Value>'→
14
←
Returning from constructor for 'bind_ty<llvm::Value>'→
15
←
Returning without writing to 'V'→
713inline bind_ty<const Value> m_Value(const Value *&V) { return V; }
714 
715/// Match an instruction, capturing it if we match.
716inline bind_ty<Instruction> m_Instruction(Instruction *&I) { return I; }
717/// Match a unary operator, capturing it if we match.
718inline bind_ty<UnaryOperator> m_UnOp(UnaryOperator *&I) { return I; }
719/// Match a binary operator, capturing it if we match.
720inline bind_ty<BinaryOperator> m_BinOp(BinaryOperator *&I) { return I; }
721/// Match a with overflow intrinsic, capturing it if we match.
722inline bind_ty<WithOverflowInst> m_WithOverflowInst(WithOverflowInst *&I) {
723  return I;
724}
725inline bind_ty<const WithOverflowInst>
726m_WithOverflowInst(const WithOverflowInst *&I) {
727  return I;
728}
729 
730/// Match a Constant, capturing the value if we match.
731inline bind_ty<Constant> m_Constant(Constant *&C) { return C; }
732 
733/// Match a ConstantInt, capturing the value if we match.
734inline bind_ty<ConstantInt> m_ConstantInt(ConstantInt *&CI) { return CI; }
735 
736/// Match a ConstantFP, capturing the value if we match.
737inline bind_ty<ConstantFP> m_ConstantFP(ConstantFP *&C) { return C; }
738 
739/// Match a ConstantExpr, capturing the value if we match.
740inline bind_ty<ConstantExpr> m_ConstantExpr(ConstantExpr *&C) { return C; }
741 
742/// Match a basic block value, capturing it if we match.
743inline bind_ty<BasicBlock> m_BasicBlock(BasicBlock *&V) { return V; }
744inline bind_ty<const BasicBlock> m_BasicBlock(const BasicBlock *&V) {
745  return V;
746}
747 
748/// Match an arbitrary immediate Constant and ignore it.
749inline match_combine_and<class_match<Constant>,
750                         match_unless<constantexpr_match>>
751m_ImmConstant() {
752  return m_CombineAnd(m_Constant(), m_Unless(m_ConstantExpr()));
753}
754 
755/// Match an immediate Constant, capturing the value if we match.
756inline match_combine_and<bind_ty<Constant>,
757                         match_unless<constantexpr_match>>
758m_ImmConstant(Constant *&C) {
759  return m_CombineAnd(m_Constant(C), m_Unless(m_ConstantExpr()));
760}
761 
762/// Match a specified Value*.
763struct specificval_ty {
764  const Value *Val;
765 
766  specificval_ty(const Value *V) : Val(V) {}
767 
768  template <typename ITy> bool match(ITy *V) { return V == Val; }
769};
770 
771/// Match if we have a specific specified value.
772inline specificval_ty m_Specific(const Value *V) { return V; }
773 
774/// Stores a reference to the Value *, not the Value * itself,
775/// thus can be used in commutative matchers.
776template <typename Class> struct deferredval_ty {
777  Class *const &Val;
778 
779  deferredval_ty(Class *const &V) : Val(V) {}
780 
781  template <typename ITy> bool match(ITy *const V) { return V == Val; }
782};
783 
784/// Like m_Specific(), but works if the specific value to match is determined
785/// as part of the same match() expression. For example:
786/// m_Add(m_Value(X), m_Specific(X)) is incorrect, because m_Specific() will
787/// bind X before the pattern match starts.
788/// m_Add(m_Value(X), m_Deferred(X)) is correct, and will check against
789/// whichever value m_Value(X) populated.
790inline deferredval_ty<Value> m_Deferred(Value *const &V) { return V; }
791inline deferredval_ty<const Value> m_Deferred(const Value *const &V) {
792  return V;
793}
794 
795/// Match a specified floating point value or vector of all elements of
796/// that value.
797struct specific_fpval {
798  double Val;
799 
800  specific_fpval(double V) : Val(V) {}
801 
802  template <typename ITy> bool match(ITy *V) {
803    if (const auto *CFP = dyn_cast<ConstantFP>(V))
804      return CFP->isExactlyValue(Val);
805    if (V->getType()->isVectorTy())
806      if (const auto *C = dyn_cast<Constant>(V))
807        if (auto *CFP = dyn_cast_or_null<ConstantFP>(C->getSplatValue()))
808          return CFP->isExactlyValue(Val);
809    return false;
810  }
811};
812 
813/// Match a specific floating point value or vector with all elements
814/// equal to the value.
815inline specific_fpval m_SpecificFP(double V) { return specific_fpval(V); }
816 
817/// Match a float 1.0 or vector with all elements equal to 1.0.
818inline specific_fpval m_FPOne() { return m_SpecificFP(1.0); }
819 
820struct bind_const_intval_ty {
821  uint64_t &VR;
822 
823  bind_const_intval_ty(uint64_t &V) : VR(V) {}
824 
825  template <typename ITy> bool match(ITy *V) {
826    if (const auto *CV = dyn_cast<ConstantInt>(V))
827      if (CV->getValue().ule(UINT64_MAX(18446744073709551615UL))) {
828        VR = CV->getZExtValue();
829        return true;
830      }
831    return false;
832  }
833};
834 
835/// Match a specified integer value or vector of all elements of that
836/// value.
837template <bool AllowUndefs> struct specific_intval {
838  APInt Val;
839 
840  specific_intval(APInt V) : Val(std::move(V)) {}
841 
842  template <typename ITy> bool match(ITy *V) {
843    const auto *CI = dyn_cast<ConstantInt>(V);
844    if (!CI && V->getType()->isVectorTy())
845      if (const auto *C = dyn_cast<Constant>(V))
846        CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndefs));
847 
848    return CI && APInt::isSameValue(CI->getValue(), Val);
849  }
850};
851 
852/// Match a specific integer value or vector with all elements equal to
853/// the value.
854inline specific_intval<false> m_SpecificInt(APInt V) {
855  return specific_intval<false>(std::move(V));
856}
857 
858inline specific_intval<false> m_SpecificInt(uint64_t V) {
859  return m_SpecificInt(APInt(64, V));
860}
861 
862inline specific_intval<true> m_SpecificIntAllowUndef(APInt V) {
863  return specific_intval<true>(std::move(V));
864}
865 
866inline specific_intval<true> m_SpecificIntAllowUndef(uint64_t V) {
867  return m_SpecificIntAllowUndef(APInt(64, V));
868}
869 
870/// Match a ConstantInt and bind to its value.  This does not match
871/// ConstantInts wider than 64-bits.
872inline bind_const_intval_ty m_ConstantInt(uint64_t &V) { return V; }
873 
874/// Match a specified basic block value.
875struct specific_bbval {
876  BasicBlock *Val;
877 
878  specific_bbval(BasicBlock *Val) : Val(Val) {}
879 
880  template <typename ITy> bool match(ITy *V) {
881    const auto *BB = dyn_cast<BasicBlock>(V);
882    return BB && BB == Val;
883  }
884};
885 
886/// Match a specific basic block value.
887inline specific_bbval m_SpecificBB(BasicBlock *BB) {
888  return specific_bbval(BB);
889}
890 
891/// A commutative-friendly version of m_Specific().
892inline deferredval_ty<BasicBlock> m_Deferred(BasicBlock *const &BB) {
893  return BB;
894}
895inline deferredval_ty<const BasicBlock>
896m_Deferred(const BasicBlock *const &BB) {
897  return BB;
898}
899 
900//===----------------------------------------------------------------------===//
901// Matcher for any binary operator.
902//
903template <typename LHS_t, typename RHS_t, bool Commutable = false>
904struct AnyBinaryOp_match {
905  LHS_t L;
906  RHS_t R;
907 
908  // The evaluation order is always stable, regardless of Commutability.
909  // The LHS is always matched first.
910  AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
911 
912  template <typename OpTy> bool match(OpTy *V) {
913    if (auto *I = dyn_cast<BinaryOperator>(V))
914      return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
915             (Commutable && L.match(I->getOperand(1)) &&
916              R.match(I->getOperand(0)));
917    return false;
918  }
919};
920 
921template <typename LHS, typename RHS>
922inline AnyBinaryOp_match<LHS, RHS> m_BinOp(const LHS &L, const RHS &R) {
923  return AnyBinaryOp_match<LHS, RHS>(L, R);
924}
925 
926//===----------------------------------------------------------------------===//
927// Matcher for any unary operator.
928// TODO fuse unary, binary matcher into n-ary matcher
929//
930template <typename OP_t> struct AnyUnaryOp_match {
931  OP_t X;
932 
933  AnyUnaryOp_match(const OP_t &X) : X(X) {}
934 
935  template <typename OpTy> bool match(OpTy *V) {
936    if (auto *I = dyn_cast<UnaryOperator>(V))
937      return X.match(I->getOperand(0));
938    return false;
939  }
940};
941 
942template <typename OP_t> inline AnyUnaryOp_match<OP_t> m_UnOp(const OP_t &X) {
943  return AnyUnaryOp_match<OP_t>(X);
944}
945 
946//===----------------------------------------------------------------------===//
947// Matchers for specific binary operators.
948//
949 
950template <typename LHS_t, typename RHS_t, unsigned Opcode,
951          bool Commutable = false>
952struct BinaryOp_match {
953  LHS_t L;
954  RHS_t R;
955 
956  // The evaluation order is always stable, regardless of Commutability.
957  // The LHS is always matched first.
958  BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
959 
960  template <typename OpTy> inline bool match(unsigned Opc, OpTy *V) {
961    if (V->getValueID() == Value::InstructionVal + Opc) {
962      auto *I = cast<BinaryOperator>(V);
963      return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
964             (Commutable && L.match(I->getOperand(1)) &&
965              R.match(I->getOperand(0)));
966    }
967    if (auto *CE = dyn_cast<ConstantExpr>(V))
968      return CE->getOpcode() == Opc &&
969             ((L.match(CE->getOperand(0)) && R.match(CE->getOperand(1))) ||
970              (Commutable && L.match(CE->getOperand(1)) &&
971               R.match(CE->getOperand(0))));
972    return false;
973  }
974 
975  template <typename OpTy> bool match(OpTy *V) { return match(Opcode, V); }
976};
977 
978template <typename LHS, typename RHS>
979inline BinaryOp_match<LHS, RHS, Instruction::Add> m_Add(const LHS &L,
980                                                        const RHS &R) {
981  return BinaryOp_match<LHS, RHS, Instruction::Add>(L, R);
982}
983 
984template <typename LHS, typename RHS>
985inline BinaryOp_match<LHS, RHS, Instruction::FAdd> m_FAdd(const LHS &L,
986                                                          const RHS &R) {
987  return BinaryOp_match<LHS, RHS, Instruction::FAdd>(L, R);
988}
989 
990template <typename LHS, typename RHS>
991inline BinaryOp_match<LHS, RHS, Instruction::Sub> m_Sub(const LHS &L,
992                                                        const RHS &R) {
993  return BinaryOp_match<LHS, RHS, Instruction::Sub>(L, R);
994}
995 
996template <typename LHS, typename RHS>
997inline BinaryOp_match<LHS, RHS, Instruction::FSub> m_FSub(const LHS &L,
998                                                          const RHS &R) {
999  return BinaryOp_match<LHS, RHS, Instruction::FSub>(L, R);
1000}
1001 
1002template <typename Op_t> struct FNeg_match {
1003  Op_t X;
1004 
1005  FNeg_match(const Op_t &Op) : X(Op) {}
1006  template <typename OpTy> bool match(OpTy *V) {
1007    auto *FPMO = dyn_cast<FPMathOperator>(V);
1008    if (!FPMO)
1009      return false;
1010 
1011    if (FPMO->getOpcode() == Instruction::FNeg)
1012      return X.match(FPMO->getOperand(0));
1013 
1014    if (FPMO->getOpcode() == Instruction::FSub) {
1015      if (FPMO->hasNoSignedZeros()) {
1016        // With 'nsz', any zero goes.
1017        if (!cstfp_pred_ty<is_any_zero_fp>().match(FPMO->getOperand(0)))
1018          return false;
1019      } else {
1020        // Without 'nsz', we need fsub -0.0, X exactly.
1021        if (!cstfp_pred_ty<is_neg_zero_fp>().match(FPMO->getOperand(0)))
1022          return false;
1023      }
1024 
1025      return X.match(FPMO->getOperand(1));
1026    }
1027 
1028    return false;
1029  }
1030};
1031 
1032/// Match 'fneg X' as 'fsub -0.0, X'.
1033template <typename OpTy> inline FNeg_match<OpTy> m_FNeg(const OpTy &X) {
1034  return FNeg_match<OpTy>(X);
1035}
1036 
1037/// Match 'fneg X' as 'fsub +-0.0, X'.
1038template <typename RHS>
1039inline BinaryOp_match<cstfp_pred_ty<is_any_zero_fp>, RHS, Instruction::FSub>
1040m_FNegNSZ(const RHS &X) {
1041  return m_FSub(m_AnyZeroFP(), X);
1042}
1043 
1044template <typename LHS, typename RHS>
1045inline BinaryOp_match<LHS, RHS, Instruction::Mul> m_Mul(const LHS &L,
1046                                                        const RHS &R) {
1047  return BinaryOp_match<LHS, RHS, Instruction::Mul>(L, R);
1048}
1049 
1050template <typename LHS, typename RHS>
1051inline BinaryOp_match<LHS, RHS, Instruction::FMul> m_FMul(const LHS &L,
1052                                                          const RHS &R) {
1053  return BinaryOp_match<LHS, RHS, Instruction::FMul>(L, R);
1054}
1055 
1056template <typename LHS, typename RHS>
1057inline BinaryOp_match<LHS, RHS, Instruction::UDiv> m_UDiv(const LHS &L,
1058                                                          const RHS &R) {
1059  return BinaryOp_match<LHS, RHS, Instruction::UDiv>(L, R);
1060}
1061 
1062template <typename LHS, typename RHS>
1063inline BinaryOp_match<LHS, RHS, Instruction::SDiv> m_SDiv(const LHS &L,
1064                                                          const RHS &R) {
1065  return BinaryOp_match<LHS, RHS, Instruction::SDiv>(L, R);
1066}
1067 
1068template <typename LHS, typename RHS>
1069inline BinaryOp_match<LHS, RHS, Instruction::FDiv> m_FDiv(const LHS &L,
1070                                                          const RHS &R) {
1071  return BinaryOp_match<LHS, RHS, Instruction::FDiv>(L, R);
1072}
1073 
1074template <typename LHS, typename RHS>
1075inline BinaryOp_match<LHS, RHS, Instruction::URem> m_URem(const LHS &L,
1076                                                          const RHS &R) {
1077  return BinaryOp_match<LHS, RHS, Instruction::URem>(L, R);
1078}
1079 
1080template <typename LHS, typename RHS>
1081inline BinaryOp_match<LHS, RHS, Instruction::SRem> m_SRem(const LHS &L,
1082                                                          const RHS &R) {
1083  return BinaryOp_match<LHS, RHS, Instruction::SRem>(L, R);
1084}
1085 
1086template <typename LHS, typename RHS>
1087inline BinaryOp_match<LHS, RHS, Instruction::FRem> m_FRem(const LHS &L,
1088                                                          const RHS &R) {
1089  return BinaryOp_match<LHS, RHS, Instruction::FRem>(L, R);
1090}
1091 
1092template <typename LHS, typename RHS>
1093inline BinaryOp_match<LHS, RHS, Instruction::And> m_And(const LHS &L,
1094                                                        const RHS &R) {
1095  return BinaryOp_match<LHS, RHS, Instruction::And>(L, R);
1096}
1097 
1098template <typename LHS, typename RHS>
1099inline BinaryOp_match<LHS, RHS, Instruction::Or> m_Or(const LHS &L,
1100                                                      const RHS &R) {
1101  return BinaryOp_match<LHS, RHS, Instruction::Or>(L, R);
1102}
1103 
1104template <typename LHS, typename RHS>
1105inline BinaryOp_match<LHS, RHS, Instruction::Xor> m_Xor(const LHS &L,
1106                                                        const RHS &R) {
1107  return BinaryOp_match<LHS, RHS, Instruction::Xor>(L, R);
1108}
1109 
1110template <typename LHS, typename RHS>
1111inline BinaryOp_match<LHS, RHS, Instruction::Shl> m_Shl(const LHS &L,
1112                                                        const RHS &R) {
1113  return BinaryOp_match<LHS, RHS, Instruction::Shl>(L, R);
1114}
1115 
1116template <typename LHS, typename RHS>
1117inline BinaryOp_match<LHS, RHS, Instruction::LShr> m_LShr(const LHS &L,
1118                                                          const RHS &R) {
1119  return BinaryOp_match<LHS, RHS, Instruction::LShr>(L, R);
1120}
1121 
1122template <typename LHS, typename RHS>
1123inline BinaryOp_match<LHS, RHS, Instruction::AShr> m_AShr(const LHS &L,
1124                                                          const RHS &R) {
1125  return BinaryOp_match<LHS, RHS, Instruction::AShr>(L, R);
1126}
1127 
1128template <typename LHS_t, typename RHS_t, unsigned Opcode,
1129          unsigned WrapFlags = 0>
1130struct OverflowingBinaryOp_match {
1131  LHS_t L;
1132  RHS_t R;
1133 
1134  OverflowingBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
1135      : L(LHS), R(RHS) {}
1136 
1137  template <typename OpTy> bool match(OpTy *V) {
1138    if (auto *Op = dyn_cast<OverflowingBinaryOperator>(V)) {
1139      if (Op->getOpcode() != Opcode)
1140        return false;
1141      if ((WrapFlags & OverflowingBinaryOperator::NoUnsignedWrap) &&
1142          !Op->hasNoUnsignedWrap())
1143        return false;
1144      if ((WrapFlags & OverflowingBinaryOperator::NoSignedWrap) &&
1145          !Op->hasNoSignedWrap())
1146        return false;
1147      return L.match(Op->getOperand(0)) && R.match(Op->getOperand(1));
1148    }
1149    return false;
1150  }
1151};
1152 
1153template <typename LHS, typename RHS>
1154inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1155                                 OverflowingBinaryOperator::NoSignedWrap>
1156m_NSWAdd(const LHS &L, const RHS &R) {
1157  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1158                                   OverflowingBinaryOperator::NoSignedWrap>(L,
1159                                                                            R);
1160}
1161template <typename LHS, typename RHS>
1162inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1163                                 OverflowingBinaryOperator::NoSignedWrap>
1164m_NSWSub(const LHS &L, const RHS &R) {
1165  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1166                                   OverflowingBinaryOperator::NoSignedWrap>(L,
1167                                                                            R);
1168}
1169template <typename LHS, typename RHS>
1170inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1171                                 OverflowingBinaryOperator::NoSignedWrap>
1172m_NSWMul(const LHS &L, const RHS &R) {
1173  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1174                                   OverflowingBinaryOperator::NoSignedWrap>(L,
1175                                                                            R);
1176}
1177template <typename LHS, typename RHS>
1178inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1179                                 OverflowingBinaryOperator::NoSignedWrap>
1180m_NSWShl(const LHS &L, const RHS &R) {
1181  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1182                                   OverflowingBinaryOperator::NoSignedWrap>(L,
1183                                                                            R);
1184}
1185 
1186template <typename LHS, typename RHS>
1187inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1188                                 OverflowingBinaryOperator::NoUnsignedWrap>
1189m_NUWAdd(const LHS &L, const RHS &R) {
1190  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1191                                   OverflowingBinaryOperator::NoUnsignedWrap>(
1192      L, R);
1193}
1194template <typename LHS, typename RHS>
1195inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1196                                 OverflowingBinaryOperator::NoUnsignedWrap>
1197m_NUWSub(const LHS &L, const RHS &R) {
1198  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1199                                   OverflowingBinaryOperator::NoUnsignedWrap>(
1200      L, R);
1201}
1202template <typename LHS, typename RHS>
1203inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1204                                 OverflowingBinaryOperator::NoUnsignedWrap>
1205m_NUWMul(const LHS &L, const RHS &R) {
1206  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1207                                   OverflowingBinaryOperator::NoUnsignedWrap>(
1208      L, R);
1209}
1210template <typename LHS, typename RHS>
1211inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1212                                 OverflowingBinaryOperator::NoUnsignedWrap>
1213m_NUWShl(const LHS &L, const RHS &R) {
1214  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1215                                   OverflowingBinaryOperator::NoUnsignedWrap>(
1216      L, R);
1217}
1218 
1219template <typename LHS_t, typename RHS_t, bool Commutable = false>
1220struct SpecificBinaryOp_match
1221    : public BinaryOp_match<LHS_t, RHS_t, 0, Commutable> {
1222  unsigned Opcode;
1223 
1224  SpecificBinaryOp_match(unsigned Opcode, const LHS_t &LHS, const RHS_t &RHS)
1225      : BinaryOp_match<LHS_t, RHS_t, 0, Commutable>(LHS, RHS), Opcode(Opcode) {}
1226 
1227  template <typename OpTy> bool match(OpTy *V) {
1228    return BinaryOp_match<LHS_t, RHS_t, 0, Commutable>::match(Opcode, V);
1229  }
1230};
1231 
1232/// Matches a specific opcode.
1233template <typename LHS, typename RHS>
1234inline SpecificBinaryOp_match<LHS, RHS> m_BinOp(unsigned Opcode, const LHS &L,
1235                                                const RHS &R) {
1236  return SpecificBinaryOp_match<LHS, RHS>(Opcode, L, R);
1237}
1238 
1239//===----------------------------------------------------------------------===//
1240// Class that matches a group of binary opcodes.
1241//
1242template <typename LHS_t, typename RHS_t, typename Predicate>
1243struct BinOpPred_match : Predicate {
1244  LHS_t L;
1245  RHS_t R;
1246 
1247  BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1248 
1249  template <typename OpTy> bool match(OpTy *V) {
1250    if (auto *I = dyn_cast<Instruction>(V))
1251      return this->isOpType(I->getOpcode()) && L.match(I->getOperand(0)) &&
1252             R.match(I->getOperand(1));
1253    if (auto *CE = dyn_cast<ConstantExpr>(V))
1254      return this->isOpType(CE->getOpcode()) && L.match(CE->getOperand(0)) &&
1255             R.match(CE->getOperand(1));
1256    return false;
1257  }
1258};
1259 
1260struct is_shift_op {
1261  bool isOpType(unsigned Opcode) { return Instruction::isShift(Opcode); }
1262};
1263 
1264struct is_right_shift_op {
1265  bool isOpType(unsigned Opcode) {
1266    return Opcode == Instruction::LShr || Opcode == Instruction::AShr;
1267  }
1268};
1269 
1270struct is_logical_shift_op {
1271  bool isOpType(unsigned Opcode) {
1272    return Opcode == Instruction::LShr || Opcode == Instruction::Shl;
1273  }
1274};
1275 
1276struct is_bitwiselogic_op {
1277  bool isOpType(unsigned Opcode) {
1278    return Instruction::isBitwiseLogicOp(Opcode);
1279  }
1280};
1281 
1282struct is_idiv_op {
1283  bool isOpType(unsigned Opcode) {
1284    return Opcode == Instruction::SDiv || Opcode == Instruction::UDiv;
1285  }
1286};
1287 
1288struct is_irem_op {
1289  bool isOpType(unsigned Opcode) {
1290    return Opcode == Instruction::SRem || Opcode == Instruction::URem;
1291  }
1292};
1293 
1294/// Matches shift operations.
1295template <typename LHS, typename RHS>
1296inline BinOpPred_match<LHS, RHS, is_shift_op> m_Shift(const LHS &L,
1297                                                      const RHS &R) {
1298  return BinOpPred_match<LHS, RHS, is_shift_op>(L, R);
1299}
1300 
1301/// Matches logical shift operations.
1302template <typename LHS, typename RHS>
1303inline BinOpPred_match<LHS, RHS, is_right_shift_op> m_Shr(const LHS &L,
1304                                                          const RHS &R) {
1305  return BinOpPred_match<LHS, RHS, is_right_shift_op>(L, R);
1306}
1307 
1308/// Matches logical shift operations.
1309template <typename LHS, typename RHS>
1310inline BinOpPred_match<LHS, RHS, is_logical_shift_op>
1311m_LogicalShift(const LHS &L, const RHS &R) {
1312  return BinOpPred_match<LHS, RHS, is_logical_shift_op>(L, R);
1313}
1314 
1315/// Matches bitwise logic operations.
1316template <typename LHS, typename RHS>
1317inline BinOpPred_match<LHS, RHS, is_bitwiselogic_op>
1318m_BitwiseLogic(const LHS &L, const RHS &R) {
1319  return BinOpPred_match<LHS, RHS, is_bitwiselogic_op>(L, R);
1320}
1321 
1322/// Matches integer division operations.
1323template <typename LHS, typename RHS>
1324inline BinOpPred_match<LHS, RHS, is_idiv_op> m_IDiv(const LHS &L,
1325                                                    const RHS &R) {
1326  return BinOpPred_match<LHS, RHS, is_idiv_op>(L, R);
1327}
1328 
1329/// Matches integer remainder operations.
1330template <typename LHS, typename RHS>
1331inline BinOpPred_match<LHS, RHS, is_irem_op> m_IRem(const LHS &L,
1332                                                    const RHS &R) {
1333  return BinOpPred_match<LHS, RHS, is_irem_op>(L, R);
1334}
1335 
1336//===----------------------------------------------------------------------===//
1337// Class that matches exact binary ops.
1338//
1339template <typename SubPattern_t> struct Exact_match {
1340  SubPattern_t SubPattern;
1341 
1342  Exact_match(const SubPattern_t &SP) : SubPattern(SP) {}
1343 
1344  template <typename OpTy> bool match(OpTy *V) {
1345    if (auto *PEO = dyn_cast<PossiblyExactOperator>(V))
1346      return PEO->isExact() && SubPattern.match(V);
1347    return false;
1348  }
1349};
1350 
1351template <typename T> inline Exact_match<T> m_Exact(const T &SubPattern) {
1352  return SubPattern;
1353}
1354 
1355//===----------------------------------------------------------------------===//
1356// Matchers for CmpInst classes
1357//
1358 
1359template <typename LHS_t, typename RHS_t, typename Class, typename PredicateTy,
1360          bool Commutable = false>
1361struct CmpClass_match {
1362  PredicateTy &Predicate;
1363  LHS_t L;
1364  RHS_t R;
1365 
1366  // The evaluation order is always stable, regardless of Commutability.
1367  // The LHS is always matched first.
1368  CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
1369      : Predicate(Pred), L(LHS), R(RHS) {}
1370 
1371  template <typename OpTy> bool match(OpTy *V) {
1372    if (auto *I = dyn_cast<Class>(V)) {
1373      if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
1374        Predicate = I->getPredicate();
1375        return true;
1376      } else if (Commutable && L.match(I->getOperand(1)) &&
1377                 R.match(I->getOperand(0))) {
1378        Predicate = I->getSwappedPredicate();
1379        return true;
1380      }
1381    }
1382    return false;
1383  }
1384};
1385 
1386template <typename LHS, typename RHS>
1387inline CmpClass_match<LHS, RHS, CmpInst, CmpInst::Predicate>
1388m_Cmp(CmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1389  return CmpClass_match<LHS, RHS, CmpInst, CmpInst::Predicate>(Pred, L, R);
1390}
1391 
1392template <typename LHS, typename RHS>
1393inline CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>
1394m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1395  return CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>(Pred, L, R);
1396}
1397 
1398template <typename LHS, typename RHS>
1399inline CmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>
1400m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1401  return CmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>(Pred, L, R);
1402}
1403 
1404//===----------------------------------------------------------------------===//
1405// Matchers for instructions with a given opcode and number of operands.
1406//
1407 
1408/// Matches instructions with Opcode and three operands.
1409template <typename T0, unsigned Opcode> struct OneOps_match {
1410  T0 Op1;
1411 
1412  OneOps_match(const T0 &Op1) : Op1(Op1) {}
1413 
1414  template <typename OpTy> bool match(OpTy *V) {
1415    if (V->getValueID() == Value::InstructionVal + Opcode) {
1416      auto *I = cast<Instruction>(V);
1417      return Op1.match(I->getOperand(0));
1418    }
1419    return false;
1420  }
1421};
1422 
1423/// Matches instructions with Opcode and three operands.
1424template <typename T0, typename T1, unsigned Opcode> struct TwoOps_match {
1425  T0 Op1;
1426  T1 Op2;
1427 
1428  TwoOps_match(const T0 &Op1, const T1 &Op2) : Op1(Op1), Op2(Op2) {}
1429 
1430  template <typename OpTy> bool match(OpTy *V) {
1431    if (V->getValueID() == Value::InstructionVal + Opcode) {
1432      auto *I = cast<Instruction>(V);
1433      return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1));
1434    }
1435    return false;
1436  }
1437};
1438 
1439/// Matches instructions with Opcode and three operands.
1440template <typename T0, typename T1, typename T2, unsigned Opcode>
1441struct ThreeOps_match {
1442  T0 Op1;
1443  T1 Op2;
1444  T2 Op3;
1445 
1446  ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
1447      : Op1(Op1), Op2(Op2), Op3(Op3) {}
1448 
1449  template <typename OpTy> bool match(OpTy *V) {
1450    if (V->getValueID() == Value::InstructionVal + Opcode) {
1451      auto *I = cast<Instruction>(V);
1452      return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1453             Op3.match(I->getOperand(2));
1454    }
1455    return false;
1456  }
1457};
1458 
1459/// Matches SelectInst.
1460template <typename Cond, typename LHS, typename RHS>
1461inline ThreeOps_match<Cond, LHS, RHS, Instruction::Select>
1462m_Select(const Cond &C, const LHS &L, const RHS &R) {
1463  return ThreeOps_match<Cond, LHS, RHS, Instruction::Select>(C, L, R);
1464}
1465 
1466/// This matches a select of two constants, e.g.:
1467/// m_SelectCst<-1, 0>(m_Value(V))
1468template <int64_t L, int64_t R, typename Cond>
1469inline ThreeOps_match<Cond, constantint_match<L>, constantint_match<R>,
1470                      Instruction::Select>
1471m_SelectCst(const Cond &C) {
1472  return m_Select(C, m_ConstantInt<L>(), m_ConstantInt<R>());
1473}
1474 
1475/// Matches FreezeInst.
1476template <typename OpTy>
1477inline OneOps_match<OpTy, Instruction::Freeze> m_Freeze(const OpTy &Op) {
1478  return OneOps_match<OpTy, Instruction::Freeze>(Op);
1479}
1480 
1481/// Matches InsertElementInst.
1482template <typename Val_t, typename Elt_t, typename Idx_t>
1483inline ThreeOps_match<Val_t, Elt_t, Idx_t, Instruction::InsertElement>
1484m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) {
1485  return ThreeOps_match<Val_t, Elt_t, Idx_t, Instruction::InsertElement>(
1486      Val, Elt, Idx);
1487}
1488 
1489/// Matches ExtractElementInst.
1490template <typename Val_t, typename Idx_t>
1491inline TwoOps_match<Val_t, Idx_t, Instruction::ExtractElement>
1492m_ExtractElt(const Val_t &Val, const Idx_t &Idx) {
1493  return TwoOps_match<Val_t, Idx_t, Instruction::ExtractElement>(Val, Idx);
1494}
1495 
1496/// Matches shuffle.
1497template <typename T0, typename T1, typename T2> struct Shuffle_match {
1498  T0 Op1;
1499  T1 Op2;
1500  T2 Mask;
1501 
1502  Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
1503      : Op1(Op1), Op2(Op2), Mask(Mask) {}
1504 
1505  template <typename OpTy> bool match(OpTy *V) {
1506    if (auto *I = dyn_cast<ShuffleVectorInst>(V)) {
1507      return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1508             Mask.match(I->getShuffleMask());
1509    }
1510    return false;
1511  }
1512};
1513 
1514struct m_Mask {
1515  ArrayRef<int> &MaskRef;
1516  m_Mask(ArrayRef<int> &MaskRef) : MaskRef(MaskRef) {}
1517  bool match(ArrayRef<int> Mask) {
1518    MaskRef = Mask;
1519    return true;
1520  }
1521};
1522 
1523struct m_ZeroMask {
1524  bool match(ArrayRef<int> Mask) {
1525    return all_of(Mask, [](int Elem) { return Elem == 0 || Elem == -1; });
1526  }
1527};
1528 
1529struct m_SpecificMask {
1530  ArrayRef<int> &MaskRef;
1531  m_SpecificMask(ArrayRef<int> &MaskRef) : MaskRef(MaskRef) {}
1532  bool match(ArrayRef<int> Mask) { return MaskRef == Mask; }
1533};
1534 
1535struct m_SplatOrUndefMask {
1536  int &SplatIndex;
1537  m_SplatOrUndefMask(int &SplatIndex) : SplatIndex(SplatIndex) {}
1538  bool match(ArrayRef<int> Mask) {
1539    const auto *First = find_if(Mask, [](int Elem) { return Elem != -1; });
1540    if (First == Mask.end())
1541      return false;
1542    SplatIndex = *First;
1543    return all_of(Mask,
1544                  [First](int Elem) { return Elem == *First || Elem == -1; });
1545  }
1546};
1547 
1548/// Matches ShuffleVectorInst independently of mask value.
1549template <typename V1_t, typename V2_t>
1550inline TwoOps_match<V1_t, V2_t, Instruction::ShuffleVector>
1551m_Shuffle(const V1_t &v1, const V2_t &v2) {
1552  return TwoOps_match<V1_t, V2_t, Instruction::ShuffleVector>(v1, v2);
1553}
1554 
1555template <typename V1_t, typename V2_t, typename Mask_t>
1556inline Shuffle_match<V1_t, V2_t, Mask_t>
1557m_Shuffle(const V1_t &v1, const V2_t &v2, const Mask_t &mask) {
1558  return Shuffle_match<V1_t, V2_t, Mask_t>(v1, v2, mask);
1559}
1560 
1561/// Matches LoadInst.
1562template <typename OpTy>
1563inline OneOps_match<OpTy, Instruction::Load> m_Load(const OpTy &Op) {
1564  return OneOps_match<OpTy, Instruction::Load>(Op);
1565}
1566 
1567/// Matches StoreInst.
1568template <typename ValueOpTy, typename PointerOpTy>
1569inline TwoOps_match<ValueOpTy, PointerOpTy, Instruction::Store>
1570m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp) {
1571  return TwoOps_match<ValueOpTy, PointerOpTy, Instruction::Store>(ValueOp,
1572                                                                  PointerOp);
1573}
1574 
1575//===----------------------------------------------------------------------===//
1576// Matchers for CastInst classes
1577//
1578 
1579template <typename Op_t, unsigned Opcode> struct CastClass_match {
1580  Op_t Op;
1581 
1582  CastClass_match(const Op_t &OpMatch) : Op(OpMatch) {}
1583 
1584  template <typename OpTy> bool match(OpTy *V) {
1585    if (auto *O = dyn_cast<Operator>(V))
1586      return O->getOpcode() == Opcode && Op.match(O->getOperand(0));
1587    return false;
1588  }
1589};
1590 
1591/// Matches BitCast.
1592template <typename OpTy>
1593inline CastClass_match<OpTy, Instruction::BitCast> m_BitCast(const OpTy &Op) {
1594  return CastClass_match<OpTy, Instruction::BitCast>(Op);
1595}
1596 
1597/// Matches PtrToInt.
1598template <typename OpTy>
1599inline CastClass_match<OpTy, Instruction::PtrToInt> m_PtrToInt(const OpTy &Op) {
1600  return CastClass_match<OpTy, Instruction::PtrToInt>(Op);
1601}
1602 
1603/// Matches IntToPtr.
1604template <typename OpTy>
1605inline CastClass_match<OpTy, Instruction::IntToPtr> m_IntToPtr(const OpTy &Op) {
1606  return CastClass_match<OpTy, Instruction::IntToPtr>(Op);
1607}
1608 
1609/// Matches Trunc.
1610template <typename OpTy>
1611inline CastClass_match<OpTy, Instruction::Trunc> m_Trunc(const OpTy &Op) {
1612  return CastClass_match<OpTy, Instruction::Trunc>(Op);
1613}
1614 
1615template <typename OpTy>
1616inline match_combine_or<CastClass_match<OpTy, Instruction::Trunc>, OpTy>
1617m_TruncOrSelf(const OpTy &Op) {
1618  return m_CombineOr(m_Trunc(Op), Op);
1619}
1620 
1621/// Matches SExt.
1622template <typename OpTy>
1623inline CastClass_match<OpTy, Instruction::SExt> m_SExt(const OpTy &Op) {
1624  return CastClass_match<OpTy, Instruction::SExt>(Op);
1625}
1626 
1627/// Matches ZExt.
1628template <typename OpTy>
1629inline CastClass_match<OpTy, Instruction::ZExt> m_ZExt(const OpTy &Op) {
1630  return CastClass_match<OpTy, Instruction::ZExt>(Op);
1631}
1632 
1633template <typename OpTy>
1634inline match_combine_or<CastClass_match<OpTy, Instruction::ZExt>, OpTy>
1635m_ZExtOrSelf(const OpTy &Op) {
1636  return m_CombineOr(m_ZExt(Op), Op);
1637}
1638 
1639template <typename OpTy>
1640inline match_combine_or<CastClass_match<OpTy, Instruction::SExt>, OpTy>
1641m_SExtOrSelf(const OpTy &Op) {
1642  return m_CombineOr(m_SExt(Op), Op);
1643}
1644 
1645template <typename OpTy>
1646inline match_combine_or<CastClass_match<OpTy, Instruction::ZExt>,
1647                        CastClass_match<OpTy, Instruction::SExt>>
1648m_ZExtOrSExt(const OpTy &Op) {
1649  return m_CombineOr(m_ZExt(Op), m_SExt(Op));
1650}
1651 
1652template <typename OpTy>
1653inline match_combine_or<
1654    match_combine_or<CastClass_match<OpTy, Instruction::ZExt>,
1655                     CastClass_match<OpTy, Instruction::SExt>>,
1656    OpTy>
1657m_ZExtOrSExtOrSelf(const OpTy &Op) {
1658  return m_CombineOr(m_ZExtOrSExt(Op), Op);
1659}
1660 
1661template <typename OpTy>
1662inline CastClass_match<OpTy, Instruction::UIToFP> m_UIToFP(const OpTy &Op) {
1663  return CastClass_match<OpTy, Instruction::UIToFP>(Op);
1664}
1665 
1666template <typename OpTy>
1667inline CastClass_match<OpTy, Instruction::SIToFP> m_SIToFP(const OpTy &Op) {
1668  return CastClass_match<OpTy, Instruction::SIToFP>(Op);
1669}
1670 
1671template <typename OpTy>
1672inline CastClass_match<OpTy, Instruction::FPToUI> m_FPToUI(const OpTy &Op) {
1673  return CastClass_match<OpTy, Instruction::FPToUI>(Op);
1674}
1675 
1676template <typename OpTy>
1677inline CastClass_match<OpTy, Instruction::FPToSI> m_FPToSI(const OpTy &Op) {
1678  return CastClass_match<OpTy, Instruction::FPToSI>(Op);
1679}
1680 
1681template <typename OpTy>
1682inline CastClass_match<OpTy, Instruction::FPTrunc> m_FPTrunc(const OpTy &Op) {
1683  return CastClass_match<OpTy, Instruction::FPTrunc>(Op);
1684}
1685 
1686template <typename OpTy>
1687inline CastClass_match<OpTy, Instruction::FPExt> m_FPExt(const OpTy &Op) {
1688  return CastClass_match<OpTy, Instruction::FPExt>(Op);
1689}
1690 
1691//===----------------------------------------------------------------------===//
1692// Matchers for control flow.
1693//
1694 
1695struct br_match {
1696  BasicBlock *&Succ;
1697 
1698  br_match(BasicBlock *&Succ) : Succ(Succ) {}
1699 
1700  template <typename OpTy> bool match(OpTy *V) {
1701    if (auto *BI = dyn_cast<BranchInst>(V))
1702      if (BI->isUnconditional()) {
1703        Succ = BI->getSuccessor(0);
1704        return true;
1705      }
1706    return false;
1707  }
1708};
1709 
1710inline br_match m_UnconditionalBr(BasicBlock *&Succ) { return br_match(Succ); }
1711 
1712template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1713struct brc_match {
1714  Cond_t Cond;
1715  TrueBlock_t T;
1716  FalseBlock_t F;
1717 
1718  brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
1719      : Cond(C), T(t), F(f) {}
1720 
1721  template <typename OpTy> bool match(OpTy *V) {
1722    if (auto *BI = dyn_cast<BranchInst>(V))
1723      if (BI->isConditional() && Cond.match(BI->getCondition()))
1724        return T.match(BI->getSuccessor(0)) && F.match(BI->getSuccessor(1));
1725    return false;
1726  }
1727};
1728 
1729template <typename Cond_t>
1730inline brc_match<Cond_t, bind_ty<BasicBlock>, bind_ty<BasicBlock>>
1731m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F) {
1732  return brc_match<Cond_t, bind_ty<BasicBlock>, bind_ty<BasicBlock>>(
1733      C, m_BasicBlock(T), m_BasicBlock(F));
1734}
1735 
1736template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1737inline brc_match<Cond_t, TrueBlock_t, FalseBlock_t>
1738m_Br(const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &F) {
1739  return brc_match<Cond_t, TrueBlock_t, FalseBlock_t>(C, T, F);
1740}
1741 
1742//===----------------------------------------------------------------------===//
1743// Matchers for max/min idioms, eg: "select (sgt x, y), x, y" -> smax(x,y).
1744//
1745 
1746template <typename CmpInst_t, typename LHS_t, typename RHS_t, typename Pred_t,
1747          bool Commutable = false>
1748struct MaxMin_match {
1749  using PredType = Pred_t;
1750  LHS_t L;
1751  RHS_t R;
1752 
1753  // The evaluation order is always stable, regardless of Commutability.
1754  // The LHS is always matched first.
1755  MaxMin_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1756 
1757  template <typename OpTy> bool match(OpTy *V) {
1758    if (auto *II = dyn_cast<IntrinsicInst>(V)) {
1759      Intrinsic::ID IID = II->getIntrinsicID();
1760      if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
1761          (IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
1762          (IID == Intrinsic::umax && Pred_t::match(ICmpInst::ICMP_UGT)) ||
1763          (IID == Intrinsic::umin && Pred_t::match(ICmpInst::ICMP_ULT))) {
1764        Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
1765        return (L.match(LHS) && R.match(RHS)) ||
1766               (Commutable && L.match(RHS) && R.match(LHS));
1767      }
1768    }
1769    // Look for "(x pred y) ? x : y" or "(x pred y) ? y : x".
1770    auto *SI = dyn_cast<SelectInst>(V);
1771    if (!SI)
1772      return false;
1773    auto *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
1774    if (!Cmp)
1775      return false;
1776    // At this point we have a select conditioned on a comparison.  Check that
1777    // it is the values returned by the select that are being compared.
1778    auto *TrueVal = SI->getTrueValue();
1779    auto *FalseVal = SI->getFalseValue();
1780    auto *LHS = Cmp->getOperand(0);
1781    auto *RHS = Cmp->getOperand(1);
1782    if ((TrueVal != LHS || FalseVal != RHS) &&
1783        (TrueVal != RHS || FalseVal != LHS))
1784      return false;
1785    typename CmpInst_t::Predicate Pred =
1786        LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();
1787    // Does "(x pred y) ? x : y" represent the desired max/min operation?
1788    if (!Pred_t::match(Pred))
1789      return false;
1790    // It does!  Bind the operands.
1791    return (L.match(LHS) && R.match(RHS)) ||
1792           (Commutable && L.match(RHS) && R.match(LHS));
1793  }
1794};
1795 
1796/// Helper class for identifying signed max predicates.
1797struct smax_pred_ty {
1798  static bool match(ICmpInst::Predicate Pred) {
1799    return Pred == CmpInst::ICMP_SGT || Pred == CmpInst::ICMP_SGE;
1800  }
1801};
1802 
1803/// Helper class for identifying signed min predicates.
1804struct smin_pred_ty {
1805  static bool match(ICmpInst::Predicate Pred) {
1806    return Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_SLE;
1807  }
1808};
1809 
1810/// Helper class for identifying unsigned max predicates.
1811struct umax_pred_ty {
1812  static bool match(ICmpInst::Predicate Pred) {
1813    return Pred == CmpInst::ICMP_UGT || Pred == CmpInst::ICMP_UGE;
1814  }
1815};
1816 
1817/// Helper class for identifying unsigned min predicates.
1818struct umin_pred_ty {
1819  static bool match(ICmpInst::Predicate Pred) {
1820    return Pred == CmpInst::ICMP_ULT || Pred == CmpInst::ICMP_ULE;
1821  }
1822};
1823 
1824/// Helper class for identifying ordered max predicates.
1825struct ofmax_pred_ty {
1826  static bool match(FCmpInst::Predicate Pred) {
1827    return Pred == CmpInst::FCMP_OGT || Pred == CmpInst::FCMP_OGE;
1828  }
1829};
1830 
1831/// Helper class for identifying ordered min predicates.
1832struct ofmin_pred_ty {
1833  static bool match(FCmpInst::Predicate Pred) {
1834    return Pred == CmpInst::FCMP_OLT || Pred == CmpInst::FCMP_OLE;
1835  }
1836};
1837 
1838/// Helper class for identifying unordered max predicates.
1839struct ufmax_pred_ty {
1840  static bool match(FCmpInst::Predicate Pred) {
1841    return Pred == CmpInst::FCMP_UGT || Pred == CmpInst::FCMP_UGE;
1842  }
1843};
1844 
1845/// Helper class for identifying unordered min predicates.
1846struct ufmin_pred_ty {
1847  static bool match(FCmpInst::Predicate Pred) {
1848    return Pred == CmpInst::FCMP_ULT || Pred == CmpInst::FCMP_ULE;
1849  }
1850};
1851 
1852template <typename LHS, typename RHS>
1853inline MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty> m_SMax(const LHS &L,
1854                                                             const RHS &R) {
1855  return MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty>(L, R);
1856}
1857 
1858template <typename LHS, typename RHS>
1859inline MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty> m_SMin(const LHS &L,
1860                                                             const RHS &R) {
1861  return MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty>(L, R);
1862}
1863 
1864template <typename LHS, typename RHS>
1865inline MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty> m_UMax(const LHS &L,
1866                                                             const RHS &R) {
1867  return MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty>(L, R);
1868}
1869 
1870template <typename LHS, typename RHS>
1871inline MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty> m_UMin(const LHS &L,
1872                                                             const RHS &R) {
1873  return MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty>(L, R);
1874}
1875 
1876template <typename LHS, typename RHS>
1877inline match_combine_or<
1878    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty>,
1879                     MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty>>,
1880    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty>,
1881                     MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty>>>
1882m_MaxOrMin(const LHS &L, const RHS &R) {
1883  return m_CombineOr(m_CombineOr(m_SMax(L, R), m_SMin(L, R)),
1884                     m_CombineOr(m_UMax(L, R), m_UMin(L, R)));
1885}
1886 
1887/// Match an 'ordered' floating point maximum function.
1888/// Floating point has one special value 'NaN'. Therefore, there is no total
1889/// order. However, if we can ignore the 'NaN' value (for example, because of a
1890/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1891/// semantics. In the presence of 'NaN' we have to preserve the original
1892/// select(fcmp(ogt/ge, L, R), L, R) semantics matched by this predicate.
1893///
1894///                         max(L, R)  iff L and R are not NaN
1895///  m_OrdFMax(L, R) =      R          iff L or R are NaN
1896template <typename LHS, typename RHS>
1897inline MaxMin_match<FCmpInst, LHS, RHS, ofmax_pred_ty> m_OrdFMax(const LHS &L,
1898                                                                 const RHS &R) {
1899  return MaxMin_match<FCmpInst, LHS, RHS, ofmax_pred_ty>(L, R);
1900}
1901 
1902/// Match an 'ordered' floating point minimum function.
1903/// Floating point has one special value 'NaN'. Therefore, there is no total
1904/// order. However, if we can ignore the 'NaN' value (for example, because of a
1905/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1906/// semantics. In the presence of 'NaN' we have to preserve the original
1907/// select(fcmp(olt/le, L, R), L, R) semantics matched by this predicate.
1908///
1909///                         min(L, R)  iff L and R are not NaN
1910///  m_OrdFMin(L, R) =      R          iff L or R are NaN
1911template <typename LHS, typename RHS>
1912inline MaxMin_match<FCmpInst, LHS, RHS, ofmin_pred_ty> m_OrdFMin(const LHS &L,
1913                                                                 const RHS &R) {
1914  return MaxMin_match<FCmpInst, LHS, RHS, ofmin_pred_ty>(L, R);
1915}
1916 
1917/// Match an 'unordered' floating point maximum function.
1918/// Floating point has one special value 'NaN'. Therefore, there is no total
1919/// order. However, if we can ignore the 'NaN' value (for example, because of a
1920/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1921/// semantics. In the presence of 'NaN' we have to preserve the original
1922/// select(fcmp(ugt/ge, L, R), L, R) semantics matched by this predicate.
1923///
1924///                         max(L, R)  iff L and R are not NaN
1925///  m_UnordFMax(L, R) =    L          iff L or R are NaN
1926template <typename LHS, typename RHS>
1927inline MaxMin_match<FCmpInst, LHS, RHS, ufmax_pred_ty>
1928m_UnordFMax(const LHS &L, const RHS &R) {
1929  return MaxMin_match<FCmpInst, LHS, RHS, ufmax_pred_ty>(L, R);
1930}
1931 
1932/// Match an 'unordered' floating point minimum function.
1933/// Floating point has one special value 'NaN'. Therefore, there is no total
1934/// order. However, if we can ignore the 'NaN' value (for example, because of a
1935/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1936/// semantics. In the presence of 'NaN' we have to preserve the original
1937/// select(fcmp(ult/le, L, R), L, R) semantics matched by this predicate.
1938///
1939///                          min(L, R)  iff L and R are not NaN
1940///  m_UnordFMin(L, R) =     L          iff L or R are NaN
1941template <typename LHS, typename RHS>
1942inline MaxMin_match<FCmpInst, LHS, RHS, ufmin_pred_ty>
1943m_UnordFMin(const LHS &L, const RHS &R) {
1944  return MaxMin_match<FCmpInst, LHS, RHS, ufmin_pred_ty>(L, R);
1945}
1946 
1947//===----------------------------------------------------------------------===//
1948// Matchers for overflow check patterns: e.g. (a + b) u< a, (a ^ -1) <u b
1949// Note that S might be matched to other instructions than AddInst.
1950//
1951 
1952template <typename LHS_t, typename RHS_t, typename Sum_t>
1953struct UAddWithOverflow_match {
1954  LHS_t L;
1955  RHS_t R;
1956  Sum_t S;
1957 
1958  UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
1959      : L(L), R(R), S(S) {}
1960 
1961  template <typename OpTy> bool match(OpTy *V) {
1962    Value *ICmpLHS, *ICmpRHS;
1963    ICmpInst::Predicate Pred;
1964    if (!m_ICmp(Pred, m_Value(ICmpLHS), m_Value(ICmpRHS)).match(V))
1965      return false;
1966 
1967    Value *AddLHS, *AddRHS;
1968    auto AddExpr = m_Add(m_Value(AddLHS), m_Value(AddRHS));
1969 
1970    // (a + b) u< a, (a + b) u< b
1971    if (Pred == ICmpInst::ICMP_ULT)
1972      if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
1973        return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
1974 
1975    // a >u (a + b), b >u (a + b)
1976    if (Pred == ICmpInst::ICMP_UGT)
1977      if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
1978        return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
1979 
1980    Value *Op1;
1981    auto XorExpr = m_OneUse(m_Xor(m_Value(Op1), m_AllOnes()));
1982    // (a ^ -1) <u b
1983    if (Pred == ICmpInst::ICMP_ULT) {
1984      if (XorExpr.match(ICmpLHS))
1985        return L.match(Op1) && R.match(ICmpRHS) && S.match(ICmpLHS);
1986    }
1987    //  b > u (a ^ -1)
1988    if (Pred == ICmpInst::ICMP_UGT) {
1989      if (XorExpr.match(ICmpRHS))
1990        return L.match(Op1) && R.match(ICmpLHS) && S.match(ICmpRHS);
1991    }
1992 
1993    // Match special-case for increment-by-1.
1994    if (Pred == ICmpInst::ICMP_EQ) {
1995      // (a + 1) == 0
1996      // (1 + a) == 0
1997      if (AddExpr.match(ICmpLHS) && m_ZeroInt().match(ICmpRHS) &&
1998          (m_One().match(AddLHS) || m_One().match(AddRHS)))
1999        return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
2000      // 0 == (a + 1)
2001      // 0 == (1 + a)
2002      if (m_ZeroInt().match(ICmpLHS) && AddExpr.match(ICmpRHS) &&
2003          (m_One().match(AddLHS) || m_One().match(AddRHS)))
2004        return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
2005    }
2006 
2007    return false;
2008  }
2009};
2010 
2011/// Match an icmp instruction checking for unsigned overflow on addition.
2012///
2013/// S is matched to the addition whose result is being checked for overflow, and
2014/// L and R are matched to the LHS and RHS of S.
2015template <typename LHS_t, typename RHS_t, typename Sum_t>
2016UAddWithOverflow_match<LHS_t, RHS_t, Sum_t>
2017m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S) {
2018  return UAddWithOverflow_match<LHS_t, RHS_t, Sum_t>(L, R, S);
2019}
2020 
2021template <typename Opnd_t> struct Argument_match {
2022  unsigned OpI;
2023  Opnd_t Val;
2024 
2025  Argument_match(unsigned OpIdx, const Opnd_t &V) : OpI(OpIdx), Val(V) {}
2026 
2027  template <typename OpTy> bool match(OpTy *V) {
2028    // FIXME: Should likely be switched to use `CallBase`.
2029    if (const auto *CI = dyn_cast<CallInst>(V))
34
←
Assuming 'CI' is non-null→
35
←
Taking true branch→
2030      return Val.match(CI->getArgOperand(OpI));
36
←
Value assigned to 'X'→
2031    return false;
2032  }
2033};
2034 
2035/// Match an argument.
2036template <unsigned OpI, typename Opnd_t>
2037inline Argument_match<Opnd_t> m_Argument(const Opnd_t &Op) {
2038  return Argument_match<Opnd_t>(OpI, Op);
20
←
Returning without writing to 'Op.VR'→
2039}
2040 
2041/// Intrinsic matchers.
2042struct IntrinsicID_match {
2043  unsigned ID;
2044 
2045  IntrinsicID_match(Intrinsic::ID IntrID) : ID(IntrID) {}
2046 
2047  template <typename OpTy> bool match(OpTy *V) {
2048    if (const auto *CI = dyn_cast<CallInst>(V))
2049      if (const auto *F = CI->getCalledFunction())
2050        return F->getIntrinsicID() == ID;
2051    return false;
2052  }
2053};
2054 
2055/// Intrinsic matches are combinations of ID matchers, and argument
2056/// matchers. Higher arity matcher are defined recursively in terms of and-ing
2057/// them with lower arity matchers. Here's some convenient typedefs for up to
2058/// several arguments, and more can be added as needed
2059template <typename T0 = void, typename T1 = void, typename T2 = void,
2060          typename T3 = void, typename T4 = void, typename T5 = void,
2061          typename T6 = void, typename T7 = void, typename T8 = void,
2062          typename T9 = void, typename T10 = void>
2063struct m_Intrinsic_Ty;
2064template <typename T0> struct m_Intrinsic_Ty<T0> {
2065  using Ty = match_combine_and<IntrinsicID_match, Argument_match<T0>>;
2066};
2067template <typename T0, typename T1> struct m_Intrinsic_Ty<T0, T1> {
2068  using Ty =
2069      match_combine_and<typename m_Intrinsic_Ty<T0>::Ty, Argument_match<T1>>;
2070};
2071template <typename T0, typename T1, typename T2>
2072struct m_Intrinsic_Ty<T0, T1, T2> {
2073  using Ty = match_combine_and<typename m_Intrinsic_Ty<T0, T1>::Ty,
2074                               Argument_match<T2>>;
2075};
2076template <typename T0, typename T1, typename T2, typename T3>
2077struct m_Intrinsic_Ty<T0, T1, T2, T3> {
2078  using Ty = match_combine_and<typename m_Intrinsic_Ty<T0, T1, T2>::Ty,
2079                               Argument_match<T3>>;
2080};
2081 
2082template <typename T0, typename T1, typename T2, typename T3, typename T4>
2083struct m_Intrinsic_Ty<T0, T1, T2, T3, T4> {
2084  using Ty = match_combine_and<typename m_Intrinsic_Ty<T0, T1, T2, T3>::Ty,
2085                               Argument_match<T4>>;
2086};
2087 
2088template <typename T0, typename T1, typename T2, typename T3, typename T4,
2089          typename T5>
2090struct m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5> {
2091  using Ty = match_combine_and<typename m_Intrinsic_Ty<T0, T1, T2, T3, T4>::Ty,
2092                               Argument_match<T5>>;
2093};
2094 
2095/// Match intrinsic calls like this:
2096/// m_Intrinsic<Intrinsic::fabs>(m_Value(X))
2097template <Intrinsic::ID IntrID> inline IntrinsicID_match m_Intrinsic() {
2098  return IntrinsicID_match(IntrID);
2099}
2100 
2101/// Matches MaskedLoad Intrinsic.
2102template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2103inline typename m_Intrinsic_Ty<Opnd0, Opnd1, Opnd2, Opnd3>::Ty
2104m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2105             const Opnd3 &Op3) {
2106  return m_Intrinsic<Intrinsic::masked_load>(Op0, Op1, Op2, Op3);
2107}
2108 
2109/// Matches MaskedGather Intrinsic.
2110template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2111inline typename m_Intrinsic_Ty<Opnd0, Opnd1, Opnd2, Opnd3>::Ty
2112m_MaskedGather(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2113               const Opnd3 &Op3) {
2114  return m_Intrinsic<Intrinsic::masked_gather>(Op0, Op1, Op2, Op3);
2115}
2116 
2117template <Intrinsic::ID IntrID, typename T0>
2118inline typename m_Intrinsic_Ty<T0>::Ty m_Intrinsic(const T0 &Op0) {
2119  return m_CombineAnd(m_Intrinsic<IntrID>(), m_Argument<0>(Op0));
19
←
Calling 'm_Argument<0U, llvm::PatternMatch::bind_ty<llvm::Value>>'→
21
←
Returning from 'm_Argument<0U, llvm::PatternMatch::bind_ty<llvm::Value>>'→
22
←
Calling 'm_CombineAnd<llvm::PatternMatch::IntrinsicID_match, llvm::PatternMatch::Argument_match<llvm::PatternMatch::bind_ty<llvm::Value>>>'→
24
←
Returning from 'm_CombineAnd<llvm::PatternMatch::IntrinsicID_match, llvm::PatternMatch::Argument_match<llvm::PatternMatch::bind_ty<llvm::Value>>>'→
25
←
Returning without writing to 'Op0.VR'→
2120}
2121 
2122template <Intrinsic::ID IntrID, typename T0, typename T1>
2123inline typename m_Intrinsic_Ty<T0, T1>::Ty m_Intrinsic(const T0 &Op0,
2124                                                       const T1 &Op1) {
2125  return m_CombineAnd(m_Intrinsic<IntrID>(Op0), m_Argument<1>(Op1));
18
←
Calling 'm_Intrinsic<318U, llvm::PatternMatch::bind_ty<llvm::Value>>'→
26
←
Returning from 'm_Intrinsic<318U, llvm::PatternMatch::bind_ty<llvm::Value>>'→
27
←
Returning without writing to 'Op0.VR'→
2126}
2127 
2128template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2>
2129inline typename m_Intrinsic_Ty<T0, T1, T2>::Ty
2130m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2) {
2131  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1), m_Argument<2>(Op2));
2132}
2133 
2134template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2135          typename T3>
2136inline typename m_Intrinsic_Ty<T0, T1, T2, T3>::Ty
2137m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3) {
2138  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
2139}
2140 
2141template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2142          typename T3, typename T4>
2143inline typename m_Intrinsic_Ty<T0, T1, T2, T3, T4>::Ty
2144m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2145            const T4 &Op4) {
2146  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
2147                      m_Argument<4>(Op4));
2148}
2149 
2150template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2151          typename T3, typename T4, typename T5>
2152inline typename m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5>::Ty
2153m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2154            const T4 &Op4, const T5 &Op5) {
2155  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
2156                      m_Argument<5>(Op5));
2157}
2158 
2159// Helper intrinsic matching specializations.
2160template <typename Opnd0>
2161inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BitReverse(const Opnd0 &Op0) {
2162  return m_Intrinsic<Intrinsic::bitreverse>(Op0);
2163}
2164 
2165template <typename Opnd0>
2166inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BSwap(const Opnd0 &Op0) {
2167  return m_Intrinsic<Intrinsic::bswap>(Op0);
2168}
2169 
2170template <typename Opnd0>
2171inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FAbs(const Opnd0 &Op0) {
2172  return m_Intrinsic<Intrinsic::fabs>(Op0);
2173}
2174 
2175template <typename Opnd0>
2176inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FCanonicalize(const Opnd0 &Op0) {
2177  return m_Intrinsic<Intrinsic::canonicalize>(Op0);
2178}
2179 
2180template <typename Opnd0, typename Opnd1>
2181inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMin(const Opnd0 &Op0,
2182                                                        const Opnd1 &Op1) {
2183  return m_Intrinsic<Intrinsic::minnum>(Op0, Op1);
2184}
2185 
2186template <typename Opnd0, typename Opnd1>
2187inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMax(const Opnd0 &Op0,
2188                                                        const Opnd1 &Op1) {
2189  return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
2190}
2191 
2192template <typename Opnd0, typename Opnd1, typename Opnd2>
2193inline typename m_Intrinsic_Ty<Opnd0, Opnd1, Opnd2>::Ty
2194m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2195  return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
2196}
2197 
2198template <typename Opnd0, typename Opnd1, typename Opnd2>
2199inline typename m_Intrinsic_Ty<Opnd0, Opnd1, Opnd2>::Ty
2200m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2201  return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
2202}
2203 
2204template <typename Opnd0>
2205inline typename m_Intrinsic_Ty<Opnd0>::Ty m_Sqrt(const Opnd0 &Op0) {
2206  return m_Intrinsic<Intrinsic::sqrt>(Op0);
2207}
2208 
2209template <typename Opnd0, typename Opnd1>
2210inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_CopySign(const Opnd0 &Op0,
2211                                                            const Opnd1 &Op1) {
2212  return m_Intrinsic<Intrinsic::copysign>(Op0, Op1);
2213}
2214 
2215template <typename Opnd0>
2216inline typename m_Intrinsic_Ty<Opnd0>::Ty m_VecReverse(const Opnd0 &Op0) {
2217  return m_Intrinsic<Intrinsic::experimental_vector_reverse>(Op0);
2218}
2219 
2220//===----------------------------------------------------------------------===//
2221// Matchers for two-operands operators with the operators in either order
2222//
2223 
2224/// Matches a BinaryOperator with LHS and RHS in either order.
2225template <typename LHS, typename RHS>
2226inline AnyBinaryOp_match<LHS, RHS, true> m_c_BinOp(const LHS &L, const RHS &R) {
2227  return AnyBinaryOp_match<LHS, RHS, true>(L, R);
2228}
2229 
2230/// Matches an ICmp with a predicate over LHS and RHS in either order.
2231/// Swaps the predicate if operands are commuted.
2232template <typename LHS, typename RHS>
2233inline CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate, true>
2234m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
2235  return CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate, true>(Pred, L,
2236                                                                       R);
2237}
2238 
2239/// Matches a specific opcode with LHS and RHS in either order.
2240template <typename LHS, typename RHS>
2241inline SpecificBinaryOp_match<LHS, RHS, true>
2242m_c_BinOp(unsigned Opcode, const LHS &L, const RHS &R) {
2243  return SpecificBinaryOp_match<LHS, RHS, true>(Opcode, L, R);
2244}
2245 
2246/// Matches a Add with LHS and RHS in either order.
2247template <typename LHS, typename RHS>
2248inline BinaryOp_match<LHS, RHS, Instruction::Add, true> m_c_Add(const LHS &L,
2249                                                                const RHS &R) {
2250  return BinaryOp_match<LHS, RHS, Instruction::Add, true>(L, R);
2251}
2252 
2253/// Matches a Mul with LHS and RHS in either order.
2254template <typename LHS, typename RHS>
2255inline BinaryOp_match<LHS, RHS, Instruction::Mul, true> m_c_Mul(const LHS &L,
2256                                                                const RHS &R) {
2257  return BinaryOp_match<LHS, RHS, Instruction::Mul, true>(L, R);
2258}
2259 
2260/// Matches an And with LHS and RHS in either order.
2261template <typename LHS, typename RHS>
2262inline BinaryOp_match<LHS, RHS, Instruction::And, true> m_c_And(const LHS &L,
2263                                                                const RHS &R) {
2264  return BinaryOp_match<LHS, RHS, Instruction::And, true>(L, R);
2265}
2266 
2267/// Matches an Or with LHS and RHS in either order.
2268template <typename LHS, typename RHS>
2269inline BinaryOp_match<LHS, RHS, Instruction::Or, true> m_c_Or(const LHS &L,
2270                                                              const RHS &R) {
2271  return BinaryOp_match<LHS, RHS, Instruction::Or, true>(L, R);
2272}
2273 
2274/// Matches an Xor with LHS and RHS in either order.
2275template <typename LHS, typename RHS>
2276inline BinaryOp_match<LHS, RHS, Instruction::Xor, true> m_c_Xor(const LHS &L,
2277                                                                const RHS &R) {
2278  return BinaryOp_match<LHS, RHS, Instruction::Xor, true>(L, R);
2279}
2280 
2281/// Matches a 'Neg' as 'sub 0, V'.
2282template <typename ValTy>
2283inline BinaryOp_match<cst_pred_ty<is_zero_int>, ValTy, Instruction::Sub>
2284m_Neg(const ValTy &V) {
2285  return m_Sub(m_ZeroInt(), V);
2286}
2287 
2288/// Matches a 'Neg' as 'sub nsw 0, V'.
2289template <typename ValTy>
2290inline OverflowingBinaryOp_match<cst_pred_ty<is_zero_int>, ValTy,
2291                                 Instruction::Sub,
2292                                 OverflowingBinaryOperator::NoSignedWrap>
2293m_NSWNeg(const ValTy &V) {
2294  return m_NSWSub(m_ZeroInt(), V);
2295}
2296 
2297/// Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
2298/// NOTE: we first match the 'Not' (by matching '-1'),
2299/// and only then match the inner matcher!
2300template <typename ValTy>
2301inline BinaryOp_match<cst_pred_ty<is_all_ones>, ValTy, Instruction::Xor, true>
2302m_Not(const ValTy &V) {
2303  return m_c_Xor(m_AllOnes(), V);
2304}
2305 
2306template <typename ValTy> struct NotForbidUndef_match {
2307  ValTy Val;
2308  NotForbidUndef_match(const ValTy &V) : Val(V) {}
2309 
2310  template <typename OpTy> bool match(OpTy *V) {
2311    // We do not use m_c_Xor because that could match an arbitrary APInt that is
2312    // not -1 as C and then fail to match the other operand if it is -1.
2313    // This code should still work even when both operands are constants.
2314    Value *X;
2315    const APInt *C;
2316    if (m_Xor(m_Value(X), m_APIntForbidUndef(C)).match(V) && C->isAllOnes())
2317      return Val.match(X);
2318    if (m_Xor(m_APIntForbidUndef(C), m_Value(X)).match(V) && C->isAllOnes())
2319      return Val.match(X);
2320    return false;
2321  }
2322};
2323 
2324/// Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'. For vectors, the
2325/// constant value must be composed of only -1 scalar elements.
2326template <typename ValTy>
2327inline NotForbidUndef_match<ValTy> m_NotForbidUndef(const ValTy &V) {
2328  return NotForbidUndef_match<ValTy>(V);
2329}
2330 
2331/// Matches an SMin with LHS and RHS in either order.
2332template <typename LHS, typename RHS>
2333inline MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true>
2334m_c_SMin(const LHS &L, const RHS &R) {
2335  return MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true>(L, R);
2336}
2337/// Matches an SMax with LHS and RHS in either order.
2338template <typename LHS, typename RHS>
2339inline MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty, true>
2340m_c_SMax(const LHS &L, const RHS &R) {
2341  return MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty, true>(L, R);
2342}
2343/// Matches a UMin with LHS and RHS in either order.
2344template <typename LHS, typename RHS>
2345inline MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty, true>
2346m_c_UMin(const LHS &L, const RHS &R) {
2347  return MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty, true>(L, R);
2348}
2349/// Matches a UMax with LHS and RHS in either order.
2350template <typename LHS, typename RHS>
2351inline MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty, true>
2352m_c_UMax(const LHS &L, const RHS &R) {
2353  return MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty, true>(L, R);
2354}
2355 
2356template <typename LHS, typename RHS>
2357inline match_combine_or<
2358    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty, true>,
2359                     MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true>>,
2360    match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty, true>,
2361                     MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty, true>>>
2362m_c_MaxOrMin(const LHS &L, const RHS &R) {
2363  return m_CombineOr(m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R)),
2364                     m_CombineOr(m_c_UMax(L, R), m_c_UMin(L, R)));
2365}
2366 
2367/// Matches FAdd with LHS and RHS in either order.
2368template <typename LHS, typename RHS>
2369inline BinaryOp_match<LHS, RHS, Instruction::FAdd, true>
2370m_c_FAdd(const LHS &L, const RHS &R) {
2371  return BinaryOp_match<LHS, RHS, Instruction::FAdd, true>(L, R);
2372}
2373 
2374/// Matches FMul with LHS and RHS in either order.
2375template <typename LHS, typename RHS>
2376inline BinaryOp_match<LHS, RHS, Instruction::FMul, true>
2377m_c_FMul(const LHS &L, const RHS &R) {
2378  return BinaryOp_match<LHS, RHS, Instruction::FMul, true>(L, R);
2379}
2380 
2381template <typename Opnd_t> struct Signum_match {
2382  Opnd_t Val;
2383  Signum_match(const Opnd_t &V) : Val(V) {}
2384 
2385  template <typename OpTy> bool match(OpTy *V) {
2386    unsigned TypeSize = V->getType()->getScalarSizeInBits();
2387    if (TypeSize == 0)
2388      return false;
2389 
2390    unsigned ShiftWidth = TypeSize - 1;
2391    Value *OpL = nullptr, *OpR = nullptr;
2392 
2393    // This is the representation of signum we match:
2394    //
2395    //  signum(x) == (x >> 63) | (-x >>u 63)
2396    //
2397    // An i1 value is its own signum, so it's correct to match
2398    //
2399    //  signum(x) == (x >> 0)  | (-x >>u 0)
2400    //
2401    // for i1 values.
2402 
2403    auto LHS = m_AShr(m_Value(OpL), m_SpecificInt(ShiftWidth));
2404    auto RHS = m_LShr(m_Neg(m_Value(OpR)), m_SpecificInt(ShiftWidth));
2405    auto Signum = m_Or(LHS, RHS);
2406 
2407    return Signum.match(V) && OpL == OpR && Val.match(OpL);
2408  }
2409};
2410 
2411/// Matches a signum pattern.
2412///
2413/// signum(x) =
2414///      x >  0  ->  1
2415///      x == 0  ->  0
2416///      x <  0  -> -1
2417template <typename Val_t> inline Signum_match<Val_t> m_Signum(const Val_t &V) {
2418  return Signum_match<Val_t>(V);
2419}
2420 
2421template <int Ind, typename Opnd_t> struct ExtractValue_match {
2422  Opnd_t Val;
2423  ExtractValue_match(const Opnd_t &V) : Val(V) {}
2424 
2425  template <typename OpTy> bool match(OpTy *V) {
2426    if (auto *I = dyn_cast<ExtractValueInst>(V)) {
2427      // If Ind is -1, don't inspect indices
2428      if (Ind != -1 &&
2429          !(I->getNumIndices() == 1 && I->getIndices()[0] == (unsigned)Ind))
2430        return false;
2431      return Val.match(I->getAggregateOperand());
2432    }
2433    return false;
2434  }
2435};
2436 
2437/// Match a single index ExtractValue instruction.
2438/// For example m_ExtractValue<1>(...)
2439template <int Ind, typename Val_t>
2440inline ExtractValue_match<Ind, Val_t> m_ExtractValue(const Val_t &V) {
2441  return ExtractValue_match<Ind, Val_t>(V);
2442}
2443 
2444/// Match an ExtractValue instruction with any index.
2445/// For example m_ExtractValue(...)
2446template <typename Val_t>
2447inline ExtractValue_match<-1, Val_t> m_ExtractValue(const Val_t &V) {
2448  return ExtractValue_match<-1, Val_t>(V);
2449}
2450 
2451/// Matcher for a single index InsertValue instruction.
2452template <int Ind, typename T0, typename T1> struct InsertValue_match {
2453  T0 Op0;
2454  T1 Op1;
2455 
2456  InsertValue_match(const T0 &Op0, const T1 &Op1) : Op0(Op0), Op1(Op1) {}
2457 
2458  template <typename OpTy> bool match(OpTy *V) {
2459    if (auto *I = dyn_cast<InsertValueInst>(V)) {
2460      return Op0.match(I->getOperand(0)) && Op1.match(I->getOperand(1)) &&
2461             I->getNumIndices() == 1 && Ind == I->getIndices()[0];
2462    }
2463    return false;
2464  }
2465};
2466 
2467/// Matches a single index InsertValue instruction.
2468template <int Ind, typename Val_t, typename Elt_t>
2469inline InsertValue_match<Ind, Val_t, Elt_t> m_InsertValue(const Val_t &Val,
2470                                                          const Elt_t &Elt) {
2471  return InsertValue_match<Ind, Val_t, Elt_t>(Val, Elt);
2472}
2473 
2474/// Matches patterns for `vscale`. This can either be a call to `llvm.vscale` or
2475/// the constant expression
2476///  `ptrtoint(gep <vscale x 1 x i8>, <vscale x 1 x i8>* null, i32 1>`
2477/// under the right conditions determined by DataLayout.
2478struct VScaleVal_match {
2479  template <typename ITy> bool match(ITy *V) {
2480    if (m_Intrinsic<Intrinsic::vscale>().match(V))
2481      return true;
2482 
2483    Value *Ptr;
2484    if (m_PtrToInt(m_Value(Ptr)).match(V)) {
2485      if (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
2486        auto *DerefTy =
2487            dyn_cast<ScalableVectorType>(GEP->getSourceElementType());
2488        if (GEP->getNumIndices() == 1 && DerefTy &&
2489            DerefTy->getElementType()->isIntegerTy(8) &&
2490            m_Zero().match(GEP->getPointerOperand()) &&
2491            m_SpecificInt(1).match(GEP->idx_begin()->get()))
2492          return true;
2493      }
2494    }
2495 
2496    return false;
2497  }
2498};
2499 
2500inline VScaleVal_match m_VScale() {
2501  return VScaleVal_match();
2502}
2503 
2504template <typename LHS, typename RHS, unsigned Opcode, bool Commutable = false>
2505struct LogicalOp_match {
2506  LHS L;
2507  RHS R;
2508 
2509  LogicalOp_match(const LHS &L, const RHS &R) : L(L), R(R) {}
2510 
2511  template <typename T> bool match(T *V) {
2512    auto *I = dyn_cast<Instruction>(V);
2513    if (!I || !I->getType()->isIntOrIntVectorTy(1))
2514      return false;
2515 
2516    if (I->getOpcode() == Opcode) {
2517      auto *Op0 = I->getOperand(0);
2518      auto *Op1 = I->getOperand(1);
2519      return (L.match(Op0) && R.match(Op1)) ||
2520             (Commutable && L.match(Op1) && R.match(Op0));
2521    }
2522 
2523    if (auto *Select = dyn_cast<SelectInst>(I)) {
2524      auto *Cond = Select->getCondition();
2525      auto *TVal = Select->getTrueValue();
2526      auto *FVal = Select->getFalseValue();
2527 
2528      // Don't match a scalar select of bool vectors.
2529      // Transforms expect a single type for operands if this matches.
2530      if (Cond->getType() != Select->getType())
2531        return false;
2532 
2533      if (Opcode == Instruction::And) {
2534        auto *C = dyn_cast<Constant>(FVal);
2535        if (C && C->isNullValue())
2536          return (L.match(Cond) && R.match(TVal)) ||
2537                 (Commutable && L.match(TVal) && R.match(Cond));
2538      } else {
2539        assert(Opcode == Instruction::Or)(static_cast <bool> (Opcode == Instruction::Or) ? void (
0) : __assert_fail ("Opcode == Instruction::Or", "llvm/include/llvm/IR/PatternMatch.h"
, 2539, __extension__ __PRETTY_FUNCTION__));
2540        auto *C = dyn_cast<Constant>(TVal);
2541        if (C && C->isOneValue())
2542          return (L.match(Cond) && R.match(FVal)) ||
2543                 (Commutable && L.match(FVal) && R.match(Cond));
2544      }
2545    }
2546 
2547    return false;
2548  }
2549};
2550 
2551/// Matches L && R either in the form of L & R or L ? R : false.
2552/// Note that the latter form is poison-blocking.
2553template <typename LHS, typename RHS>
2554inline LogicalOp_match<LHS, RHS, Instruction::And> m_LogicalAnd(const LHS &L,
2555                                                                const RHS &R) {
2556  return LogicalOp_match<LHS, RHS, Instruction::And>(L, R);
2557}
2558 
2559/// Matches L && R where L and R are arbitrary values.
2560inline auto m_LogicalAnd() { return m_LogicalAnd(m_Value(), m_Value()); }
2561 
2562/// Matches L && R with LHS and RHS in either order.
2563template <typename LHS, typename RHS>
2564inline LogicalOp_match<LHS, RHS, Instruction::And, true>
2565m_c_LogicalAnd(const LHS &L, const RHS &R) {
2566  return LogicalOp_match<LHS, RHS, Instruction::And, true>(L, R);
2567}
2568 
2569/// Matches L || R either in the form of L | R or L ? true : R.
2570/// Note that the latter form is poison-blocking.
2571template <typename LHS, typename RHS>
2572inline LogicalOp_match<LHS, RHS, Instruction::Or> m_LogicalOr(const LHS &L,
2573                                                              const RHS &R) {
2574  return LogicalOp_match<LHS, RHS, Instruction::Or>(L, R);
2575}
2576 
2577/// Matches L || R where L and R are arbitrary values.
2578inline auto m_LogicalOr() { return m_LogicalOr(m_Value(), m_Value()); }
2579 
2580/// Matches L || R with LHS and RHS in either order.
2581template <typename LHS, typename RHS>
2582inline LogicalOp_match<LHS, RHS, Instruction::Or, true>
2583m_c_LogicalOr(const LHS &L, const RHS &R) {
2584  return LogicalOp_match<LHS, RHS, Instruction::Or, true>(L, R);
2585}
2586 
2587/// Matches either L && R or L || R,
2588/// either one being in the either binary or logical form.
2589/// Note that the latter form is poison-blocking.
2590template <typename LHS, typename RHS, bool Commutable = false>
2591inline auto m_LogicalOp(const LHS &L, const RHS &R) {
2592  return m_CombineOr(
2593      LogicalOp_match<LHS, RHS, Instruction::And, Commutable>(L, R),
2594      LogicalOp_match<LHS, RHS, Instruction::Or, Commutable>(L, R));
2595}
2596 
2597/// Matches either L && R or L || R where L and R are arbitrary values.
2598inline auto m_LogicalOp() { return m_LogicalOp(m_Value(), m_Value()); }
2599 
2600/// Matches either L && R or L || R with LHS and RHS in either order.
2601template <typename LHS, typename RHS>
2602inline auto m_c_LogicalOp(const LHS &L, const RHS &R) {
2603  return m_LogicalOp<LHS, RHS, /*Commutable=*/true>(L, R);
2604}
2605 
2606} // end namespace PatternMatch
2607} // end namespace llvm
2608 
2609#endif // LLVM_IR_PATTERNMATCH_H